Free sockets software for linux

C++ Sockets is a C++ wrapper for BSD-style sockets.
Main features:
- SSL support
- IPv6 support
- tcp and udp sockets
- encrypted tcp
- http protocol
- highly customizable error handling
Enhancements:
- A fatal bug in LineProtocol/Online when a CRLF happened over a read buffer boundary has been fixed.
- New output buffer logic.
- OnWriteComplete callback has been added, which fires after the output buffer has been transferred.

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

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.

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.

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.
Enhancements:
- ARP has been added but not tested. More IP4 options can be changed at code time now.

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.

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