socket toolkit

Socket/X offers you with full access to the power of Windows Sockets, making it easy to write TCP/IP or UDP client and server software. Socket/X comes in ActiveX control and COM object forms. Because Socket/X is both an ActiveX control and a COM object, you can use it nearly anywhere -- ASP pages, Visual Basic applications, Visual C++ applications, anywhere that supports either COM objects or ActiveX controls.

Socket/X provides complete support for Windows and Visual Basics event-driven programming model and lets you do nearly anything that can be done with WinSock. Socket/X goes beyond the normal Visual Basic event-driven model by providing a scheme for Fast Notifications. Fast Notifications allow your program to quickly receive events through simple functions, rather than going through the lengthy process to fire an event. Fast Notifications considerably reduce the amount of time required to handle an event and only require a couple extra lines of code on your part. Want to stick with events? No problem! Those are still supported.

You can also use Socket/X in a "blocking" mode. This enables you to use Socket/X where events and callbacks are impractical (such as ASP pages).

Socket/X supports stream-based and datagram sockets. Stream-based sockets provide sequenced, reliable, full-duplex, connection-oriented byte streams. With stream-based sockets your data is guaranteed to arrive. This uses the Transmission Control Protocol (TCP) for the Internet address family.

Datagram sockets are connectionless, unreliable packets (typically small) of a fixed maximum length. These kinds of sockets are good for broadcasting large quantities of small pieces of information to a lot of clients. This style of socket uses the User Datagram Protocol (UDP) for the Internet address family.

ODBC Socket Server is an open source database access toolkit that exposes Windows ODBC data sources with an XML-based TCP/IP interface. Allows databases such as MS Access to be accessed across TCP/IP networks; or Linux/Macintosh/UNIX access to any Windows Database. Clients for COM, C++, Perl, PHP included, all source code provided.

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.

Socket, sockaddr_in, sockaddr_un, inet_aton, inet_ntoa is a Perl module to load the C socket.h defines and structure manipulators.

SYNOPSIS

use Socket;

$proto = getprotobyname(udp);
socket(Socket_Handle, PF_INET, SOCK_DGRAM, $proto);
$iaddr = gethostbyname(hishost.com);
$port = getservbyname(time, udp);
$sin = sockaddr_in($port, $iaddr);
send(Socket_Handle, 0, 0, $sin);

$proto = getprotobyname(tcp);
socket(Socket_Handle, PF_INET, SOCK_STREAM, $proto);
$port = getservbyname(smtp, tcp);
$sin = sockaddr_in($port,inet_aton("127.1"));
$sin = sockaddr_in(7,inet_aton("localhost"));
$sin = sockaddr_in(7,INADDR_LOOPBACK);
connect(Socket_Handle,$sin);

($port, $iaddr) = sockaddr_in(getpeername(Socket_Handle));
$peer_host = gethostbyaddr($iaddr, AF_INET);
$peer_addr = inet_ntoa($iaddr);

$proto = getprotobyname(tcp);
socket(Socket_Handle, PF_UNIX, SOCK_STREAM, $proto);
unlink(/var/run/usock);
$sun = sockaddr_un(/var/run/usock);
connect(Socket_Handle,$sun);

This module is just a translation of the C socket.h file. Unlike the old mechanism of requiring a translated socket.ph file, this uses the h2xs program (see the Perl source distribution) and your native C compiler. This means that it has a far more likely chance of getting the numbers right. This includes all of the commonly used pound-defines like AF_INET, SOCK_STREAM, etc.

Socket::PassAccessRights is a Perl extension for BSD style file descriptor passing via Unix domain sockets.

SYNOPSIS

use Socket::PassAccessRights;
Socket::PassAccessRights::sendfd(fileno(SOCKET), fileno(SEND_ME)) or die;
$fd = Socket::PassAccessRights::recvfd(fileno(SOCKET)) or die;
open FD, ">&=$fd" or die "$!"; # convert int fd to file handle

