/*

 * Copyright 2000-2003 Sun Microsystems, Inc.  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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 *

 */

#include <stdio.h>

// This file is currently used for os/solaris/agent too.  At some point in time

// the source will be reorganized to avoid these ifdefs.

#ifdef __sun

  #include <string.h>

  #include <inttypes.h>

  #include <sys/byteorder.h>

#endif

#include "IOBuf.hpp"

// Formats for printing pointers

#ifdef _LP64

#  define INTPTR_FORMAT "0x%016lx"

#else /* ! _LP64 */

#  define INTPTR_FORMAT "0x%08lx"

#endif /* _LP64 */

// Uncomment the #define below to get messages on stderr

// #define DEBUGGING

IOBuf::IOBuf(int inLen, int outLen) {

  inBuf = new Buffer(inLen);

  outBuf = new Buffer(outLen);

  fd = INVALID_SOCKET;

  outHandle = NULL;

  usingSocket = true;

  reset();

}

IOBuf::~IOBuf() {

  delete inBuf;

  delete outBuf;

}

void

IOBuf::setSocket(SOCKET sock) {

  fd = sock;

  usingSocket = true;

}

// Reading/writing files is only needed and used on windows.

#ifdef WIN32

void

IOBuf::setOutputFileHandle(HANDLE handle) {

  outHandle = handle;

  usingSocket = false;

}

#endif

void

IOBuf::reset() {

  gotDataLastTime = false;

  state          = TEXT_STATE;

  binPos         = 0;

  binLength      = 0;

}

IOBuf::ReadLineResult

IOBuf::tryReadLine() {

  return doReadLine(false);

}

char*

IOBuf::readLine() {

  ReadLineResult rr = doReadLine(true);

  if (rr != RL_GOT_DATA) {

    return NULL;

  }

  return getLine();

}

IOBuf::ReadLineResult

IOBuf::doReadLine(bool shouldWait) {

  if (!usingSocket) {

    return IOBuf::RL_ERROR;

  }

  if (gotDataLastTime) {

    curLine.clear();

  }

  int c;

  do {

    c = readChar(shouldWait);

    if (c >= 0) {

      Action act = processChar((char) c);

      if (act == GOT_LINE) {

        curLine.push_back('\0');

        gotDataLastTime = true;

        return IOBuf::RL_GOT_DATA;

      } else if (act == SKIP_EOL_CHAR) {

        // Do nothing

      } else {

        curLine.push_back((char) c);

      }

    }

  } while (shouldWait || c >= 0);

  gotDataLastTime = false;

  return IOBuf::RL_NO_DATA;

}

bool

IOBuf::flushImpl(bool moreDataToCome) {

  int numWritten = 0;

#ifdef WIN32

  // When running on Windows and using IOBufs for inter-process

  // communication, we need to write metadata into the stream

  // indicating how many bytes are coming down. Five bytes are written

  // per flush() call, four containing the integer number of bytes

  // coming (not including the five-byte header) and one (a 0 or 1)

  // indicating whether there is more data coming.

  if (!usingSocket) {

    int numToWrite = outBuf->drainRemaining();

    char moreToCome = (moreDataToCome ? 1 : 0);

    DWORD numBytesWritten;

    if (!WriteFile(outHandle, &numToWrite, sizeof(int), &numBytesWritten, NULL)) {

      return false;

    }

    if (numBytesWritten != sizeof(int)) {

      return false;

    }

    if (!WriteFile(outHandle, &moreToCome, 1, &numBytesWritten, NULL)) {

      return false;

    }

    if (numBytesWritten != 1) {

      return false;

    }

  }

#endif

  while (outBuf->drainRemaining() != 0) {

#ifdef DEBUGGING

      fprintf(stderr, "Flushing %d bytes\n", outBuf->drainRemaining());

#endif

    if (usingSocket) {

      numWritten = send(fd, outBuf->drainPos(), outBuf->drainRemaining(), 0);

    } else {

#ifdef WIN32

      DWORD numBytesWritten;

      if (!WriteFile(outHandle, outBuf->drainPos(), outBuf->drainRemaining(), &numBytesWritten, NULL)) {

        numWritten = -1;

      } else {

        numWritten = numBytesWritten;

      }

#endif

    }

    if (numWritten != -1) {

#ifdef DEBUGGING

      fprintf(stderr, "Flushed %d bytes\n", numWritten);

#endif

      outBuf->incrDrainPos(numWritten);

    } else {

      return false;

    }

  }

  outBuf->compact();

  return true;

}

