Free mimic software for linux

TookieMail is a webmail client. It mimics some of the things that Gmail does, such as the way attachments work and the auto-complete addressbook feature.

Currently, TookieMail only works with IMAP and SMTP. It has been tested with Courier IMAP only.

TookieMail project should work with any IMAP server that uses the "INBOX." prefix for folders.

Installation:

Head over to the config directory. Edit the server.php file.

Just put your info in place of the default info. Typically, it wont need to be changed unless your mail server is not on the local host.

The DLini library provides functions for reading and writing Windows style .ini files.
It mimics the Windows API for .ini file handling exactly, so it can be used to port Windows applications that use .ini files to other platforms.
Have you ever needed to port a Windows program to Linux or UNIX? Maybe its a legacy program and uses .ini files to read its settings.
This package provides all the necessary functions to read the .ini file, in just the same way as you would expect to read it under Windows using GetPrivateProfile style functions.
Enhancements:
- New functions completed: GetPrivateProfileStruct, GetPrivateProfileSection, and GetPrivateProfileSectionNames.
- Some optional debug output and an off-by-one error have been corrected.
- Autoconf/Automake scripts have been added.

mousikos is a portable audio/music player manager for GNOME. It is designed to be able to support various types of portable music players connected through the parallel port or a USB port. It currently does not support any existing players. A fake player mimicked by a directory on the hard disk is currently supported as proof of concept of the rest of the features.
It is being developed under Linux. It is written in C. It requires glib, gtk+ and gnome. I intend to un-gnome-ify it sometime as some people only use KDE. It will always rely on glib and gtk however. It is distributed under the GNU General Public License (GPL) version 2 of June 1991.
It differs from other gui front-ends in these ways ways:
It relies on playlists (m3u).
It filters on the fly from high bit rate file to low bitrate files. In some cases this can be achieved by bit pealing (ogg to ogg), in others by re-encoding. This allows more files to fit on the player. The filtering capabilities are customizable so one could also have, for example, 256KBps ogg VBR to a regular 112Kbps mp3s.
Main features:
- It uses a two pane window. One for player contents one for playlist. Other player managers only have one with the player contents
- It can support multiple types of players. To add support for a given player one file must be edited and two new files must be created: .c and .h. I hope this means that existing command line programs for other players can be adapted easily for use within mousikos.
- It features a bookmarks(hotlist) menu for quick access to favorite playlists.

libMAGE is a Multi-Agent Grid Engine library. libMAGE library an experiment aimed to make a programming tool for creation of autonomic systems. We define autonomic system as the system that has the following features:

- The system is composed from a set of intellectual agents. All decision-making in the system is distributed and has a form of self-organization.
- The system is able to adapt to the surrounding environment. This includes adaptation to CPU, memory and disk load, and node failure (self-healing). The system is allowed to allocate additional nodes or redistribute current resources.

In libMAGE every agent of the system can be viewed as a living cell in a biological organism. Every agent contains enough information for construction of the whole organism, however after going through the process of growth, which mimics morphogenesis, the agent gets specialized. Specialized agents form groups and function cooperatively.

MiniUPnP Client and Daemon is an UPnP IGD client lightweight library and UPnP IGD daemon.
The UPnP protocol is supported by most home adsl/cable routers and Windows 2K/XP. The aim of the MiniUpnp project is to bring a free software solution to support the "Internet Gateway Device" part of the protocol.
The Linux SDK for UPnP devices (libupnp) seems too heavy for me. I want the simplest library possible, with the smallest footprint and no dependencies to other libraries such as XML parsers or HTTP implementations. All the code is pure ANSI C.
Compiled on a x86 PC, the miniupnp client library have less than 15KB code size. For instance, the upnpc sample program is around 20KB.
The project is divided in two main parts : the client library, enabling applications to access the services provided by an UPnP "Internet Gateway Device" present on the network, and the miniupnpd daemon, providing these services to your network from a linux or bsd box being the gateway. At the moment the miniupnpd is developped on OpenBSD 3.0+ with pf. You can see some of the work I have done to integrate with pf on this page.
As pf is also available under FreeBSD, guys at the pfSense project have ported miniupnpd to this system.
For some reasons, it may be not the good solution for you to use the code from the MiniUPnP project directly.
As the code is small and simple to understand, it is a good base to take inspiration for your own UPnP implementation. The KTorrent team UPnP plugin in C++ is a good example.
If you are wondering which home router is working with the miniupnp client, you can find the answer here. In fact, you are more likely to help me fill the list by sending me an email.
Usefulness of the miniUPnP client library
The usage of the miniUPnP client library is useful whenever an application needs to listen for incoming connections.
Examples : P2P applications, FTP clients for active mode, IRC (for DCC) or IM applications, network games, any server.
The typical usage of UPnP capabilities of a router is a file tranfert using MSN messenger. The MSN Messenger software uses the UPnP API of Windows XP to open port for incoming connection. To mimic the MS software, it is a good idea to use UPnP as well.
Enhancements:
- This release adds changes to accommodate the Linux 2.6.22 kernel.

