Free resembling software for linux

Symlinker is a minimalistic file manager that is built to primarily operate with symlinks. The project is written in PHP.
Why would I use it?
There are many PHP hosting providers nowadays. Unfortunately most of them only provides you FTP to upload your files to their servers which imposes several restrictions on you.
You probably use a content management systems (CMS) on your site and you may want to make multiply installations of the same CMS. Such an installation traditionally involves duplicating the complete directory structure of your CMS, but that may take much disk space and its painful to upgrade the individual installations this way. There is a much better way.
You can solve this problem by placing the directory structure of your CMS in only one directory and symlink the individual CMS instances that you want to use to point to this particular directory. This is called a symlink farm. Unfortunately its not possible to handle symlinks with FTP because the FTP protocol doesnt have such commands that operate on symlinks.
This scenario is a perfect one where Symlinker comes handy.
How can I install it?
1. Download symlinker.php and put it somewhere under your webspace.
2. Set the $password variable in the beginning of symlinker.php. This will be your login password that Symlinker will ask you upon login.
3. You may also set the $default_path variable in the beginning of symlinker.php. This will be your default path after login.
How can I use it?
First, point your browser to the URL where you put symlinker.php. Symlinker will ask you the login password, so enter it correctly and log in.
If everything went well, you should see a page that resembles the picture that you can see on the right side. Lets see what operations you can use here:
- You can navigate in the directory tree by using the navigation bar which resides in the top left corner of the page or editing the path argument in the URL.
- You can create a new symlink by entering the filename and the target of the symlink into the upper text fields and pressing the symlink button.
- You can update the target of the symlinks of the current directory by editing the text fields related to the specific filenames and pressing the update button.
- You can log out by visiting the logout link which resides in the top right corner of the page.
How can I set up a symlink farm?
To better understand how to set up a symlink farm, take a look at the picture on the right side.
I use the MediaWiki content management system here. I have a special directory, /web/monda/apps where I keep the installations of the CMSes that I use.
First, I create a symlink with the filename mediawiki which points to ../../apps/mediawiki-1.9.3, the exact version of the MediaWiki installation which I want to use within this directory. Later when I want to upgrade MediaWiki, I can just rename the target of this symlink to point to a more recent version of MediaWiki.
As you can see, most of the filenames in this directory are symlinked to mediawiki, but some are not. This is because most CMS holds some data which are specific to the individual CMS instances so they must have their own separate directory.
Enhancements:
- Logout works correctly.
- Works with register_globals turned off for better security.

Console Jabber Client is a Jabber client with text-based user interface resembling those known from popular IRC clients.

CJC is a Jabber/XMPP client for text terminals. Console Jabber Client uses pyxmpp library for XMPP comunication and curses for screen output. It is not finished yet, but still quite usable. Its user interface is resembling those of popular IRC clients like irssi or BitchX.

sinntp is a tiny NNTP client. sinntp virtually lacks any user interface: news messages are downloaded from a remote server and put into a local mailbox file.
About NNTP:
The Network News Transfer Protocol or NNTP is an Internet application protocol used primarily for reading and posting Usenet articles, as well as transferring news among news servers. Brian Kantor of the University of California, San Diego and Phil Lapsley of the University of California, Berkeley completed RFC 977, the specification for the Network News Transfer Protocol, in March 1986. Other contributors included Stan Barber from the Baylor College of Medicine and Erik Fair of Apple Computer.
Usenet was originally designed around the UUCP network, with most article transfers taking place over direct computer-to-computer telephone links. Readers and posters would log into the same computers that hosted the servers, reading the articles directly from the local disk.
As local area networks and the Internet became more commonly used, it became desirable to allow newsreaders to be run on personal computers, and a means of employing the Internet to handle article transfers was desired. Because networked Internet-compatible filesystems were not yet widely available, it was decided to develop a new protocol that resembled SMTP, but was tailored for reading newsgroups.
The well-known TCP port 119 is reserved for NNTP. When clients connect to a news server with SSL, TCP port 563 is used. This is sometimes referred to as NNTPS.
The protocol remains in widespread use, and as of 2005 efforts are underway to produce an updated standard. The IMAP protocol can also be used for reading newsgroups.
Enhancements:
- Reading messages is not stopped if reading a message failed.

fget is a commandline tool for mirroring remote files via FTP. It is based upon the included FTP client library, whose API is designed to resemble the normal Unix API for accessing files and directories.
This interface should make it very easy to integrate FTP support into other applications.
Main features:
- Small and fast.
- Remote directory caching built into the FTP client library.
- API designed to resemble the normal UNIX API for accessing files and directories, so its very easy to use.
Enhancements:
- fixed include file problem for cygwin
- misc code cleanups in fget code (added lots of comments)
- added fget "-S" option

Devel::TraceFuncs is a Perl module with trace function calls as they happen.

SYNOPSIS

Usage:

require Devel::TraceFuncs;

max_trace_depth 5;
trace_file "foo.out";
trace_file $file_handle;

sub foo {
IN(my $f, "a message");

DEBUG "hellooo!";
}

Devel::TraceFuncs provides utilities to trace the execution of a program. It can print traces that look something like:

+-> global: 0
| +-> main::fo(4, 5) (in ./t.pm:32): now then
| | +-> main::fp(4, 5) (in ./t.pm:19)
| | | +-> main::fq() (in ./t.pm:13)
| | | | que pee doll (in ./t.pm:8)
| | | +-< main::fq() (in ./t.pm:13)
| | | cee dee (in ./t.pm:14)
| | +-< main::fp(4, 5) (in ./t.pm:19)
| | ha
| | hs (in ./t.pm:20)
| +-< main::fo(4, 5) (in ./t.pm:32): now then
| done (in ./t.pm:34)
+-< global: 0

