← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/pbms/src/cslib/CSSocket.h

  • Committer: Barry.Leslie at PrimeBase
  • Date: 2010-10-18 21:21:20 UTC
  • mto: This revision was merged to the branch mainline in revision 1871.
  • Revision ID: barry.leslie@primebase.com-20101018212120-dqukgtkwhb1imt1o
Merged changes from lp:pbms. These changes should remove any danger
of longjmp() clobbering local variables.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/pbms/src/cslib/CSSocket.h
37
37
#include "CSMemory.h"
38
38
#include "CSMutex.h"
39
39
 
40
 
using namespace std;
41
 
 
42
40
class CSOutputStream;
43
41
class CSInputStream;
44
42
 
 
43
#define CS_SOCKET_ADDRESS_SIZE          300
 
44
 
 
45
/* This is only required if you do
 
46
 * not use an output buffer stream!
 
47
 */
 
48
//#define CS_USE_OUTPUT_BUFFER
 
49
 
 
50
#ifdef CS_USE_OUTPUT_BUFFER
 
51
#ifdef DEBUG
 
52
#define CS_OUTPUT_BUFFER_SIZE           80
 
53
#define CS_MIN_WRITE_SIZE                       40
 
54
#else
 
55
#define CS_OUTPUT_BUFFER_SIZE           (4*1024)
 
56
#define CS_MIN_WRITE_SIZE                       (1500)
 
57
#endif
 
58
#endif
 
59
 
45
60
class CSSocket : public CSRefObject {
46
61
public:
47
 
        CSSocket() { }
48
 
 
49
 
        virtual ~CSSocket() { }
 
62
        CSSocket(): iHandle(-1), iHost(NULL), iService(NULL), iIdentity(NULL), iPort(0), iTimeout(0) {
 
63
#ifdef CS_USE_OUTPUT_BUFFER
 
64
        iDataLen = 0;
 
65
#endif
 
66
        }
 
67
 
 
68
        virtual ~CSSocket() {
 
69
                close();
 
70
        }
 
71
 
 
72
        void setTimeout(uint32_t milli_sec);
50
73
 
51
74
        CSOutputStream *getOutputStream();
52
75
 
53
76
        CSInputStream *getInputStream();
54
77
 
55
 
        virtual void formatAddress(size_t size, char *address) = 0;
 
78
        virtual void formatAddress(size_t size, char *address);
56
79
 
57
80
        /*
58
81
         * Publish a listener:
59
82
         */
60
 
        virtual void publish(char *service, int default_port) = 0;
 
83
        virtual void publish(char *service, int default_port);
61
84
 
62
85
        /*
63
86
         * Accept a connection from a listening socket:
64
87
         */
65
 
        virtual void open(CSSocket *listener) = 0;
 
88
        virtual void open(CSSocket *listener);
66
89
 
67
90
        /*
68
91
         * Connect to a listening socket.
69
92
         */
70
 
        virtual void open(char *address, int default_port) = 0;
 
93
        virtual void open(char *address, int default_port);
71
94
 
72
95
        /*
73
96
         * Close the socket.
74
97
         */
75
 
        virtual void close() { }
 
98
        virtual void close();
76
99
 
77
100
        /*
78
101
         * Read at least one byte from the socket.
84
107
         * Note: Errors on the socket do not cause
85
108
         * an exception!
86
109
         */
87
 
        virtual size_t read(void *data, size_t size) = 0;
 
110
        virtual size_t read(void *data, size_t size);
88
111
 
89
112
        /*
90
113
         * Returns -1 on EOF!
92
115
         * Just like read, error on the socket do
93
116
         * not throw an exception.
94
117
         */
95
 
        virtual int read() = 0;
 
118
        virtual int read();
96
119
 
97
120
        /*
98
121
         * Look at the next character in the file without
99
122
         * taking from the input.
100
123
         */
101
 
        virtual int peek() = 0;
 
124
        virtual int peek();
102
125
 
103
126
        /*
104
127
         * Write the given number of bytes.
105
128
         * Throws IOException if an error occurs.
106
129
         */
107
 
        virtual void write(const  void *data, size_t size) = 0;
 
130
        virtual void write(const  void *data, size_t size);
108
131
 
109
132
        /*
110
133
         * Write a character to the file.
111
134
         */
112
 
        virtual void write(char ch) = 0;
 
135
        virtual void write(char ch);
113
136
 
114
137
        /*
115
138
         * Flush the data written.
116
139
         */
117
 
        virtual void flush() = 0;
 
140
        virtual void flush();
 
141
 
 
142
        virtual const char *identify();
 
143
 
 
144
        static void initSockets();
118
145
 
119
146
        static CSSocket *newSocket();
120
147
 
121
 
        friend class SCSocket;
122
 
 
123
 
private:
124
 
};
125
 
 
126
 
#define CS_SOCKET_ADDRESS_SIZE          300
127
 
 
128
 
class SCSocket : public CSSocket {
129
 
public:
130
 
        SCSocket(): CSSocket(), iHandle(-1), iHost(NULL), iService(NULL), iPort(0) { }
131
 
 
132
 
        virtual ~SCSocket() {
133
 
                close();
134
 
        }
135
 
 
136
 
        virtual void formatAddress(size_t size, char *address);
137
 
 
138
 
        virtual void publish(char *service, int default_port);
139
 
 
140
 
        virtual void open(CSSocket *listener);
141
 
 
142
 
        virtual void open(char *address, int default_port);
143
 
 
144
 
        virtual void close();
145
 
 
146
 
        virtual size_t read(void *data, size_t size);
147
 
 
148
 
        virtual int read();
149
 
 
150
 
        virtual int peek();
151
 
 
152
 
        virtual void write(const void *data, size_t size);
153
 
 
154
 
        virtual void write(char ch);
155
 
 
156
 
        virtual void flush();
157
 
 
158
148
private:
159
149
        void throwError(const char *func, const char *file, int line, char *address, int err);
160
150
        void throwError(const char *func, const char *file, int line, int err);
161
 
        void setInternalOptions();
 
151
        void setNoDelay();
 
152
        void setNonBlocking();
 
153
        void setBlocking();
162
154
        void openInternal();
163
 
 
164
 
        int iHandle;
165
 
        char *iHost;
166
 
        char *iService;
167
 
        int iPort;
 
155
        void writeBlock(const void *data, size_t len);
 
156
        int timeoutRead(CSThread *self, void *buffer, size_t length);
 
157
 
 
158
        int                     iHandle;
 
159
        char            *iHost;
 
160
        char            *iService;
 
161
        char            *iIdentity;
 
162
        int                     iPort;
 
163
        uint32_t        iTimeout;
 
164
 
 
165
#ifdef CS_USE_OUTPUT_BUFFER
 
166
        char    iOutputBuffer[CS_OUTPUT_BUFFER_SIZE];
 
167
        size_t  iDataLen;
 
168
#endif
 
169
 
168
170
};
169
171
 
170
172
#endif