c%2B%2B/socket%2B%2B-1.10/sockstream.h

// sockstream.h -*- C++ -*- socket library
// Copyright (C) 1992,1993,1994 Gnanasekaran Swaminathan <gs4t@virginia.edu>
// 
// Permission is granted to use at your own risk and distribute this software
// in source and binary forms provided the above copyright
// notice and this paragraph are preserved on all copies.
// This software is provided "as is" with no express or implied warranty.
//
// Version: 17Oct95 1.10

#ifndef _SOCKSTREAM_H
#define _SOCKSTREAM_H

#include <iostream.h>
#include <stddef.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/uio.h>
#include <sys/socket.h>

#ifndef _G_config_h
        // non libg++ or g++ compilation
#       define _S_NOLIBGXX

#       define _S_USER_BUF              0x0001
#       define _S_UNBUFFERED            0x0002
#       define _S_NO_READS              0x0004
#       define _S_NO_WRITES             0x0008
#       define _S_EOF_SEEN              0x0010
#       define _S_ERR_SEEN              0x0020
#       define _S_DELETE_DONT_CLOSE     0x0040
#       define _S_LINKED                0x0080
#       define _S_LINE_BUF              0x0200

#       define _G_ssize_t size_t

#else
#       ifndef _S_USER_BUF
                // libg++ 2.5.x
#               define _S_USER_BUF              _IO_USER_BUF            
#               define _S_UNBUFFERED            _IO_UNBUFFERED          
#               define _S_NO_READS              _IO_NO_READS            
#               define _S_NO_WRITES             _IO_NO_WRITES           
#               define _S_EOF_SEEN              _IO_EOF_SEEN            
#               define _S_ERR_SEEN              _IO_ERR_SEEN            
#               define _S_DELETE_DONT_CLOSE     _IO_DELETE_DONT_CLOSE   
#               define _S_LINKED                _IO_LINKED              
#               define _S_LINE_BUF              _IO_LINE_BUF            
#       endif //  !_S_USER_BUF

#endif //  !_G_config_h

#ifdef __linux__
// linux leaves these things out. We define it for compatitbility
// not for their use.
#       define SO_ACCEPTCONN    0x0002
#       define SO_USELOOPBACK   0x0040
#       define SO_SNDLOWAT      0x1003
#       define SO_RCVLOWAT      0x1004
#       define SO_SNDTIMEO      0x1005
#       define SO_RCVTIMEO      0x1006

#       define MSG_MAXIOVLEN    16
#       define SOMAXCONN        5
#endif // __linux__

extern void sock_error (const char* classname, const char* error_message);

typedef int sockexcept;

struct sockaddr;

class sockAddr {
public:
    virtual             ~sockAddr() {}
    
    virtual             operator void*  () const =0;
                        operator sockaddr* () const { return addr (); }
    virtual int         size            () const =0;
    virtual int         family          () const =0;
    virtual sockaddr*   addr            () const =0;

    void                error (const char* errmsg) const;
};

struct msghdr;

class sockbuf: public streambuf {
public:
    enum type {
        sock_stream     = SOCK_STREAM,
        sock_dgram      = SOCK_DGRAM,
        sock_raw        = SOCK_RAW,
        sock_rdm        = SOCK_RDM,
        sock_seqpacket  = SOCK_SEQPACKET
    };
    enum option {
        so_debug        = SO_DEBUG,
        so_acceptconn   = SO_ACCEPTCONN,
        so_reuseaddr    = SO_REUSEADDR,
        so_keepalive    = SO_KEEPALIVE,
        so_dontroute    = SO_DONTROUTE,
        so_broadcast    = SO_BROADCAST,
        so_useloopback  = SO_USELOOPBACK,
        so_linger       = SO_LINGER,
        so_oobinline    = SO_OOBINLINE,
        so_sndbuf       = SO_SNDBUF,
        so_rcvbuf       = SO_RCVBUF,
        so_sndlowat     = SO_SNDLOWAT,
        so_rcvlowat     = SO_RCVLOWAT,
        so_sndtimeo     = SO_SNDTIMEO,
        so_rcvtimeo     = SO_RCVTIMEO,
        so_error        = SO_ERROR,
        so_type         = SO_TYPE
    };  
    enum level { sol_socket = SOL_SOCKET };
    enum msgflag {
        msg_oob         = MSG_OOB,
        msg_peek        = MSG_PEEK,
        msg_dontroute   = MSG_DONTROUTE,
        