int

IOBuf::readChar(bool block) {

  do {

    int c = inBuf->readByte();

    if (c >= 0) {

      return c;

    }

    // See whether we need to compact the input buffer

    if (inBuf->remaining() < inBuf->size() / 2) {

      inBuf->compact();

    }

    // See whether socket is ready

    fd_set fds;

    FD_ZERO(&fds);

    FD_SET(fd, &fds);

    struct timeval timeout;

    timeout.tv_sec = 0;

    timeout.tv_usec = 0;

    if (block || select(1 + fd, &fds, NULL, NULL, &timeout) > 0) {

      if (block || FD_ISSET(fd, &fds)) {

#ifdef DEBUGGING

        int b = (block ? 1 : 0);

        fprintf(stderr, "calling recv: block = %d\n", b);

#endif

        // Read data from socket

        int numRead = recv(fd, inBuf->fillPos(), inBuf->remaining(), 0);

        if (numRead < 0) {

#ifdef DEBUGGING

          fprintf(stderr, "recv failed\n");

#endif

          return -1;

        }

        inBuf->incrFillPos(numRead);

      }

    }

  } while (block);

  return inBuf->readByte();

}

char*

IOBuf::getLine() {

#ifdef DEBUGGING

  fprintf(stderr, "Returning (first 10 chars) \"%.10s\"\n", curLine.begin());

#endif

  return curLine.begin();

}

bool

IOBuf::flush() {

  return flushImpl(false);

}

bool

IOBuf::writeString(const char* str) {

  int len = strlen(str);

  if (len > outBuf->size()) {

    return false;

  }

  if (len > outBuf->remaining()) {

    if (!flushImpl(true)) {

      return false;

    }

  }

  // NOTE we do not copy the null terminator of the string.

  strncpy(outBuf->fillPos(), str, len);

  outBuf->incrFillPos(len);

  return true;

}

bool

IOBuf::writeInt(int val) {

  char buf[128];

  sprintf(buf, "%d", val);

  return writeString(buf);

}

bool

IOBuf::writeUnsignedInt(unsigned int val) {

  char buf[128];

  sprintf(buf, "%u", val);

  return writeString(buf);

}

bool

IOBuf::writeBoolAsInt(bool val) {

  if (val) {

    return writeString("1");

  } else {

    return writeString("0");

  }

}

bool

IOBuf::writeAddress(void* val) {

  char buf[128];

  sprintf(buf, INTPTR_FORMAT, val);

  return writeString(buf);

}

bool

IOBuf::writeSpace() {

  return writeString(" ");

}

bool

IOBuf::writeEOL() {

  return writeString("\n\r");

}

bool

IOBuf::writeBinChar(char c) {

  return writeBinBuf((char*) &c, sizeof(c));

}

bool

IOBuf::writeBinUnsignedShort(unsigned short i) {

  i = htons(i);

  return writeBinBuf((char*) &i, sizeof(i));

}

bool

IOBuf::writeBinUnsignedInt(unsigned int i) {

  i = htonl(i);

  return writeBinBuf((char*) &i, sizeof(i));

}

bool

IOBuf::writeBinBuf(char* buf, int size) {

  while (size > 0) {

    int spaceRemaining = outBuf->remaining();

    if (spaceRemaining == 0) {

      if (!flushImpl(true)) {

        return false;

      }

      spaceRemaining = outBuf->remaining();

    }

    int toCopy = (size > spaceRemaining) ? spaceRemaining : size;

    memcpy(outBuf->fillPos(), buf, toCopy);

    outBuf->incrFillPos(toCopy);

    buf += toCopy;

    size -= toCopy;

    if (size > 0) {

      if (!flushImpl(true)) {

        return false;

      }

    }

  }

  return true;

}

