Free toe socks software for linux

tsocks provides transparent network access through a SOCKS version 4 or 5 proxy (usually on a firewall).

SOCKS servers are a form of proxy that are commonly used in firewalled LAN environments to allow access between networks, and often to the Internet. The problem is that most applications dont know how to gain access through SOCKS servers. This means that network based applications that dont understand SOCKS are very limited in networks they can reach. An example of this is simple telnet.

tsocks role is to allow these non SOCKS aware applications (e.g telnet, ssh, ftp etc) to use SOCKS without any modification. It does this by intercepting the calls that applications make to establish network connections and negotating them through a SOCKS server as necessary. If youre on a network firewalled from the internet with a SOCKS server for outside access, telnet cant use this server and thus cant telnet out to the Internet., sou you cannot get out.

tsocks is based on the shared library interceptor concept. Through use of the LD_PRELOAD environment variable or the /etc/ld.so.preload file tsocks is automatically loaded into the process space of every executed program. From there it overrides the normal connect() function by providing its own. Thus when an application calls connect() to establish a TCP connection it instead passes control to tsocks. tsocks determines if the connection needs to be made via a SOCKS server (by checking /etc/tsocks.conf) and negotiates the connection if so (through use of the real connect() function )

netToe project is a Tic Tac Toe game for the Linux console, playable over the network.
netToe is a Tic Tac Toe-like game for the Linux console written in C using UNIX sockets. It is playable by 2 players over the network, against computer AI, or against another player on the same machine.
Enhancements:
- Completed the code section regarding colors.
- netToe now uses colors !
- Modified the parse_cmd_args(...) function to accept more than one argument at time, option --no-colors added. (ref: misc.c)
- Added modules terminal.c and terminal.h Those file include the new code to handle colors in nettoe.
- Added modules matrices.c and matrices.h Those files include the new code to handle the nettoe board matrix.
- Removed netmisc.c and netmisc.h modules and included the code in the network.c and network.h modules.

GTacToe project is a Tic Tac Toe game with intelligent AI. It also features network play, two player local games, and much more.
Installing
1. `cd to the directory containing the packages source code and type `./configure to configure the package for your system.
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.
Enhancements:
- Long break from coding on this but here are the minor changes and big bug fixes
- Cleaned up a lot of code to make sure the core/ui split is complete
- Prepared things for a QT gui for the 4.0.0 release
- Thinking about how I will do a windows port
- Added lots of header files and functions to the configure script
- Added the missing errno.h in the last release (sorry I didnt notice sooner)
- Fixed a network error where my error checking always reported an error

bufsock.py is a python module that makes it a little bit easier to work with sockets, and may also make your I/O faster if youre reading and/or writing lots of tiny packets.

Also, you may find that it makes your network applications more reliable, as the network is allowed to split apart your packets into multiple smaller packets, or aggregate two or more packets into one larger packet, if it decides it needs to do so for reliability or performance.

So you might do a s.recv expecting to get one line of input, but the network decided to batch together two remote s.sends into one s.recv, for example. But the network usually, but not always, will batch up your packets the way youd expect - so this can be a difficult problem to track down.

It supports the following methods:

read(length) brings in a specific number of bytes.
readto(char) reads up thru the next occurence of char
readtomax(char,length) reads up thru the next occurence of char, or length bytes, whichever is less
set_chunk_len(length) says "do reads and writes in increments of length". The chunk length defaults to 4096. You should make this larger on networks that employ jumbo frames to squeeze out more performance!
send(buf) writes the bytes in buf.
flush() is just like stdios (the C librarys) flush function. Call it when you want an output buffer flushed (written immediately).
shutdown(v) just like for a regular socket, except it flushes first.

Usage:

Code snippet:
sock = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
sock.connect((hostname,port))
bs = bufsock.bufsock(sock)
version = bs.readto(n)
print version