        msg_maxiovlen   = MSG_MAXIOVLEN
    };
    enum shuthow {
        shut_read,
        shut_write,
        shut_readwrite
    };
    enum { somaxconn    = SOMAXCONN };
    struct socklinger {
        int     l_onoff;        // option on/off
        int     l_linger;       // linger time

        socklinger (int a, int b): l_onoff (a), l_linger (b) {}
    };
    
protected:
    struct sockcnt {
        int     sock;
        int     cnt;

        sockcnt(int s, int c): sock(s), cnt(c) {}
    };
    
    sockcnt*    rep;  // counts the # refs to sock
    int         stmo; // -1==block, 0==poll, >0 == waiting time in secs
    int         rtmo; // -1==block, 0==poll, >0 == waiting time in secs
    
    virtual int         underflow ();
    virtual int         overflow (int c = EOF);
    virtual int         doallocate ();
    int                 flush_output ();

#ifdef _S_NOLIBGXX
    int         x_flags; // port to USL iostream
    int                 xflags () const { return x_flags; }
    int                 xsetflags (int f) { return x_flags |= f; }
    int                 xflags (int f)
                        { int ret = x_flags; x_flags = f; return ret; }
    void                xput_char (char c) { *pptr() = c; pbump (1); }
    int                 linebuffered () const { return x_flags & _S_LINE_BUF; }
#endif // _S_NOLIBGXX
    
public:
                        sockbuf (int soc = -1);
                        sockbuf (int, type, int proto=0);
                        sockbuf (const sockbuf&);
    sockbuf&            operator = (const sockbuf&);
    virtual             ~sockbuf ();
                        operator int () const { return rep->sock; }
    
    
    virtual sockbuf*    open    (type, int proto=0);
    virtual sockbuf*    close   ();
    virtual int         sync    ();
    virtual _G_ssize_t  sys_read (char* buf, _G_ssize_t len);
    virtual _G_ssize_t  sys_write (const void* buf, long len);
    virtual int         xsputn (const char* s, int n);
    int                 is_open () const { return rep->sock >= 0; }
    int                 is_eof  ()       { return xflags() & _S_EOF_SEEN; }
    
    
    virtual int         bind    (sockAddr&);
    virtual int         connect (sockAddr&);
    
    void                listen  (int num=somaxconn);
    virtual sockbuf     accept  ();
    virtual sockbuf     accept  (sockAddr& sa);
    
    int                 read    (void* buf, int len);
    int                 recv    (void* buf, int len, int msgf=0);
    int                 recvfrom(sockAddr& sa,
                                 void* buf, int len, int msgf=0);

#ifndef __linux__
    int                 recvmsg (msghdr* msg, int msgf=0);
    int                 sendmsg (msghdr* msg, int msgf=0);
#endif
    
    int                 write   (const void* buf, int len);
    int                 send    (const void* buf, int len, int msgf=0);
    int                 sendto  (sockAddr& sa,
                                 const void* buf, int len, int msgf=0);
    
    int                 sendtimeout (int wp=-1);
    int                 recvtimeout (int wp=-1);
    int                 is_readready (int wp_sec, int wp_usec=0) const;
    int                 is_writeready (int wp_sec, int wp_usec=0) const;
    int                 is_exceptionpending (int wp_sec, int wp_usec=0) const;
    
    void                shutdown (shuthow sh);
    
    int                 getopt(option op, void* buf,int len,
                               level l=sol_socket) const;
    void                setopt(option op, void* buf,int len,
                               level l=sol_socket) const;
    