#ifdef WIN32

IOBuf::FillState

IOBuf::fillFromFileHandle(HANDLE fh, DWORD* numBytesRead) {

  int totalToRead;

  char moreToCome;

  outBuf->compact();

  DWORD numRead;

  if (!ReadFile(fh, &totalToRead, sizeof(int), &numRead, NULL)) {

    return FAILED;

  }

  if (numRead != sizeof(int)) {

    return FAILED;

  }

  if (!ReadFile(fh, &moreToCome, 1, &numRead, NULL)) {

    return FAILED;

  }

  if (numRead != 1) {

    return FAILED;

  }

  if (outBuf->remaining() < totalToRead) {

    return FAILED;

  }

  int tmp = totalToRead;

  while (totalToRead > 0) {

    if (!ReadFile(fh, outBuf->fillPos(), totalToRead, &numRead, NULL)) {

      return FAILED;

    }

    outBuf->incrFillPos((int) numRead);

    totalToRead -= numRead;

  }

  *numBytesRead = tmp;

  return ((moreToCome == 0) ? DONE : MORE_DATA_PENDING);

}

#endif

bool

IOBuf::isBinEscapeChar(char c) {

  return (c == '|');

}

IOBuf::Action

IOBuf::processChar(char c) {

  Action action = NO_ACTION;

  switch (state) {

  case TEXT_STATE: {

    // Looking for text char, bin escape char, or EOL

    if (isBinEscapeChar(c)) {

#ifdef DEBUGGING

      fprintf(stderr, "[a: '%c'] ", inBuf[0]);

#endif

      binPos = 0;

#ifdef DEBUGGING

      fprintf(stderr, "[b: '%c'] ", inBuf[0]);

#endif

      binLength = 0;

#ifdef DEBUGGING

      fprintf(stderr, "[c: '%c'] ", inBuf[0]);

#endif

      state = BIN_STATE;

#ifdef DEBUGGING

      fprintf(stderr, "[d: '%c'] ", inBuf[0]);

#endif

#ifdef DEBUGGING

      fprintf(stderr, "\nSwitching to BIN_STATE\n");

#endif

    } else if (isEOL(c)) {

      state = EOL_STATE;

      action = GOT_LINE;

#ifdef DEBUGGING

      fprintf(stderr, "\nSwitching to EOL_STATE (GOT_LINE)\n");

#endif

    }

#ifdef DEBUGGING

    else {

      fprintf(stderr, "'%c' ", c);

      fflush(stderr);

    }

#endif

    break;

  }

  case BIN_STATE: {

    // Seeking to finish read of input

    if (binPos < 4) {

      int cur = c & 0xFF;

      binLength <<= 8;

      binLength |= cur;

      ++binPos;

    } else {

#ifdef DEBUGGING

      fprintf(stderr, "Reading binary byte %d of %d\n",

              binPos - 4, binLength);

#endif

      ++binPos;

      if (binPos == 4 + binLength) {

        state = TEXT_STATE;

#ifdef DEBUGGING

        fprintf(stderr, "Switching to TEXT_STATE\n");

#endif

      }

    }

    break;

  }

  case EOL_STATE: {

    // More EOL characters just cause us to re-enter this state

    if (isEOL(c)) {

      action = SKIP_EOL_CHAR;

    } else if (isBinEscapeChar(c)) {

      binPos = 0;

      binLength = 0;

      state = BIN_STATE;

    } else {

      state = TEXT_STATE;

#ifdef DEBUGGING

      fprintf(stderr, "'%c' ", c);

      fflush(stderr);

#endif

    }

    break;

  }

  } // switch

  return action;

}

bool

IOBuf::isEOL(char c) {

#ifdef WIN32

  return ((c == '\n') || (c == '\r'));

#elif defined(__sun)

  return c == '\n';

#else

  #error Please port isEOL() to your platform

  return false;

#endif

}