/**************************************************************************/
/*                                                                        */
/* Copyright (c) 2001, 2011 NoMachine (http://www.nomachine.com)          */
/* Copyright (c) 2008-2017 Oleksandr Shneyder <o.shneyder@phoca-gmbh.de>  */
/* Copyright (c) 2014-2022 Ulrich Sibiller <uli42@gmx.de>                 */
/* Copyright (c) 2014-2019 Mihai Moldovan <ionic@ionic.de>                */
/* Copyright (c) 2011-2022 Mike Gabriel <mike.gabriel@das-netzwerkteam.de>*/
/* Copyright (c) 2015-2016 Qindel Group (http://www.qindel.com)           */
/*                                                                        */
/* NXCOMP, NX protocol compression and NX extensions to this software     */
/* are copyright of the aforementioned persons and companies.             */
/*                                                                        */
/* Redistribution and use of the present software is allowed according    */
/* to terms specified in the file LICENSE.nxcomp which comes in the       */
/* source distribution.                                                   */
/*                                                                        */
/* All rights reserved.                                                   */
/*                                                                        */
/* NOTE: This software has received contributions from various other      */
/* contributors, only the core maintainers and supporters are listed as   */
/* copyright holders. Please contact us, if you feel you should be listed */
/* as copyright holder, as well.                                          */
/*                                                                        */
/**************************************************************************/

#ifndef Agent_H
#define Agent_H

#include <unistd.h>

#include <sys/time.h>
#include <sys/types.h>
#include <sys/select.h>

#include "Misc.h"
#include "Transport.h"
#include "Proxy.h"

extern Proxy *proxy;

#define PANIC
#define WARNING
#undef  TEST
#undef  DEBUG

class Agent
{
  public:

  //
  // Must be created by passing the fake descriptor that
  // will be used for simulating socket communication
  // between the agent and the proxy. I/O will take place
  // by copying data to the agent's read and write buf-
  // fers.
  //

  Agent(int fd[2]);

  ~Agent();

  AgentTransport *getTransport() const
  {
    return transport_;
  }

  void saveReadMask(fd_set *readSet)
  {
    saveRead_ = *readSet;
  }

  void saveWriteMask(fd_set *writeSet)
  {
    saveWrite_ = *writeSet;
  }

  void clearReadMask(fd_set *readSet)
  {
    FD_CLR(remoteFd_, readSet);
    FD_CLR(localFd_,  readSet);
  }

  void clearWriteMask(fd_set *writeSet)
  {
    FD_CLR(remoteFd_, writeSet);
    FD_CLR(localFd_,  writeSet);
  }

  void setLocalRead(fd_set *readSet, int *result)
  {
    (*result)++;

    FD_SET(localFd_, readSet);
  }

  void setRemoteRead(fd_set *readSet, int *result)
  {
    (*result)++;

    FD_SET(remoteFd_, readSet);
  }

  void setRemoteWrite(fd_set *writeSet, int *result)
  {
    (*result)++;

    FD_SET(remoteFd_, writeSet);
  }

  fd_set *getSavedReadMask()
  {
    return &saveRead_;
  }

  fd_set *getSavedWriteMask()
  {
    return &saveWrite_;
  }

  int getRemoteFd() const
  {
    return remoteFd_;
  }

  int getLocalFd() const
  {
    return localFd_;
  }

  int getProxyFd() const
  {
    return proxy -> getFd();
  }

  int isValid() const
  {
    return (transport_ != NULL);
  }

  int localReadable()
  {
    return (transport_ -> readable() != 0);
  }

  //
  // Check if we can process more data from
  // the agent descriptor and cache the result
  // to avoid multiple calls. This must be
  // always called before querying the other
  // functions.
  //

  void saveChannelState()
  {
    canRead_ = (proxy != NULL ? proxy -> canRead(localFd_) : 0);
  }

  int remoteCanRead(const fd_set * const readSet)
  {
    // OS X 10.5 requires the second argument to be non-const, so copy readSet.
    // It's safe though, as FD_ISSET does not operate on it.
    fd_set readWorkSet = *readSet;

    #if defined(TEST) || defined(INFO)
    *logofs << "Agent: remoteCanRead() is " <<
               (FD_ISSET(remoteFd_, &readWorkSet) && transport_ -> dequeuable() != 0)
            << " with FD_ISSET() " << (int) FD_ISSET(remoteFd_, &readWorkSet)
            << " and dequeuable " << transport_ -> dequeuable()
            << ".\n" << logofs_flush;
    #endif

    return (FD_ISSET(remoteFd_, &readWorkSet) &&
                transport_ -> dequeuable() != 0);
  }

  int remoteCanWrite(const fd_set * const writeSet)
  {
    // OS X 10.5 requires the second argument to be non-const, so copy writeSet.
    // It's safe though, as FD_ISSET does not operate on it.
    fd_set writeWorkSet = *writeSet;

    #if defined(TEST) || defined(INFO)
    *logofs << "Agent: remoteCanWrite() is " <<
               (FD_ISSET(remoteFd_, &writeWorkSet) && transport_ ->
               queuable() != 0 && canRead_ == 1) << " with FD_ISSET() "
            << (int) FD_ISSET(remoteFd_, &writeWorkSet) << " queueable "
            << transport_ -> queuable() << " channel can read "
            << canRead_ << ".\n" << logofs_flush;
    #endif

    return (FD_ISSET(remoteFd_, &writeWorkSet) &&
                transport_ -> queuable() != 0 &&
                    canRead_ == 1);
  }

  int localCanRead()
  {
    #if defined(TEST) || defined(INFO)
    *logofs << "Agent: localCanRead() is " <<
               (transport_ -> readable() != 0 && canRead_ == 1)
            << " with readable " << transport_ -> readable()
            << " channel can read " << canRead_ << ".\n"
            << logofs_flush;
    #endif

    return (transport_ -> readable() != 0 &&
                canRead_ == 1);
  }

  int proxyCanRead()
  {
    #if defined(TEST) || defined(INFO)
    *logofs << "Agent: proxyCanRead() is " << proxy -> canRead()
            << ".\n" << logofs_flush;
    #endif

    return (proxy -> canRead());
  }

  int proxyCanRead(const fd_set * const readSet)
  {
    // OS X 10.5 requires the second argument to be non-const, so copy readSet.
    // It's safe though, as FD_ISSET does not operate on it.
    fd_set readWorkSet = *readSet;

    #if defined(TEST) || defined(INFO)
    *logofs << "Agent: proxyCanRead() is "
            << ((int) FD_ISSET(proxy -> getFd(), &readWorkSet))
            << ".\n" << logofs_flush;
    #endif

    return (FD_ISSET(proxy -> getFd(), &readWorkSet));
  }

  int enqueueData(const char *data, const int size) const
  {
    return transport_ -> enqueue(data, size);
  }

  int dequeueData(char *data, int size) const
  {
    return transport_ -> dequeue(data, size);
  }

  int dequeuableData() const
  {
    return transport_ -> dequeuable();
  }

  private:

  int remoteFd_;
  int localFd_;

  fd_set saveRead_;
  fd_set saveWrite_;

  int canRead_;

  AgentTransport *transport_;
};

#endif /* Agent_H */