    type                gettype () const;
    int                 clearerror () const;
    int                 debug     (int opt= -1) const;
    int                 reuseaddr (int opt= -1) const;
    int                 keepalive (int opt= -1) const;
    int                 dontroute (int opt= -1) const;
    int                 broadcast (int opt= -1) const;
    int                 oobinline (int opt= -1) const;
    int                 linger    (int tim= -1) const;
    int                 sendbufsz (int sz=-1)   const;
    int                 recvbufsz (int sz=-1)   const;
    
    void                error (const char* errmsg) const;
};

class isockstream: public istream {
protected:
                        isockstream (): ios (0) {}
public:
                        isockstream(sockbuf& sb)
                          : ios (new sockbuf(sb)) {}
                        ~isockstream ();
                        

    sockbuf*            rdbuf () { return (sockbuf*)ios::rdbuf(); }
    sockbuf*            operator -> () { return rdbuf(); }

    void                error (const char* errmsg) const;
};

class osockstream: public ostream {
protected:
                        osockstream (): ios (0) {}
public:
                        osockstream(sockbuf& sb)
                        : ios (new sockbuf(sb)) {}
                        ~osockstream ();

    sockbuf*            rdbuf () { return (sockbuf*)ios::rdbuf(); }
    sockbuf*            operator -> () { return rdbuf(); }

    void                error (const char* errmsg) const;
};

class iosockstream: public iostream {
protected:
                        iosockstream (): ios (0) {}
public:
                        iosockstream(sockbuf& sb)
                        : ios (new sockbuf(sb)) {}
                        ~iosockstream ();

    sockbuf*            rdbuf () { return (sockbuf*)ios::rdbuf(); }
    sockbuf*            operator -> () { return rdbuf(); }

    void                error (const char* errmsg) const;
};

