0
|
1 /*
|
|
2 * Copyright 2000-2003 Sun Microsystems, Inc. All Rights Reserved.
|
|
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
4 *
|
|
5 * This code is free software; you can redistribute it and/or modify it
|
|
6 * under the terms of the GNU General Public License version 2 only, as
|
|
7 * published by the Free Software Foundation.
|
|
8 *
|
|
9 * This code is distributed in the hope that it will be useful, but WITHOUT
|
|
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
12 * version 2 for more details (a copy is included in the LICENSE file that
|
|
13 * accompanied this code).
|
|
14 *
|
|
15 * You should have received a copy of the GNU General Public License version
|
|
16 * 2 along with this work; if not, write to the Free Software Foundation,
|
|
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
18 *
|
|
19 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
|
|
20 * CA 95054 USA or visit www.sun.com if you need additional information or
|
|
21 * have any questions.
|
|
22 *
|
|
23 */
|
|
24
|
|
25 #ifndef _IO_BUF_
|
|
26 #define _IO_BUF_
|
|
27
|
|
28 // This file is currently used for os/solaris/agent/ too. At some point in time
|
|
29 // the source will be reorganized to avoid these ifdefs.
|
|
30 // Note that this class can read/write from a file as well as a socket. This
|
|
31 // file capability is only implemented on win32.
|
|
32
|
|
33 #ifdef WIN32
|
|
34 #include <winsock2.h>
|
|
35 #else
|
|
36 #include <sys/types.h>
|
|
37 #include <sys/socket.h>
|
|
38 // These are from win32 winsock2.h
|
|
39 typedef unsigned int SOCKET;
|
|
40 typedef void * HANDLE;
|
|
41 typedef unsigned long DWORD;
|
|
42 #define INVALID_SOCKET (SOCKET)(~0)
|
|
43 #endif
|
|
44
|
|
45 #include <vector>
|
|
46 #include "Buffer.hpp"
|
|
47
|
|
48 /** Manages an input/output buffer pair for a socket or file handle. */
|
|
49 class IOBuf {
|
|
50 public:
|
|
51 IOBuf(int inBufLen, int outBufLen);
|
|
52 ~IOBuf();
|
|
53
|
|
54 enum ReadLineResult {
|
|
55 RL_GOT_DATA,
|
|
56 RL_NO_DATA,
|
|
57 RL_ERROR
|
|
58 };
|
|
59
|
|
60 /** Change the socket with which this buffer is associated */
|
|
61 void setSocket(SOCKET sock);
|
|
62
|
|
63 // Reading/writing files is only supported on windows.
|
|
64 #ifdef WIN32
|
|
65 /** Change the output file handle with which this buffer is
|
|
66 associated. Currently IOBufs can not be used to read from a file
|
|
67 handle. */
|
|
68 void setOutputFileHandle(HANDLE handle);
|
|
69 #endif
|
|
70
|
|
71 /** Reset the input and output buffers, without flushing the output
|
|
72 data to the socket */
|
|
73 void reset();
|
|
74
|
|
75 /** Try to read a line of data from the given socket without
|
|
76 blocking. If was able to read a complete line of data, returns a
|
|
77 character pointer to the beginning of the (null-terminated)
|
|
78 string. If not, returns NULL, but maintains enough state that
|
|
79 subsequent calls to tryReadLine() will not ignore the data
|
|
80 already read. NOTE: this skips end-of-line characters (typically
|
|
81 CR/LF) as defined by "isEOL()". When switching back and forth
|
|
82 between binary and text modes, to be sure no data is lost, pad
|
|
83 the beginning and end of the binary transmission with bytes
|
|
84 which can not be confused with these characters. */
|
|
85 ReadLineResult tryReadLine();
|
|
86
|
|
87 /** Read a line of data from the given socket, blocking until a
|
|
88 line, including EOL, appears. Return the line, or NULL if
|
|
89 something goes wrong. */
|
|
90 char *readLine();
|
|
91
|
|
92 /** Get the pointer to the beginning of the (null-terminated) line.
|
|
93 This should only be called if tryReadLine() has returned
|
|
94 RL_GOT_DATA. This sets the "parsing cursor" to the beginning of
|
|
95 the line. */
|
|
96 char* getLine();
|
|
97
|
|
98 // NOTE: any further data-acquisition routines must ALWAYS call
|
|
99 // fixupData() at the beginning!
|
|
100
|
|
101 //----------------------------------------------------------------------
|
|
102 // Output routines
|
|
103 //
|
|
104
|
|
105 /** Flush the output buffer to the socket. Returns true if
|
|
106 succeeded, false if write error occurred. */
|
|
107 bool flush();
|
|
108
|
|
109 /** Write the given string to the output buffer. May flush if output
|
|
110 buffer becomes too full to store the data. Not guaranteed to
|
|
111 work if string is longer than the size of the output buffer.
|
|
112 Does not include the null terminator of the string. Returns true
|
|
113 if succeeded, false if write error occurred. */
|
|
114 bool writeString(const char* str);
|
|
115
|
|
116 /** Write the given int to the output buffer. May flush if output
|
|
117 buffer becomes too full to store the data. Returns true if
|
|
118 succeeded, false if write error occurred. */
|
|
119 bool writeInt(int val);
|
|
120
|
|
121 /** Write the given unsigned int to the output buffer. May flush if
|
|
122 output buffer becomes too full to store the data. Returns true
|
|
123 if succeeded, false if write error occurred. */
|
|
124 bool writeUnsignedInt(unsigned int val);
|
|
125
|
|
126 /** Write the given boolean to the output buffer. May flush if
|
|
127 output buffer becomes too full to store the data. Returns true
|
|
128 if succeeded, false if write error occurred. */
|
|
129 bool writeBoolAsInt(bool val);
|
|
130
|
|
131 /** Write the given address to the output buffer. May flush if
|
|
132 output buffer becomes too full to store the data. Returns true
|
|
133 if succeeded, false if write error occurred. */
|
|
134 bool writeAddress(void* val);
|
|
135
|
|
136 /** Writes a space to the output buffer. May flush if output buffer
|
|
137 becomes too full to store the data. Returns true if succeeded,
|
|
138 false if write error occurred. */
|
|
139 bool writeSpace();
|
|
140
|
|
141 /** Writes an end-of-line sequence to the output buffer. May flush
|
|
142 if output buffer becomes too full to store the data. Returns
|
|
143 true if succeeded, false if write error occurred. */
|
|
144 bool writeEOL();
|
|
145
|
|
146 /** Writes a binary character to the output buffer. */
|
|
147 bool writeBinChar(char c);
|
|
148
|
|
149 /** Writes a binary unsigned short in network (big-endian) byte
|
|
150 order to the output buffer. */
|
|
151 bool writeBinUnsignedShort(unsigned short i);
|
|
152
|
|
153 /** Writes a binary unsigned int in network (big-endian) byte order
|
|
154 to the output buffer. */
|
|
155 bool writeBinUnsignedInt(unsigned int i);
|
|
156
|
|
157 /** Writes a binary buffer to the output buffer. */
|
|
158 bool writeBinBuf(char* buf, int size);
|
|
159
|
|
160 #ifdef WIN32
|
|
161 enum FillState {
|
|
162 DONE = 1,
|
|
163 MORE_DATA_PENDING = 2,
|
|
164 FAILED = 3
|
|
165 };
|
|
166
|
|
167 /** Very specialized routine; fill the output buffer from the given
|
|
168 file handle. Caller is responsible for ensuring that there is
|
|
169 data to be read on the file handle. */
|
|
170 FillState fillFromFileHandle(HANDLE fh, DWORD* numRead);
|
|
171 #endif
|
|
172
|
|
173 /** Binary utility routine (for poke) */
|
|
174 static bool isBinEscapeChar(char c);
|
|
175
|
|
176 private:
|
|
177 IOBuf(const IOBuf&);
|
|
178 IOBuf& operator=(const IOBuf&);
|
|
179
|
|
180 // Returns -1 if non-blocking and no data available
|
|
181 int readChar(bool block);
|
|
182 // Line-oriented reading
|
|
183 std::vector<char> curLine;
|
|
184 bool gotDataLastTime;
|
|
185
|
|
186 ReadLineResult doReadLine(bool);
|
|
187
|
|
188 bool flushImpl(bool moreDataToCome);
|
|
189
|
|
190 SOCKET fd;
|
|
191 HANDLE outHandle;
|
|
192 bool usingSocket;
|
|
193
|
|
194 // Buffers
|
|
195 Buffer* inBuf;
|
|
196 Buffer* outBuf;
|
|
197
|
|
198 // Simple finite-state machine to handle binary data
|
|
199 enum State {
|
|
200 TEXT_STATE,
|
|
201 BIN_STATE,
|
|
202 EOL_STATE
|
|
203 };
|
|
204 enum Action {
|
|
205 NO_ACTION,
|
|
206 GOT_LINE, // TEXT_STATE -> EOL_STATE transition
|
|
207 SKIP_EOL_CHAR // EOL_STATE -> EOL_STATE transition
|
|
208 };
|
|
209
|
|
210 State state;
|
|
211 Action processChar(char c);
|
|
212
|
|
213 // Handling incoming binary buffers (poke command)
|
|
214 int binPos; // Number of binary characters read so far;
|
|
215 // total number to read is binLength + 4
|
|
216 int binLength; // Number of binary characters in message;
|
|
217 // not valid until binPos >= 4
|
|
218
|
|
219 bool isEOL(char c);
|
|
220 };
|
|
221
|
|
222 #endif // #defined _IO_BUF_
|