Free tux aqfh software for linux

This is a Gnome 2.X Icon-Theme of the Tux n Tosh iconset. Tux n Tosh also uses some Crystal icons to be more or less complete.

TUX is a kernel-based, threaded, extremely high-performance HTTP server.

TUX server is able to efficiently and safely serve both static and dynamic data.

TUX moves the HTTP protocol stack to the kernel, and can handle requests for data with both kernel-space and user-space modules.

TUX is a http-daemon (webserver) for Linux. TUX is different from other webservers in that it runs partially from within the Linux-kernel as a module (device driver). Given sufficiently-capable networking cards, it enables direct scatter-gather DMA and hardware-based TCP/IP checksumming from the page cache directly to the network, avoiding extra data copies.

TUX handles static pages directly, and can work in concert with kernel modules, user-space modules, and regular user-space web server daemons to provide dynamic content. Regular user-space daemons do not need to be altered in any way for TUX to use them to provide content, but in order for TUX to cache dynamic content, user-space code has to use a new interface based on the tux(2) system call.

Static web pages are not a very complex thing to serve, but these are very important nevertheless, since virtually all images are static, and a large portion of the html pages are static also. A "regular" webserver has little added value for static pages; it is simply a "copy file to network" operation. This can be done very efficiently from within the Linux kernel; for example, the nfs (network file system) daemon performs a similar task and also runs in the kernel.

But dynamic content is becoming a larger and larger part of the web, and TUX provides a way to cache dynamic content as well. TUX modules (which can be build in kernel space or in user space; user space is recommended) can create "objects" which are stored using the page cache. To respond to a request for dynamic data, a TUX module can send a mix of dynamically-generated data and cached pre-generated objects, taking maximal advantage of TUXs zero-copy architecture. (Kernel-space modules are currently the only modules capable of making use of TUXs SSI support; that will change in the future.)

This completely new architecture for providing dynamic content requires a new API. Existing standard APIs for CGI are not sufficient to be mapped to TUXs API. This means that existing CGI applications must be re-coded in order to take advantage of TUXs architecture. TUX can, however, call CGI programs via its CGI module, so you can choose to convert only programs that need TUXs speed to the TUX api and run other programs using the standard CGI interface. TUX can also redirect requests to another webserver, such as Apache, so on a single site, you can mix and match static content, TUX modules, old-style CGIs, and programs written to other webservers APIs.

Whenever TUX isnt sure what to do (that is, encounters input that it is not prepared to handle), it always redirects the request to Apache to handle in an RFC-compliant manner.

Note: This document sometimes uses "Apache" instead of "any webserver you might ever want to use", just for reasons of readability.

Tux Football is a 2D top down "Association Football" (Soccer) game.
Tux Football is a great 2D football game for Windows and Linux! Bringing old style gameplay back to the desktop with up to date graphics! For those people who remember and miss old classics such as Amcos Kick Off and Sensible Softwares Sensible Soccer.
Game play is designed to be quick, responsive and fun. You are always in control of the player closest to the ball. The ball is controled via two kick buttons - one for pass, and one for shoot.
Aftertouch can be applied to shots by quickly pressing and holding the direction you want the ball to bend towards. Pushing in the opposite direction to what you kicked the ball makes it raise into the air, pushing in the same direction as the ball makes it dip towards the ground.
Main features:
- Two Teams
- Pass, Kick, Tackles, Headers
- Aftertouch
- Bounds detection (i.e. we know when throw ins, goals, etc. happens)
- Realistic physics on the ball, including bouncing off goal posts.
- Title Screen, With menu.
- Sound Support, including sfx and music
- Computer controlled players
- Redefining keys, selecting number of players