Implements passing access rights (i.e. file descritors) over Unix domain sockets. Only one fd can be passed at one time and no other data can be sent in the same operation (operation itself involves sending exactly one byte of data to solve EOF detection anomaly).

See test.pl and examples directory for usage examples.

PLATFORMS

This code has only been tested on

* Linux-2.0.38 with glibc-2.0.7 (libc.so.6) and libc.so.5 (BSD4.4 style)
* Linux-2.2.14 with glibc-2.0.7 (libc.so.6) (BSD4.4 style)
* Solaris-2.6 using gcc (BSD4.3 style)

Specifically, the code from [Stevens] did not work out of the box. I had to rename msg.msg_accrights* to msg.control* and send at least one byte. General impression from net is that file descripto passing code seems to be buggy - not just in Linux, but on FreeBSD, too.

Socket Workbench is the definitive tool for analysing socket communications that underlie the Internet and several types of inter-process communication.

Configure Socket Workbench to be a socket client (like a web browser or e-mail client) or a socket server with ease. You can send data through a socket and analyse that data that has been received.

Also, Socket Workbench has the unique "Pass Through Mode" which allows the interception of socket communications between a client and its server without packet sniffing. Features include:

- Allows the analysis of the E-mail, HTTP, Time Of Day, FTP and any other socket based communication protocol including real-time and client-server applications.
- Configure Socket Workbench to be a socket client or a socket server.
- Allows any number of clients to connect while in Server mode.
- Intercept and analyse socket communications using the Pass-Through mode.
- Includes a library of the well-known socket port numbers and servers.
- Author and send e-mails using the e-mail protocol template.
- Contains a library of HTTP requests from the popular Web Browsers and the HTTP Responses from Web Servers.
- Ideal for testing and monitoring real-time applications or two/three/n-tier client-server applications.
- All socket state transitions and Socket Workbench events can be logged.
- Data can be analysed using a raw, binary, octal, decimal or hexadecimal format.
- Incoming and outgoing data can be logged with an optional time stamp.
- Contains 7 pre-defined configurations to get under way as soon as possible.
- Incoming data can be filtered.
- Schedule data to be sent at regular intervals.
- Data can be split in to messages and messages can be split into fields.
- Allows the stress testing of socket client and servers.
- Data sent through the socket can be "linked" to a file. When the contents of the file changes, the data is automatically re-read and transmitted.

1024x768 desktop wallpaper of a socket-based motherboard with CPU. For private usage only. Free for non-commercial usage. For commercial usage (e.g. on wegpage, print etc), get in touch with the developer.

Socket Sifter is a program that simply communicates through TCP on any port.

SocketSifter can listen or connect on any available port that youspecify.

It can be used by developers who want to test theirapplications and have complete control of data flow through sockets. Thiscan be helpful in finding bugs in the protocol or just plain testingdifference application features.

Socket Sifter can also act as a handytelnet application.

With the knowledge of the correct protocol you can doalmost anything with Socket Sifter such as reading your email or retrievingweb pages.

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.

VP Toolkit is an Internet client/server C++ library, with support for object threads, stream based socket I/O, a multi-threaded server socket framework, a multi-process fault tolerant server framework, XML, HTTP, etc.

VP Toolkit software is now deprecated in favor of UDK.

To build the documentation you will need SDF, and HTMLDOC. SDF can be downloaded freely from the SDF home page at http://www.mincom.com/mtr/sdf/, and HTMLDOC can be had from
http://www.easysw.com/htmldoc/.

Socket Test Bench is a utility to test winsock-basedcommunications.

Component implements TCP/IP socket communications in a synchronous way for the server and client environments.

Raw Socket Library provides a simple to use raw socket library with IPV6 support.

Raw Socket Library provides a simple mechanism to send raw socket packet using IPV4 and IPV6 using a simple struct.

It currently supports TCP, ICMP, UDP, and ICMPv6.

Whats New in This Release:

· ARP has been added but not tested. More IP4 options can be changed at code time now.