IN

A trace begins when a function calls IN. A myd variable is passed in, such that when that function exits, the destructor for the variable is called. If this trace is to be printed, the opening line of the trace in printed at this time. Any other parameters are concatenated together, and printed on both the opening and closing lines of the trace.

I wish the syntax could be a little nicer here, but I couldnt find anything in perl that resembles Tcls uplevel or upvar commands. If I was one of the perl gods, I could have figured out a way to do something like perl5db.pl:

sub sub {
# create a new subroutine, with a myd TraceFunc object
}

DEBUG

Print some text to the trace file, at the correct depth in the trace. If the last parameter ends in "!", the arguments are printed, regardless of current depth.

trace_file

trace_file takes one argument, which is either a file name or an open file handle. All trace output will go to this file.

max_trace_depth

To avoid lots of nesting, particularly from recursive function calls, you can set the maximum depth to be traced. If this is -1 (the default), all levels of functions are traced. If it is 0, no trace output occurs, except for DEBUG statements that end in "!".

SDLucid is a C++ wrapper library for the Simple Direct Media Layer by Sam Latinga. SDLucid aims to not only be a wrapper, but also to offer a cleaner interface than the original SDL as well as more functionality. Want to see it in action? Here is a screenshot of the example contained in the distribution, nicely showing off the transforms code. SDLucid provides all of the following features that are not provided in SDL:

- a nice interface
- fast graphics primitives (polygons, circles...) with arbitrary fill modes
- affine transformations on surfaces (i.e. stretching, rotation...)
- bitmap fonts
- mp3, mod, wav playing with arbitrary mixing and samplerate conversion.

When designing SDLucid, I tried to follow these guidelines:

- make a new and clean interface to SDL that stays as close as possible to SDL terminology, but no closer.
- implement mighty functionality thats easy to use (some of this functionality duplicates what is available as SDL_mixer,SDL_image,SDL_ttf etc)
- use naming conventions that loosely resemble those of the STL, so SDLucid doesnt introduce another naming scheme into a client program
- stick to one mighty image format: PNG
- use exceptions for error reporting

It mixes well with STL code. Installation and use is drop-dead easy because of supplied autoconf macros and an sdlucid-config shell script. SDLucid currently depends on

- a good c++ compiler (gcc 2.95 will do)
- SDL, obviously. :)
- ixlib, a C++ tool library.

Simple Sockets Library provides a simple C programming interface to sockets.
The Simple Sockets Library makes sockets easy to use and comes as public domain source code. It resembles Cs file I/O, uses whatever port is available, has named servers and port reuse, streaming/blocking sockets used, polling support, blocking/selection support via numerous functions, timeout control and firewall support.
Main features:
- Resembles Cs file i/o:
- Sclose() Sgets() Sopen() Sprintf() Sputs() Sread() Sscanf() Swrite() Svprintf()
- Uses currently available ports only, so if a server can be brought up, it will be
- Named sockets -- servers have names, not fixed port addresses!
- (no more REUSEADDR problems, linger setting, zombie sockets!)
- Streaming/blocking sockets used
- Polling supported (ie. avoids blocking):
- Stest() Smasktest() Speek()
- Numerous functions to handle multiple concurrent clients:
- Smaskfdset() Smaskpush() Smasktime() Smaskunset() Smaskwait()
- Smaskget() Smaskset() Smaskunfdset() Smaskuse() Sprtmask()
- Smaskpop() Smasktest()
- Timeout control:
- Stimeoutwait() Smasktime()
- The PortMaster (Spm): Maintains a distributed port/server-name database Each machine runs a PortMaster which maps servers by name to their ports (transparent to programmers and users!)
- Firewall Support
- The PortMaster can (optionally) only "put through" connections from approved machine sites
- Supports "path"ing for sockets: one can use an environment variable to track down a server, by name, on any machine in a group:
- Sopenv()
- Doesnt need root privileges (thats Unix lingo...)
- Now supports fixed ports (servers and/or clients) to facilitate interfacing to non-SSL servers/clients
The Simple Sockets Librarys main purpose is to provide an Application Programming Interface that strongly resembles the standard C librarys file handling interface. Thus programmers find that the Simple Sockets Librarys learning curve is particularly short. As a secondary purpose the Simple Sockets Library helps programmers avoid some common programming problems with sockets (avoided: large buffers that dont transfer in their entirety without special effort, the Nagle algorithms practical effect of often limiting one to five transfers per second, servers whose ports refuse to re-open until two minutes have passed, etc). Strings are null-byte terminated just like regular C/C++ strings, facilitating their ease of use in C/C++ programming.
The Simple Sockets Library preferentially uses names for its servers rather than requiring hard-coded port numbers. Imagine if, instead of files having names, everyone went about saying "use sector 4 and track 14" or somesuch thing. This situation reflects what we now have with sockets -- and when two programs use the same port number for their servers, they cant co-exist simultaneously on a system. However, especially for those whose programs must interface with other programs using hard-coded port numbers, the Simple Socket Library also supports hard-code port numbers.
The Simple Sockets Library opens streaming sockets. Thus the Simple Sockets Librarys sockets provide guaranteed delivery of information in the correct order (unlike datagrams, for example).
The PortMaster (Spm), source code for which is part of the library, provides a "phonebook" to map server names to dynamically allocated port numbers. Port numbers thus wont clash; the operating system determines which ones are currently available and the PortMasters effectively publish the result.
Enhancements:
- (Marcel Satchel) improved for Windows
- (Aug 22, 2005) included the "b" option for Sopen() (block until requested server becomes available)
- (Marcel Satchel) Sinit.c fixed (yet again!)