Cone project is a text-based mail client. Cone seamlessly handles multiple POP3, IMAP accounts, and local mail folders.
Cone is also a simple newsreader. Cones interface is foolproof enough to be used by inexperienced users, but it also offers advanced features for power users.
Main features:
- An online tutorial provides a quick overview of Cones main features.
- A built-in text editor for editing new messages, with search/replace and spell checking (requires aspell or pspell).
- Shortcuts - assign frequently used text to a function key, or to an abbreviation. Insert the text by pressing the function key or typing its abbreviation.
- Supports UTF-8 consoles (requires the wide-character version of the curses library).
- Displays HTML mail, with automatic de-moronization ("smart quotes", and similar clutter, is replaced by plain garden-variety punctuation).
- Displays attached images, if invoked from an X terminal, by running Gnomes eog, or KDEs kview image viewer. Displays PDF attachments by running xpdf. Other, or alternative, helper applications will be added as time permits.
- After attachments are downloaded, they can be optionally removed from the message.
- Handles local mail folders, maildirs, IMAP and POP3 accounts, and Usenet newsgroups. All folders are shown in a hierarchical tree-like display.
- Supports access to servers through a Socks 5 proxy, using the Courier Socks 5 API toolkit.
- Sends mail using an external SMTP server (with/without authentication), or the local sendmail command.
- All network protocols support SSL/TLS and SASL (CRAM-MD5, CRAM-SHA1, and LOGIN).
- Address books (which can be stored in an IMAP folder).
- Remote configuration (share a common configuration between different instances of Cone).
- An optional "single sign-on". Use a single master password for multiple remote mail server accounts.
- PGP/GPG based encryption, and digital signatures. Sent messages are automatically signed. Different signing keys may be selected for different mail accounts, and the appropriate key is automatically selected when replying to a message from an account. Selecting a message for an encryption automatically looks up keys that match the recipients E-mail addresses.
- Import, export, forward and receive PGP/GPG keys as MIME attachments.
- When a single sign-on master password is installed, the master password also handles access to passphrase-protected keys.
- Cone shares a lot of its code base with the Courier mail server, which is why they share the same web site together.
- Cone also serves as a platform for development of a new experimental network mail access protocol, SMAP, that offers additional functionality not available with IMAP or POP3.
- Cone owes its versatility in handling a large variety of mail protocols to the fact that its based on LibMAIL, a generic C++ library that provides a high-level mail-handling API. Using the --with-devel configuration setting installs the LibMAIL toolkit, which allows for development of independent E-mail software.
Enhancements:
- This release fixes a bug in GPG signing of multi-part messages whose main content contains 8-bit text.

JTicTacToe project is a version of the popular boardgame "Tic Tac Toe".

JTicTacToe is a version of the popular boardgame "Tic Tac Toe", with the difference that you can have a gamefield of arbitrary size and you need 5 Xs or Os in a row to win.

You need to play against another human being; JTicTacToe is meant to be played via the Internet.

Installation

Theres really not much to install. The tarball that can be downloaded just needs to be deflated using winzip in Windows or tar -xvzf jtictactoe.tar.gz if youre using Linux/Unix.

JTicTacToe is written in Java and all you need to run the game is the executable jar included in the tarball and a working Java Virtual Machine. You can place the extractet jar file wherever you please.

JOLIE is an interpreter for a new high level programming language, designed for SOAs (Service Oriented Architecture) orchestration (as, for example, WSBPEL by OASIS).
The whole program is written entirely in Java to ensure cross-platform capabilities, following strictly an object-oriented development method focused on components reusability and virtualization.
Where does JOLIE come from?
JOLIE was born as a project for a thesis in computer science at the University of Bologna, Italy. The project is based upon a theoretical calculus equipped with semantics (named SOCK), developed in the same university.
Why JOLIE?
Service Oriented Architectures (SOA) may be really difficult to orchestrate and they imply a lot of problematics about connectivity, loosely coupling, parallel execution and so on. JOLIE is an attempt to solve all these issues, providing an easy to use language which abstracts from them all.
Enhancements:
- A new heuristic for improving incoming communication handling performance has been introduced.
- Lot of bug fixes and performance improvements in the session execution engine.
- Request-Response operations must now declare their throwable fault names.