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 :)
#	Content
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