Tuxanci is a multiplatform game, inspired by well-known czech game Bulanci (by the SleepTeam Labs team). The game is distributed under the GNU GPL license.
As a programing language for this project we have chosen C. Everything that has anything to do with graphics, sound or fonts, handle the SDL, SDL_image, SDL_mixer and SDL_ttf libraries, all of them distributed also as open source, exactly under GNU LGPL license.
The game
All graphics in both menu and game are original, altough we try to keep the similarity with Bulanci, at both controls and levels.
The menu environment is simple. All you need to set up a game is to choose players name, select a level (map) and go on. In future, we all hope there will be many other things you could set, though the current state is quite easy to use, dont you think so?
Controls
First player (the left side):
W -- move up
S -- move down
A -- move left
D -- move right
< Tab > -- use active weapon (shoot, put the mine, ...)
Second player (the right side):
Up array -- move up
Down array -- move down
Left array -- move left
Right array -- move right
0 (on the numeric keyboard) -- use active weapon (shoot, put the mine, ...)
Enhancements:
- fixed memory leaks
- bug fix, the program sometimes got frozen when Tux collided with a mine
- bug fix, Tux sometimes appeared on the same place
- when Tux teleports, it shows up after some time
- shoot from a pipe gets out after some time
- started commenting the source code (in *.h files)

A lightweight IRC bot/dictionary, easy to set up, easy to localize.

Installation:

1) Edit the configuration file in config/config.tux.dist, change all values to suit your needs and then rename it to config.tux. Take your time to read through it, there are quite a few aspects you can alter

2) Create a new MySQL database with the name you set for db_base in the configuration file

3) Create a new MySQL user and grant it all privileges to the database you just created.

4) Create the tables required by the bot entering the following command
mysql -u db_user -p db_base < tux.sql

5) edit config/hosts.dist, add your hostmask to the file, save and then rename it to hosts

6) Now you should be all set up, go to the directory where the main program is and try to run it by entering

./tuxaator

With a little luck, you will be connected to server and choose the channel.

If you also want the bot to announce Freshmeat news and give information about kernel releases if asked, read on. If not, youre finished.



Setting up the external scripts

Tuxaator relies on external scripts to gather various information of interest from the Net. The scripts are not called from the bot, but are to be run separately, for example from the crontab.

Right now I have implemented 2 sample scripts:
kernel.sh - retrieves information about the latest kernels
fetchfm.sh - retrieves latest news from FreshMeat

Both scripts are located in the "scripts" directory of the installation and have to be configured separately, it is pretty straightforward though, just open them in your favourite text editor and follow the instructions.

Refer to "man 5 crontab" for information on how to setup the cronjobs.

My configuration looks like this:
1,31 * * * * /home/duke/tuxaator/scripts/fetchfm.sh > /dev/null
55 * * * * /home/duke/tuxaator/scripts/kernel.sh > /dev/null

This is, freshmeat news are retrieved 1 and 31 minutes after hour, and kernel news 55 minutes after hour. I found this configuration to be sufficient.

Kernux project is a fully kernel-mode http-daemon for Linux. Currently Kernux is in its developing stage. Similiar developments in the same area were khttpd by Arjan van de van and Tux web-server by Ingo Molnar.

Khttpd was included in the linux testing kernel 2.5 by Linus Torvalds. But it was actually not in kernel-mode of operation. Also it handled dynamic requests which is assumed to be insecure for the server OS by the Linux kernel developers.

Tux is another implementation of kernel mode http-daemon, being developed by RedHat. The developer is Ingo Molnar, the creator of O(n) scheduler, which control the procsses from Linux kernel version 7.2 onwards.

Kernux works as a kernel module, like a device driver. It uses low-level socket operations to handle the client requests. Kernux consist of a number of threads running parallely in the OS level (kernel_threads). An idle kernel-thread receive a connection from a wait queue, maintained at the Operating System level and serves it.

The pacularity is that, it uses no duplication of sockets what other servers do, but a single socket, whose access by multiple kernel-threads is maintained by a mutual exclusion system. Each thread, after analysing the request type, ie. whether it is static or dynamic, serves the client. The system is presently configured to handle only static requests. The dynamic requests are handled to a user-mode webserver of users choice, like Apache.