Free raw socket software for linux

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.

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.

SocketW project is a cross platform (Linux/FreeBSD/Unix/Win32) streaming socket C++ library designed to be easy to use.

It supports Unix sockets and TCP/IP sockets with optional SSL/TLS (OpenSSL) support. SocketW allows you to write portable and secure network applications quickly without needing to spend time learning low-level system functions or reading OpenSSL manuals.

gnome-socket provides a simple library for high-level network asynchronous I/O in GNOME applications.

gnome-socket is a library that provides simple high-level network access to GNOME applications. Its main features are asynchronous DNS lookup and non-blocking network I/O.

Its designed to use the very flexible glib event loop in order to make integration with GNOME programs easy.

CPP Socket library is a small Classlibrary for C++ that supports a easy usage of socket-programming for networking-software.

It provides a simple object-oriented interface to the classic C library calls.

With CPPSocket supports the following network protocols:

- TCP (transmission control protocol; needs an established connection from one host to another)
- UDP (user datagram protocol; packets can be sent without an established connection)
- IPv4 (internet protocol version 4; uses 32-bit network addresses)

These protocols are what may also be called TCP/IP.

The library provides two layers of abstraction:

- Low-Level
This is a simple oo interface of the classic socket calls. But it provides some (optional) abstractions for addressing and buffering.

Usefull for more experienced programmers, that have already worked with classic sockets.

- High-Level
This provides somewhat more abstraction and ignores some functionality of the full blown sockets.

But nevertheless it is quite usefull and makes programming of networking software very easy.

So its intended to be used by novice programmers or those who dont want the maximum complexity/flexibility but an easy to use network-interface.

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

Raw Print Server project is a "raw" print server that makes it possible for a computer to act as a "Socket API" or "AppSocket" print server.
This software would not exist without Sam Rushings excellent asyncore module, nor would it exist without Steve Holdens excellent explanation of that module (in his book "Python Web Programming" from New Riders, a truly outstanding book that I cant recommend enough) from which I learned enough to write this server. Im also indebted to Guido van Rossum for Python itself, which has made my life SO much easier, and to Mark Hammond for the win32all modules which are essential parts of the Windows version of the print server.
This is version 0.1 of the Raw Print Server. There are no installation instructions to speak of; I plan to write an install script to assist with getting the software up and running, but for now its all manual.
You will need a working Python 2.x system to run the print server itself, and if you are installing on Windows youll need a working set of the win32all modules from Mark Hammond (which you really ought to have anyway). To run the GUI properties program, youll need a working PyGTK module set, and on Windows that means finding a compatible GTK+ runtime also.
Finding all of the above is left as an exercise for the reader.
Okay. If you are on a recent Linux system, or any of the BSD family, you should be able to install all of the above from your original installation media, or download them from the appropriate website for your distribution.
If you are running Windows, start by getting a recent Python build from www.python.org; follow the links from that site to the win32all downloads (currently somewhere on Sourceforge).
After that, go to www.pygtk.org and follow their links to the downloads you need for Windows. Note that as of this time (October 2005), the GTK libraries normally used for the Gimp dont work with PyGTK (despite notes on the PyGTK for Windows site saying that they do), at least, not on Win9x.
Get the runtime or development libraries referenced from the PyGTK for Windows site. If you already have the Gimp installed, uninstall the GTK+ libraries you got with it before installing the alternate runtime. My Gimp still works, so it must be okay, right?
Enhancements:
- close printer when done