Free cs software for linux

cs.edu Slax Live is a LiveCD for Computer Science Students.
The cs.edu edition of the Slax aims at providing the richness of GNU/Linux as a development environment to computer science students. The 650 MB of this CD are packed with programming tools and reference documentation. This distribution also tries to remain true to the Slackware tradition of simplicity.
Included Software:
- Compilers and interpreters for numerous programming languages: Ada, C/C++/ObjC/C#, Eiffel, Fortran, Haskell, Icon, Java, Lisp, OCaml, PHP, Perl, Prolog, Python, Ruby, Scheme, SmallTalk, Tcl/Tk, ...
- Development tools including make, autoconf, automake, arch, cvs, flex and bison, antlr, gdb, ddd, valgrind, ...
- The teTeX distribution.
- Browsable documentation for these, plus for several document formats (about 800 MB of documentation).
- GNU/Emacs with several modes: auctex, jdee and tuareg.
- A minimalist server configuration including apache and mysql.
- Enlightenment as the window manager.
- A few useful applications including gimp and mozilla.
Enhancements:
- added software, see complete list in installed_packages.txt
- added `nodma option to handle buggy DMA hardware
- added `kbd= option to set keyboard layout
- set imps/2 as the default mouse protocol
- set vga=773 as the default console text mode
- changed default refresh rates
- changed /etc/inittab to boot at runlevel 4 by default
- changed /etc/rc.d/rc.4 to handle Xorg auto-configuration
- added /etc/X11/xinit/xinitrc.guest as the root and slax xinitrc
- changed /etc/rc.d/rc.slax to handle random password generation
- added /sbin/slaxpasswd and a patched makepasswd
- changed /etc/sudoers, /etc/suauth, /etc/login.access
- changed /etc/rc.d/rc.httpd to generate apache configuration
- added /etc/apache/httpd.conf.bsm and /bin/bashmod for this
- changed /etc/rc.d/rc.mysqld to generate mysql table and random password
- changed /etc/profile and /etc/skel
- modified portions of /usr/bin/xconf
- added /etc/zprofile, /etc/zshrc
- changed DHCP client configuration
- added /etc/rc.d/rc.firewall
- configured some /etc/X11/apps-default/*
- changed mozillas default configuration in /usr/lib/mozilla/default
- added AdBlock and Themer mozillas extensions
- configured swaret
- configured gpg with the Slackware security key and my key
- put a 2.4.28-rc1 linux kernel
- added a hell of a lot of documentation, see /usr/doc and /usr/doc/languages
- added an ugly wallpaper

HCS Open Source Project consists of a do-it-yourself home automation hardware and software system.

The HCS Open Source Project is a stand-alone home automation control system which consists of hardware (main controllers and remote networked controllers) and software to monitor and control various devices around your house.

The current plans support using wired and wireless X10 modules, as well as analog, digital, and voice input and output. Once the HCS is programmed, the use of a PC is not required.

CS stands for Home Control System. Originally designed by Steve Ciarcia for the article "Home Run Control System" for Byte magazine.

What is the HCS II? The HCS II is an expandable, network-based (RS485), intelligent-node, industrial-oriented supervisory control system intended for demanding home control applications.

The HCS incorporates direct and remote digital inputs and outputs, direct and remote analog inputs and outputs, real-time or Boolean decision event triggering, X-10 transmission and reception, infrared remote control transmission and reception, remote LCD displays, and a master console.

The HCS II system architecture consists of a central supervisory controller (SC) connected to up to 32 other functional modules (called links) via a RS485 serial network. The SC and the COMM-Links can operate independently and dont need each other to function.

This allows easy testing or incorporation as intelligent subsystems in other control equipment. Initially the subsystems links all shared a comon 8031 controller board (generically called a COMM-Link) with the I/O customized for each application.

STUX is a bootable CD with a collection of GNU/Linux software, automatic hardware detection, and support for many graphics cards, sound cards, SCSI and USB devices and other peripherals.
Stux OS target is to build a Live CD similar to KNOPPIX but based on Slackware Linux.
Main features:
- Window Managers: KDE 3.1, Gnome 2.4, fvwm2, fvwm95, WindowMaker, Twm
- Browsers: Mozilla 1.6, Konqueror, Galeon, Nautilus, Lynx, KGet, wget, ...
- Mail clients: Mozilla Mail, KMail, mail, ...
- News readers: Mozilla News, Knode, Pan, ...
- Office, Word Processing, Editors: Open Office 1.1.0, KOffice, AbiWord, Kedit, KWrite, Kate, Xpdf, ...
- Services: Apache 1.3.28, ProFTPd 1.2.8p, Ample, Samba, Secure Shell, MySqld
- Multimedia: VideoLan Client 0.5.2, XawTV, gqRadio, Xine,...
- Graphics: the Gimp, KPaint, XPaint,...
- Developing: gcc 3.2.3, g++, J2sdk 1.4.2, perl 5.8.0, python 2.3.1, php 4.3.3, ...
- IRC Client: Kopete, KSirc, Chatzilla!
- AIM Client: Kopete, Kit
- ICQ Client: Kopete
- Peer 2 Peer/File sharing: BitTorrent, xMule
- Data Base: mysql 4.0.15a
- Web Applications: phpMyAdmin 2.5.5
- KDE Languages: AF, AR, BG, BS, CA, CS, DA, DE, EL, EN, EN_GB, EO, ES, ET, EU, FA, FI, FR, HE, HR, HU, IS, IT, JA, LT, MK, MT, NB, NL, NN, NSO, PL, PT, PT_BR, RO, RU, SE, SK, SL, SR, SS, SV, TA, TH, TR, UK, VEN, VI, XH, ZH_CN, ZH_TW, ZU
Enhancements:
- Upgraded to Slackware current as at 1 Jun 2007 and KNOPPIX live CD 5.1.1 (kernel 2.6.19); fixed problem with installation on SATA hard disks; all STUX utilities deeply reviewed; NVIDIA proprietary driver updated to 1.0-9755 + legacy driver 1.0-9631 for old cards; save live CD persistent configuration on ReiserFS partitions; install compressed image on ReiserFS partitions; Acx wireless firmware upgraded; fully integrates with other pre-installed operating systems; Compiz 0.5.0; fully VMware/QEMU compatible.

Audio::Ecasound is a Perl binding to the ecasound sampler, recorder, fx-processor.

SYNOPSIS
One function interface:
use Audio::Ecasound qw(:simple);

eci("cs-add play_chainsetup");
eci("c-add 1st_chain");
eci("-i:some_file.wav");
eci("-o:/dev/dsp");
# multiple n separated commands
eci("cop-add -efl:100
# with comments
cop-select 1
copp-select 1
cs-connect");
eci("start");
my $cutoff_inc = 500.0;
while (1) {
sleep(1);
last if eci("engine-status") ne "running";

my $curpos = eci("get-position");
last if $curpos > 15;

my $next_cutoff = $cutoff_inc + eci("copp-get");
# Optional float argument
eci("copp-set", $next_cutoff);
}
eci("stop");
eci("cs-disconnect");
print "Chain operator status: ", eci("cop-status");

Object Interface

use Audio::Ecasound;

my $e = new Audio::Ecasound;
$e->on_error();
$e->eci("cs-add play_chainsetup");
# etc.
Vanilla Ecasound Control Interface (See Ecasounds Programmer Guide):
use Audio::Ecasound qw(:std);

command("copp-get");
$precise_float = last_float() / 2;
command_float_arg("copp-set", $precise_float);
warn last_error() if error();
IAM Interface, pretend interactive mode commands are functions.
use Audio::Ecasound qw(:iam :simple);

# iam commands as functions with s/-/_/g
my $val = copp_get;
copp_set $val+0.1; # floats are stringified so beware
eci("-i /dev/dsp"); # not all commands are exported

Audio::Ecasound provides perl bindings to the ecasound control interface of the ecasound program. You can use perl to automate or interact with ecasound so you dont have to turn you back on the adoring masses packed into Wembly Stadium.
Ecasound is a software package designed for multitrack audio processing. It can be used for audio playback, recording, format conversions, effects processing, mixing, as a LADSPA plugin host and JACK node. Version >= 2.2.X must be installed to use this package. "SEE ALSO" for more info.

MIME::EncWords is a Perl module created to deal with RFC-1522 encoded words (improved).

SYNOPSIS

MIME::EncWords is aimed to be another implimentation of MIME::Words so that it will achive more exact conformance with MIME specifications. Additionally, it contains some improvements. Following synopsis and descriptions are inherited from its inspirer, with description of improvements and clarifications added.

Before reading further, you should see MIME::Tools to make sure that you understand where this module fits into the grand scheme of things. Go on, do it now. Ill wait.

Ready? Ok...

use MIME::EncWords qw(:all);

### Decode the string into another string, forgetting the charsets:
$decoded = decode_mimewords(
To: =?ISO-8859-1?Q?Keld_J=F8rn_Simonsen?= ,
);

### Split string into array of decoded [DATA,CHARSET] pairs:
AT decoded = decode_mimewords(
To: =?ISO-8859-1?Q?Keld_J=F8rn_Simonsen?= ,
);

### Encode a single unsafe word:
$encoded = encode_mimeword("xABFranxE7oisxBB");

### Encode a string, trying to find the unsafe words inside it:
$encoded = encode_mimewords("Me and xABFranxE7oisxBB in town");

Fellow Americans, you probably wont know what the hell this module is for. Europeans, Russians, et al, you probably do.

For example, heres a valid MIME header you might get:

From: =?US-ASCII?Q?Keith_Moore?= < moore AT utk.edu >
To: =?ISO-8859-1?Q?Keld_J=F8rn_Simonsen?= < keld AT dkuug.dk >
CC: =?ISO-8859-1?Q?Andr=E9_?= Pirard < PIRARD AT vm1.ulg.ac.be >
Subject: =?ISO-8859-1?B?SWYgeW91IGNhbiByZWFkIHRoaXMgeW8=?=
=?ISO-8859-2?B?dSB1bmRlcnN0YW5kIHRoZSBleGFtcGxlLg==?=
=?US-ASCII?Q?.._cool!?=

The fields basically decode to (sorry, I can only approximate the Latin characters with 7 bit sequences /o and e):

From: Keith Moore < moore AT cs.utk.edu >
To: Keld J/orn Simonsen < keld AT dkuug.dk >
CC: Andre Pirard < PIRARD AT vm1.ulg.ac.be >
Subject: If you can read this you understand the example... cool!

Supplement: Fellow Americans, Europeans, you probably wont know what the hell this module is for. East Asians, et al, you probably do.
For example, heres a valid MIME header you might get:

Subject: =?EUC-KR?B?sNTAuLinKGxhemluZXNzKSwgwvzB9ri7seIoaW1w?=
=?EUC-KR?B?YXRpZW5jZSksILGzuLgoaHVicmlzKQ==?=

The fields basically decode to (sorry, I cannot approximate the non-Latin multibyte characters with any 7 bit sequences):

Subject: ???(laziness), ????(impatience), ??(hubris)

bicl is a tool for editing the built-in command line boot arguments in binary files like the PPC64 Linux compressed kernel image and the PPC64 Xen compressed hypervisor boot image.

he boot argument processing for powerpc Xen is much less complex than it may appear. Assuming that the Simplify bootargs processing patch is accepted in some form, the following rules apply:

1. Arguments from 32-bit wrapper override all else
2. Builtin arguments in 64-bit image override firmware
3. Firmware is used if neither of the above exist

It is true that dom0 Linux has its own boot argument processing, but there is a simple transitive relation between Xens bootargs and Linuxs bootargs. That is, Xen first applies the above three rules to decide what to feed Linux. Linux then applies its three rules (it orders their precedence slightly differently) to decide what to feed the kernel proper.

The format of the builtin command line buffer is essentially just a seperate ELF section, which makes it easy for post-processing tools to locate it and edit it. If you have a 2.6.17 or later zImage kernel available, the following is illustrative:

$ objdump -h arch/powerpc/boot/zImage | grep cmdline
2 __builtin_cmdline 00000200 00406274 00406274 00016274 2**2

The format of the builtin command line buffer is simple, so many tools may one day understand it, but at present the most commonly-used tool is `bicl, which is shipped under the LGPL as part of the K42 source:

http://www.cs.unm.edu/~k42/tools/bicl

The usage of the tool is simple:

$ bicl
`builtin-cmdline manipulates builtin command line arguments

Usage: builtin-cmdline FILE [ARGS]
-?, --help Show this help statement.
--version Show version statement.

Examples: builtin-cmdline zImage

builtin-cmdline zImage console=ttyS0

The tool is used every day to edit the builtin command lines of Linux and Xen binaries as part of an internal IBM project.

Check Your Network Address Translator for Compatibility with Peer-to-Peer Protocols.
If you are accessing the Internet from behind a Network Address Translator (NAT) of some kind, I would appreciate your help in surveying the behavior of different NATs, in terms of how and whether they support a certain technique for enabling peer-to-peer communication between NATted hosts (particularly when both endpoints are behind NATs). Down, you can understand what NAT is.
Suppose there are three communicating hosts: A, B, and C. Host A is a "well-known" Internet server with a permanent IP address, which acts as an "introducer" for the other two nodes. (For example, Host A might be a well-known ultrapeer or a game catalog server of some kind.) Host B, using Host As "introduction" services, would like to establish a direct peer-to-peer connection with host C. Both B and C, however, are behind (probably different) network address/port translators, and neither of them has exclusive use of any public IP address.
To initiate a peer-to-peer connection with host C, host B first sends A a message requesting an "introduction" to host C. A sends B a reply message containing Cs IP address and UDP port number as reported by host C, in addition to Cs IP address and UDP port number as observed by A. (If C is behind a NAT, then these two address/port combinations will be different.) At the same time, host A sends host C a message containing Bs IP address and UDP port numbers - again, both the ones reported by B and the ones observed by A, which will be different if B is behind a NAT.
Now B and C each know that they want to initiate a connection with each other, and they know each others public (NATted) as well as original IP addresses and UDP port numbers. Both B and C now start attempting to send UDP messages directly to each other, at each of the available addresses. If B and C happen to be behind the same NAT, then they will be able to communicate with each other directly using their "originally reported" IP addresses and UDP port numbers.
In the more common case where B and C are behind different NATs, the "originally reported" addresses will be useless because they will both be private IP addresses in different addressing domains. Instead, the IP address/UDP port combinations observed by A can be used in this case to establish direct communication. Although Bs NAT will initially filter out any UDP packets arriving from Cs public (NATted) UDP port directed at Bs public port, the first UDP message B sends to C will cause Bs NAT to open up a new UDP session keyed on Cs public port, allowing future incoming traffic from C to pass through the NAT to B. Similarly, the first few messages from B to C may be filtered out by Cs NAT, but will be able to start passing through the firewall as soon as Cs first message to B causes Cs NAT to open up a new session. In this way, each NAT is tricked into thinking that its respective internal host is the "initiator" of this new session, when in fact the session is fully symmetrical and was initiated (with As help) simultaneously in each direction.
Required NAT Behavior
There is one important requirement that the NATs must satisfy in order for this technique to work: the NATs must be designed so that they assign only one (public IP address, public UDP port) pair to each (internal IP address, internal UDP port) combination, rather than allocating and assigning a new public UDP port for each new UDP session. Recall that a "session" in Internet terminology is defined by the IP addresses and port numbers of both communicating endpoints, so host Bs communication with host A is considered to be one session while host Bs communication with host C is a different session. If Bs NAT, for example, assigns one public UDP port for Bs communication with A, and then assigns B a different public UDP port for the new session B tries to open up with C, then the above technique for peer-to-peer communication will not work because Cs messages to B will be directed to the wrong UDP port.
RFC 3022 explicitly allows and suggests that NATs behave in the former, "desirable" fashion, by maintaining a single (public IP, public port) mapping for a given (internal IP, internal port) combination independent of the number of active sessions involving this mapping. This behavior is not only good for compatibility with UDP applications, but it also helps to conserve the NATs scarce pool of public port numbers. Maintaining a consistent public port mapping does not adversely affect security in any way, either, because incoming traffic can still be filtered on a per-session basis regardless of how addresses are translated. There in fact appears to be no good reason not to implement the desirable behavior in a NAT, except perhaps for the implementation simplicity of naively allocating a new public port for every new session. Unfortunately, RFC 3022 does not require NATs to implement the desirable behavior, which has led me to wonder just how many real NATs actually do, and hence this page.
What NAT Check Does
The program natcheck.c is basically just a program that "pings" a well-known UDP port at two different servers that are publically accessible on the Internet. Both of these servers run the program natserver.c, with the command-line arguments "1" and "2" respectively. In addition, there a third "conspiring" server runs natserver with the command-line argument "3". Whenever each of the first two servers receives a UDP request, it not only sends a reply directly to the sender of that request, but also sends a message to the third server, which in turn "bounces" the reply back to the original client. The effect is that the client will receive not only solicited "ping" replies from the server the request was directed to, but also "unsolicited" replies from the third server.
To determine if the network address translator in use is implementing the desirable behavior of maintaining a single (public IP address, public port) mapping for a given (client IP address, client port), the client program natcheck.c basically just initiates a sequence of simultaneous pings to the first two servers (in case some of the requests or replies are lost in transit) and checks that the clients address and UDP port as reported by both servers is the same. If the NAT naively allocates a new public port for each new session, then the source port as reported by the two servers will be different, and its time to upgrade your NAT.
The replies echoed from the third server are used only to check whether the NAT properly filters out unsolicited incoming traffic on a per-session basis. Since the client never sends any messages to the third server, if the NAT is properly implementing firewall functionality, the client should never see the third servers echoed replies even after opening up active communication sessions with the first two servers.
Enhancements:
- The NAT Check client no longer attempts to guess whether you have Basic NAT or Network Address/Port Translation (NAPT). It turns to be quite difficult to test for this property reliably, because many NAPTs attempt to bind a private UDP port to a public port with the same port number if that port number is available, causing NAT Check to falsely report Basic NAT. The only way to test for this property reliably would be to run NAT Check on at least two client machines simultaneously, and since this property isnt terribly important to P2P apps its just not worth the trouble.
- The NAT Check client now tests for one additional NAT feature, which I call loopback translation. If a NAT supports loopback translation, it means that a host on the private network behind the NAT can communicate with other hosts on the same private network using public (translated) port bindings assigned by the NAT. Most NATs probably do not support this feature yet, but it may become increasingly important in the future where P2P clients may be located behind a common ISP-deployed NAT as well as individual home NATs. More details on loopback translation will appear in the next version of my Internet-Draft, to be released soon.
- The NAT Check client program now has a command-line option, "-v", which turns on verbose messages during the test.

SPServer project is a server framework library written on C++ that implements the Half-Sync/Half-Async pattern.

SPServer is a server framework library written on C++ that implements the Half-Sync/Half-Async pattern ( http://www.cs.wustl.edu/~schmidt/PDF/HS-HA.pdf ). Its based on libevent in order to utilize the best I/O loop on any platform.

SPServer can simplify TCP server construction. It is a hybrid system between threaded and event-driven, and exploits the advantages of both programming models. It exposes a threaded programming style to programmers, while simultaneously using event-driven style to process network connection.