![](http://www.gnu-darwin.org/hexley-gd-sm.png)
|
// Copyright (c) 1999-2000 David Muse
// See the COPYING file for more information.
#ifndef GENERICSOCKET_H
#define GENERICSOCKET_H
#include <strstream.h>
#include <sys/types.h>
#include <sys/un.h>
#include <netinet/in.h>
#include <netdb.h>
// The client class allows you to write programs that can talk to other
// programs over TCP connections.
//
// It provides connection management and data transfer methods but
// does not imply any particular client/server protocol.
//
// The class supports TCP connections over Inet and Unix domain sockets.
// Inet sockets allow clients and servers on different machines to talk over a
// network. Unix sockets allow clients and servers on the same machine to
// talk. Inet sockets can be used by clients and servers on the same machine
// but Unix sockets generally perform better.
//
// This class is a base class for the client and server socket classes. It
// provides methods for reading and writing data across sockets, closing sockets
// and managing errors. The client and server socket classes provide methods
// for listening on ports and connecting to servers.
class genericsocket {
public:
genericsocket();
genericsocket(int descriptor);
// creates an instance of genericsocket using the
// already open socket represented by "descriptor"
virtual ~genericsocket();
void showErrors();
// errors will be printed to stderr
void dontShowErrors();
// errors will not be printed at all
void retryInterruptedReads();
// causes reads that were interrupted by signals to
// retry and not return errors
void dontRetryInterruptedReads();
// causes reads that were interrupted by signals to
// return errors and not retry
void retryInterruptedWrites();
// causes writes that were interrupted by signals to
// retry and not return errors
void dontRetryInterruptedWrites();
// causes writes that were interrupted by signals to
// return errors and not retry
// These methods write data to the socket. On success, the
// number of bytes written is returned. On failure, a -1 is
// returned.
int writeData(unsigned short number);
int writeData(unsigned long number);
int writeData(float number);
int writeData(double number);
int writeData(char character);
int writeData(char *string);
int writeData(char *string, size_t size);
int writeData(void *buffer, size_t size);
// These methods read data from the socket. If no data is
// available, they will wait until data is available or
// the connection is closed. On success, the number of bytes
// read is returned. On failure, a -1 is returned.
int readData(unsigned short *buffer);
int readData(unsigned long *buffer);
int readData(float *buffer);
int readData(double *buffer);
int readData(char *buffer, size_t size);
int readData(void *buffer, size_t size);
int readData(strstream *buffer, char *terminator);
// These methods allow you to pass file descriptors between
// processes. They only work over unix sockets.
int passFileDescriptor(int descriptor);
int receiveFileDescriptor(int *descriptor);
int closeSocket();
// closes the socket
int getDescriptor();
// returns the internal file descriptor for the socket
int isInetSocket();
// returns 1 if the socket is an inet domain socket
// and 0 if the socket is a unix domain socket
int isUnixSocket();
// returns 1 if the socket is a unix domain socket
// and 0 if the socket is an inet domain socket
protected:
#include <rudiments/private/genericsocket.h>
};
#endif
|