#endif  // _SOCKSTREAM_H
Revision:	1.2
Committed:	Mon Jun 10 14:10:44 2002 UTC (22 years, 5 months ago) by tdb
Content type:	text/plain
Branch:	MAIN
CVS Tags:	HEAD
Changes since 1.1:	+0 -0 lines
State:	*FILE REMOVED*
Log Message:	Tidy up of files. These are all old things that are not only no longer used but are also probably useless to anyone other than us. This saves checking them out all the time, and makes the "cms/source" tree contain only current stuff. They'll still exist in the attic's though :)
#	User	Rev	Content
1	ab11	1.1	// sockstream.h -- C++ -- socket library
2			// Copyright (C) 1992,1993,1994 Gnanasekaran Swaminathan <gs4t@virginia.edu>
3			//
4			// Permission is granted to use at your own risk and distribute this software
5			// in source and binary forms provided the above copyright
6			// notice and this paragraph are preserved on all copies.
7			// This software is provided "as is" with no express or implied warranty.
8			//
9			// Version: 17Oct95 1.10
10
11			#ifndef _SOCKSTREAM_H
12			#define _SOCKSTREAM_H
13
14			#include <iostream.h>
15			#include <stddef.h>
16			#include <stdio.h>
17			#include <sys/types.h>
18			#include <sys/uio.h>
19			#include <sys/socket.h>
20
21			#ifndef _G_config_h
22			// non libg++ or g++ compilation
23			# define _S_NOLIBGXX
24
25			# define _S_USER_BUF 0x0001
26			# define _S_UNBUFFERED 0x0002
27			# define _S_NO_READS 0x0004
28			# define _S_NO_WRITES 0x0008
29			# define _S_EOF_SEEN 0x0010
30			# define _S_ERR_SEEN 0x0020
31			# define _S_DELETE_DONT_CLOSE 0x0040
32			# define _S_LINKED 0x0080
33			# define _S_LINE_BUF 0x0200
34
35			# define _G_ssize_t size_t
36
37			#else
38			# ifndef _S_USER_BUF
39			// libg++ 2.5.x
40			# define _S_USER_BUF _IO_USER_BUF
41			# define _S_UNBUFFERED _IO_UNBUFFERED
42			# define _S_NO_READS _IO_NO_READS
43			# define _S_NO_WRITES _IO_NO_WRITES
44			# define _S_EOF_SEEN _IO_EOF_SEEN
45			# define _S_ERR_SEEN _IO_ERR_SEEN
46			# define _S_DELETE_DONT_CLOSE _IO_DELETE_DONT_CLOSE
47			# define _S_LINKED _IO_LINKED
48			# define _S_LINE_BUF _IO_LINE_BUF
49			# endif // !_S_USER_BUF
50
51			#endif // !_G_config_h
52
53			#ifdef __linux__
54			// linux leaves these things out. We define it for compatitbility
55			// not for their use.
56			# define SO_ACCEPTCONN 0x0002
57			# define SO_USELOOPBACK 0x0040
58			# define SO_SNDLOWAT 0x1003
59			# define SO_RCVLOWAT 0x1004
60			# define SO_SNDTIMEO 0x1005
61			# define SO_RCVTIMEO 0x1006
62
63			# define MSG_MAXIOVLEN 16
64			# define SOMAXCONN 5
65			#endif // __linux__
66
67			extern void sock_error (const char* classname, const char* error_message);
68
69			typedef int sockexcept;
70
71			struct sockaddr;
72
73			class sockAddr {
74			public:
75			virtual ~sockAddr() {}
76
77			virtual operator void* () const =0;
78			operator sockaddr* () const { return addr (); }
79			virtual int size () const =0;
80			virtual int family () const =0;
81			virtual sockaddr* addr () const =0;
82
83			void error (const char* errmsg) const;
84			};
85
86			struct msghdr;
87
88			class sockbuf: public streambuf {
89			public:
90			enum type {
91			sock_stream = SOCK_STREAM,
92			sock_dgram = SOCK_DGRAM,
93			sock_raw = SOCK_RAW,
94			sock_rdm = SOCK_RDM,
95			sock_seqpacket = SOCK_SEQPACKET
96			};
97			enum option {
98			so_debug = SO_DEBUG,
99			so_acceptconn = SO_ACCEPTCONN,
100			so_reuseaddr = SO_REUSEADDR,
101			so_keepalive = SO_KEEPALIVE,
102			so_dontroute = SO_DONTROUTE,
103			so_broadcast = SO_BROADCAST,
104			so_useloopback = SO_USELOOPBACK,
105			so_linger = SO_LINGER,
106			so_oobinline = SO_OOBINLINE,
107			so_sndbuf = SO_SNDBUF,
108			so_rcvbuf = SO_RCVBUF,
109			so_sndlowat = SO_SNDLOWAT,
110			so_rcvlowat = SO_RCVLOWAT,
111			so_sndtimeo = SO_SNDTIMEO,
112			so_rcvtimeo = SO_RCVTIMEO,
113			so_error = SO_ERROR,
114			so_type = SO_TYPE
115			};
116			enum level { sol_socket = SOL_SOCKET };
117			enum msgflag {
118			msg_oob = MSG_OOB,
119			msg_peek = MSG_PEEK,
120			msg_dontroute = MSG_DONTROUTE,
121
122			msg_maxiovlen = MSG_MAXIOVLEN
123			};
124			enum shuthow {
125			shut_read,
126			shut_write,
127			shut_readwrite
128			};
129			enum { somaxconn = SOMAXCONN };
130			struct socklinger {
131			int l_onoff; // option on/off
132			int l_linger; // linger time
133
134			socklinger (int a, int b): l_onoff (a), l_linger (b) {}
135			};
136
137			protected:
138			struct sockcnt {
139			int sock;
140			int cnt;
141
142			sockcnt(int s, int c): sock(s), cnt(c) {}
143			};
144
145			sockcnt* rep; // counts the # refs to sock
146			int stmo; // -1==block, 0==poll, >0 == waiting time in secs
147			int rtmo; // -1==block, 0==poll, >0 == waiting time in secs
148
149			virtual int underflow ();
150			virtual int overflow (int c = EOF);
151			virtual int doallocate ();
152			int flush_output ();
153
154			#ifdef _S_NOLIBGXX
155			int x_flags; // port to USL iostream
156			int xflags () const { return x_flags; }
157			int xsetflags (int f) { return x_flags \|= f; }
158			int xflags (int f)
159			{ int ret = x_flags; x_flags = f; return ret; }
160			void xput_char (char c) { *pptr() = c; pbump (1); }
161			int linebuffered () const { return x_flags & _S_LINE_BUF; }
162			#endif // _S_NOLIBGXX
163
164			public:
165			sockbuf (int soc = -1);
166			sockbuf (int, type, int proto=0);
167			sockbuf (const sockbuf&);
168			sockbuf& operator = (const sockbuf&);
169			virtual ~sockbuf ();
170			operator int () const { return rep->sock; }
171
172
173			virtual sockbuf* open (type, int proto=0);
174			virtual sockbuf* close ();
175			virtual int sync ();
176			virtual _G_ssize_t sys_read (char* buf, _G_ssize_t len);
177			virtual _G_ssize_t sys_write (const void* buf, long len);
178			virtual int xsputn (const char* s, int n);
179			int is_open () const { return rep->sock >= 0; }
180			int is_eof () { return xflags() & _S_EOF_SEEN; }
181
182
183			virtual int bind (sockAddr&);
184			virtual int connect (sockAddr&);
185
186			void listen (int num=somaxconn);
187			virtual sockbuf accept ();
188			virtual sockbuf accept (sockAddr& sa);
189
190			int read (void* buf, int len);
191			int recv (void* buf, int len, int msgf=0);
192			int recvfrom(sockAddr& sa,
193			void* buf, int len, int msgf=0);
194
195			#ifndef __linux__
196			int recvmsg (msghdr* msg, int msgf=0);
197			int sendmsg (msghdr* msg, int msgf=0);
198			#endif
199
200			int write (const void* buf, int len);
201			int send (const void* buf, int len, int msgf=0);
202			int sendto (sockAddr& sa,
203			const void* buf, int len, int msgf=0);
204
205			int sendtimeout (int wp=-1);
206			int recvtimeout (int wp=-1);
207			int is_readready (int wp_sec, int wp_usec=0) const;
208			int is_writeready (int wp_sec, int wp_usec=0) const;
209			int is_exceptionpending (int wp_sec, int wp_usec=0) const;
210
211			void shutdown (shuthow sh);
212
213			int getopt(option op, void* buf,int len,
214			level l=sol_socket) const;
215			void setopt(option op, void* buf,int len,
216			level l=sol_socket) const;
217
218			type gettype () const;
219			int clearerror () const;
220			int debug (int opt= -1) const;
221			int reuseaddr (int opt= -1) const;
222			int keepalive (int opt= -1) const;
223			int dontroute (int opt= -1) const;
224			int broadcast (int opt= -1) const;
225			int oobinline (int opt= -1) const;
226			int linger (int tim= -1) const;
227			int sendbufsz (int sz=-1) const;
228			int recvbufsz (int sz=-1) const;
229
230			void error (const char* errmsg) const;
231			};
232
233			class isockstream: public istream {
234			protected:
235			isockstream (): ios (0) {}
236			public:
237			isockstream(sockbuf& sb)
238			: ios (new sockbuf(sb)) {}
239			~isockstream ();
240
241
242			sockbuf* rdbuf () { return (sockbuf*)ios::rdbuf(); }
243			sockbuf* operator -> () { return rdbuf(); }
244
245			void error (const char* errmsg) const;
246			};
247
248			class osockstream: public ostream {
249			protected:
250			osockstream (): ios (0) {}
251			public:
252			osockstream(sockbuf& sb)
253			: ios (new sockbuf(sb)) {}
254			~osockstream ();
255
256			sockbuf* rdbuf () { return (sockbuf*)ios::rdbuf(); }
257			sockbuf* operator -> () { return rdbuf(); }
258
259			void error (const char* errmsg) const;
260			};
261
262			class iosockstream: public iostream {
263			protected:
264			iosockstream (): ios (0) {}
265			public:
266			iosockstream(sockbuf& sb)
267			: ios (new sockbuf(sb)) {}
268			~iosockstream ();
269
270			sockbuf* rdbuf () { return (sockbuf*)ios::rdbuf(); }
271			sockbuf* operator -> () { return rdbuf(); }
272
273			void error (const char* errmsg) const;
274			};
275
276			#endif // _SOCKSTREAM_H