/* * Copyright (c) 2000, 2003, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. * */ #ifndef _IO_BUF_ #define _IO_BUF_ // This file is currently used for os/solaris/agent/ too. At some point in time // the source will be reorganized to avoid these ifdefs. // Note that this class can read/write from a file as well as a socket. This // file capability is only implemented on win32. #ifdef WIN32 #include #else #include #include // These are from win32 winsock2.h typedef unsigned int SOCKET; typedef void * HANDLE; typedef unsigned long DWORD; #define INVALID_SOCKET (SOCKET)(~0) #endif #include #include "Buffer.hpp" /** Manages an input/output buffer pair for a socket or file handle. */ class IOBuf { public: IOBuf(int inBufLen, int outBufLen); ~IOBuf(); enum ReadLineResult { RL_GOT_DATA, RL_NO_DATA, RL_ERROR }; /** Change the socket with which this buffer is associated */ void setSocket(SOCKET sock); // Reading/writing files is only supported on windows. #ifdef WIN32 /** Change the output file handle with which this buffer is associated. Currently IOBufs can not be used to read from a file handle. */ void setOutputFileHandle(HANDLE handle); #endif /** Reset the input and output buffers, without flushing the output data to the socket */ void reset(); /** Try to read a line of data from the given socket without blocking. If was able to read a complete line of data, returns a character pointer to the beginning of the (null-terminated) string. If not, returns NULL, but maintains enough state that subsequent calls to tryReadLine() will not ignore the data already read. NOTE: this skips end-of-line characters (typically CR/LF) as defined by "isEOL()". When switching back and forth between binary and text modes, to be sure no data is lost, pad the beginning and end of the binary transmission with bytes which can not be confused with these characters. */ ReadLineResult tryReadLine(); /** Read a line of data from the given socket, blocking until a line, including EOL, appears. Return the line, or NULL if something goes wrong. */ char *readLine(); /** Get the pointer to the beginning of the (null-terminated) line. This should only be called if tryReadLine() has returned RL_GOT_DATA. This sets the "parsing cursor" to the beginning of the line. */ char* getLine(); // NOTE: any further data-acquisition routines must ALWAYS call // fixupData() at the beginning! //---------------------------------------------------------------------- // Output routines // /** Flush the output buffer to the socket. Returns true if succeeded, false if write error occurred. */ bool flush(); /** Write the given string to the output buffer. May flush if output buffer becomes too full to store the data. Not guaranteed to work if string is longer than the size of the output buffer. Does not include the null terminator of the string. Returns true if succeeded, false if write error occurred. */ bool writeString(const char* str); /** Write the given int to the output buffer. May flush if output buffer becomes too full to store the data. Returns true if succeeded, false if write error occurred. */ bool writeInt(int val); /** Write the given unsigned int to the output buffer. May flush if output buffer becomes too full to store the data. Returns true if succeeded, false if write error occurred. */ bool writeUnsignedInt(unsigned int val); /** Write the given boolean to the output buffer. May flush if output buffer becomes too full to store the data. Returns true if succeeded, false if write error occurred. */ bool writeBoolAsInt(bool val); /** Write the given address to the output buffer. May flush if output buffer becomes too full to store the data. Returns true if succeeded, false if write error occurred. */ bool writeAddress(void* val); /** Writes a space to the output buffer. May flush if output buffer becomes too full to store the data. Returns true if succeeded, false if write error occurred. */ bool writeSpace(); /** Writes an end-of-line sequence to the output buffer. May flush if output buffer becomes too full to store the data. Returns true if succeeded, false if write error occurred. */ bool writeEOL(); /** Writes a binary character to the output buffer. */ bool writeBinChar(char c); /** Writes a binary unsigned short in network (big-endian) byte order to the output buffer. */ bool writeBinUnsignedShort(unsigned short i); /** Writes a binary unsigned int in network (big-endian) byte order to the output buffer. */ bool writeBinUnsignedInt(unsigned int i); /** Writes a binary buffer to the output buffer. */ bool writeBinBuf(char* buf, int size); #ifdef WIN32 enum FillState { DONE = 1, MORE_DATA_PENDING = 2, FAILED = 3 }; /** Very specialized routine; fill the output buffer from the given file handle. Caller is responsible for ensuring that there is data to be read on the file handle. */ FillState fillFromFileHandle(HANDLE fh, DWORD* numRead); #endif /** Binary utility routine (for poke) */ static bool isBinEscapeChar(char c); private: IOBuf(const IOBuf&); IOBuf& operator=(const IOBuf&); // Returns -1 if non-blocking and no data available int readChar(bool block); // Line-oriented reading std::vector curLine; bool gotDataLastTime; ReadLineResult doReadLine(bool); bool flushImpl(bool moreDataToCome); SOCKET fd; HANDLE outHandle; bool usingSocket; // Buffers Buffer* inBuf; Buffer* outBuf; // Simple finite-state machine to handle binary data enum State { TEXT_STATE, BIN_STATE, EOL_STATE }; enum Action { NO_ACTION, GOT_LINE, // TEXT_STATE -> EOL_STATE transition SKIP_EOL_CHAR // EOL_STATE -> EOL_STATE transition }; State state; Action processChar(char c); // Handling incoming binary buffers (poke command) int binPos; // Number of binary characters read so far; // total number to read is binLength + 4 int binLength; // Number of binary characters in message; // not valid until binPos >= 4 bool isEOL(char c); }; #endif // #defined _IO_BUF_