Free socket software for linux

Socketpipe project connects over a TCP/IP socket a remote command specified to a local input generation command and/or a local output processing command.
The input and output of the remote command are appropriately redirected so that the remote commands input will come from the local input generation command and the remote commands output will be sent to the local output processing command.
The remote command is executed on the machine accessed through the login command. The socketpipe executable should be available through the execution path in the remote machine.
The braces used for delimiting the commands and their arguments should be space-separated and can be nested. This feature allows you to setup complex and efficient topologies of distributed communicating processes.
Although the initial socketpipe communication setup is performed through client-server intermediaries such as ssh(1) or rsh(1), the communication channel that socketpipe establishes is a direct socket connection between the local and the remote commands.
Without the use of socketpipe, when piping remote data through ssh(1) or rsh(1), each data block is read at the local end by the respective client, is sent to the remote daemon and written out again to the remote process.
The use of socketpipe removes the inefficiency of the multiple data copies and context switches and can in some cases provide dramatic throughput improvements. On the other hand, the confidentiality and integrity of the data passing through socketpipes data channel is not protected; socketpipe should therefore be used only within a confined LAN environment.
(The authentication process uses the protocol of the underlying login program and is no more or less vulnerable than using the program in isolation; ssh(1) remains secure, rsh(1) continues to be insecure.)
Enhancements:
- This version corrects a bug in the command parsing of the Windows version of socketpipe.

Danga::Socket is an event loop and event-driven async socket base class.

SYNOPSIS

package My::Socket
use Danga::Socket;
use base (Danga::Socket);
use fields (my_attribute);

sub new {
my My::Socket $self = shift;
$self = fields::new($self) unless ref $self;
$self->SUPER::new( @_ );

$self->{my_attribute} = 1234;
return $self;
}

sub event_err { ... }
sub event_hup { ... }
sub event_write { ... }
sub event_read { ... }
sub close { ... }

$my_sock->tcp_cork($bool);

# write returns 1 if all writes have gone through, or 0 if there
# are writes in queue
$my_sock->write($scalar);
$my_sock->write($scalarref);
$my_sock->write(sub { ... }); # run when previous data written
$my_sock->write(undef); # kick-starts

# read max $bytecount bytes, or undef on connection closed
$scalar_ref = $my_sock->read($bytecount);

# watch for writability. not needed with ->write(). write()
# will automatically turn on watch_write when you wrote too much
# and turn it off when done
$my_sock->watch_write($bool);

# watch for readability
$my_sock->watch_read($bool);

# if you read too much and want to push some back on
# readable queue. (not incredibly well-tested)
$my_sock->push_back_read($buf); # scalar or scalar ref

Danga::Socket->AddOtherFds(..);
Danga::Socket->SetLoopTimeout($millisecs);
Danga::Socket->DescriptorMap();
Danga::Socket->WatchedSockets(); # count of DescriptorMap keys
Danga::Socket->SetPostLoopCallback($code);
Danga::Socket->EventLoop();

This is an abstract base class for objects backed by a socket which provides the basic framework for event-driven asynchronous IO, designed to be fast. Danga::Socket is both a base class for objects, and an event loop.

Callers subclass Danga::Socket. Danga::Sockets constructor registers itself with the Danga::Socket event loop, and invokes callbacks on the object for readability, writability, errors, and other conditions.

Because Danga::Socket uses the "fields" module, your subclasses must too.

Libsocketcpp provides a easy-to-use C++ socket library class.
Dispite the name, the TCPSocket class can handle both UDP and TCP connections.
Unfortunatly right now, the class is simple. It does not do anything really fancy like non-blocking sockets, select which interfaces you want to use, etc...
What it does allow you to do is to set up a TCP or UDP server/client and send and receive blocks of data. Plain and simple
Enhancements:
- Fixed missing include inside tcpservertest test program.
- Should be able to compile on RH 7.0 now.

phpSocketDaemon is a PHP socket daemon framework that can handle thousands of client and server connections, asynchronously, with built-in buffering, state handling, etc.

The implementation of a new TCP client or server service (or a mix thereof) with this library is very easy, and allows maximum flexibility.

Motivation for writing this library:

This project came into existence while i was writing a new, ground breaking IRC chat web application.

To deal with 1000s of concurrent, always on (comet aka hanging iframe) http (server) connections, and an equal amount of IRC client connections, plus being able to interpret and parse and delegate all the messages and events, i needed a very fast, stable, flexible and easy to use daemon library for PHP.

However no such thing existed yet, hence this library was created.
The tarbal includes a demo HTTP server implimentation, which will give you a good impression of what its capable off, and how to use this library.

Raw Socket Constructor provides a tool for sending packets from the console.

Raw Socket Constructor is a tool that uses the Libsock library to create arbitrary TCP, ICMP, UDP, TCP6, ICMP6, or UDP6 packets.

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!)

SOHT stands for Socket over HTTP Tunneling and allows you to tunnel socket connections through an HTTP proxy.
Restrictive firewalls often prohibit all outgoing trafic except for HTTP.
This application allows you to tunnel socket connections over the HTTP protocol.
This application consists of a server that serves as a proxy and a client which tunnels a socket connection over an HTTP connection to the server.
The current server is written in Java, and there are clients in Java and .NET.
Enhancements:
- Updated to fix an issue that prohibited connections to ports above 32767.