1 /*

     2  * Copyright (c) 2000, 2003, Oracle and/or its affiliates. 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    20  * or visit www.oracle.com if you need additional information or have any

    21  * 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_