File::Maker is a Perl module that mimics a make by loading a database and calling targets methods.

SYNOPSIS

#####
# Subroutine interface
#
use File::Maker qw(load_db);

%data = load_db($pm);

######
# Object interface
#
require File::Maker;

$maker = $maker->load_db($pm);

$maker->make_targets(%targets, @targets, %options );
$maker->make_targets(%targets, %options );

$maker = new File::Maker(@options);

Generally, if a subroutine will process a list of options, @options, that subroutine will also process an array reference, @options, [@options], or hash reference, %options, {@options}. If a subroutine will process an array reference, @options, [@options], that subroutine will also process a hash reference, %options, {@options}. See the description for a subroutine for details and exceptions.

When porting low level C code from one architecture to another, makefiles do provide some level of automation and save some time. However, once Perl or another high-level language is up and running, the high-level language usually allows much more efficient use of programmers time; otherwise, whats point of the high-level language. Thus, makes great economically sense to switch from makefiles to high-level language.

The File::Maker program module provides a "make" style interface as shown in the herein above. The @targets contains a list of targets that mimics the targets of a makefile. The targets are subroutines written in Perl in a separate program module from the File::Maker. The separate target program module inherits the methods in the File::Maker program module as follows:

use File::Maker;
use vars qw( @ISA );
@ISA = qw(File::Maker);

The File::Maker methods will then find the target subroutines in the separate target program module.

The File::Maker provides for the loading of a hash from a program module to provide for the capabilities of defines in a makefile. The option pm = $file> tells File::Maker to load a database from the __DATA__ section of a program module that is in the Tie::Form format. The Tie::Form format is a very flexible lenient format that is about as close to a natural language form and still have the precision of being machine readable.

This provides a more flexible alternative to the defines in a makefile. The define hash is in a separate, very flexible form program module. This arrangement allows one target program module that inherits the File::Maker program module to produce as many different outputs as there are Tie::Form program modules.

GoboLinux is a Linux distribution that breaks with the historical Unix directory hierarchy. Basically, this means that there are no directories such as /usr and /etc. The main idea of the alternative hierarchy is to store all files belonging to an application in its own separate subtree; therefore we have directories such as /Programs/GCC/2.95.3/lib.
To allow the system to find these files, they are logically grouped in directories such as /System/Links/Executables, which, you guessed it, contains symbolic links to all executable files inside the Programs hierarchy.
To maintain backwards compatibility with traditional Unix/Linux apps, there are symbolic links that mimic the Unix tree, such as "/usr/bin -> /System/Links/Executables", and "/sbin -> /System/Links/Executables" (this example shows that arbitrary differentiations between files of the same category were also removed).
It is geared towards people who prefer to install applications from the original source packages. That is the main reason why each application gets its own directory: so you can install it from source there and then remove it with an "rm -rf". So, you see, GoboLinux is oriented at the experienced user who doesnt like things to be automagical. Our scripts merely automate procedures, but they dont "make decisions", and whenever they have to, they ask first.
The binary package collection was created as a way to avoid duplication of effort between users. The source package project was created to store "compilation rules" of the original source packages of the applications. We do not wish to estabilish a "packaging standard" such as RPM. We think that there is no real need for "packages" if the original .tar.gz is properly made. For instance, when an application uses the GNU AutoTools (autoconf, automake...) you dont need any GoboLinux package to keep your system consistent.
However, given the more logical directory tree, GoboLinux could be made, with a comprehensive binary package collection and graphical front-ends to the scripts, into a newbie-friendly distribution, but that is not a specific goal we seek (at least not in short or mid term).
GoboLinux relies on a series of tools that automate various tasks, such as generation, installation and removal of packages, and most importantly, maintainance of the symbolic links that keep the system consistent. These tools (mostly are shell scripts, actually) are fairly stable, since the idea behind GoboLinux is not new (see question about the origins of GoboLinux).
Another important issue when using a distribution is the availability of packages, ie, software that you can download in binary form and install in it straight away. In this aspect, GoboLinux is very young and far behind the other estabilished distributions. We have, however, all packages needed to get a running system (all packages that are part of "Linux From Scratch" and "Beyond Linux From Scratch" projects, for example), plus many others, such as KDE and all related packages, Tcl/Tk, and the list just wont stop growing. Check out the latest list. In this sense, is important to popin out that we are working to bring other distributions facilities, such as the Gentoo Portage system, to GoboLinux.
Enhancements:
- The first release candidate for GoboLinux 014 is out! Among other things, it includes a massive update of packages, including glibc 2.5, X.Org 7.2, GCC 4.1.2 and KDE 3.5.6, with Linux kernel 2.6.20.4 + UTF-8 support. We have now a better printing support, with a few basic drivers included in the live CD. And there were many, many bug fixes in the GoboLinux tools since 013, so we hope to provide a better experience for you all.