Console.h

/*
 * Copyright (c) 2008-2014, Pedigree Developers
 *
 * Please see the CONTRIB file in the root of the source tree for a full
 * list of contributors.
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#ifndef CONSOLE_H
#define CONSOLE_H

#include "ConsoleDefines.h"
#include "modules/system/vfs/File.h"
#include "modules/system/vfs/Filesystem.h"
#include "pedigree/kernel/Spinlock.h"
#include "pedigree/kernel/compiler.h"
#include "pedigree/kernel/process/Mutex.h"
#include "pedigree/kernel/processor/types.h"
#include "pedigree/kernel/utilities/Buffer.h"
#include "pedigree/kernel/utilities/String.h"
#include "pedigree/kernel/utilities/Vector.h"
#include "pedigree/kernel/utilities/utility.h"

class Disk;
class Event;
class Process;
class RequestQueue;

#define DEFAULT_FLAGS                                            \
    (ConsoleManager::OPostProcess | ConsoleManager::IMapCRToNL | \
     ConsoleManager::OMapNLToCRNL | ConsoleManager::LEcho |      \
     ConsoleManager::LEchoErase | ConsoleManager::LEchoKill |    \
     ConsoleManager::LCookedMode | ConsoleManager::LGenerateEvent)

class ConsoleFile : public File
{
    friend class ConsoleMasterFile;
    friend class ConsoleSlaveFile;
    friend class ConsoleManager;

  public:
    ConsoleFile(size_t consoleNumber, String consoleName, Filesystem *pFs);
    virtual ~ConsoleFile()
    {
    }

    virtual bool isMaster() = 0;

    void setEvent(Event *e)
    {
        if (isMaster())
            m_pOther->m_pEvent = e;
        else
            m_pEvent = e;
    }

    virtual char getLast()
    {
        return m_Last;
    }

    Event *getEvent() const
    {
        return m_pEvent;
    }

    void getControlCharacters(char *out)
    {
        MemoryCopy(out, m_ControlChars, MAX_CONTROL_CHAR);
    }

    virtual size_t getBlockSize() const
    {
        return PTY_BUFFER_SIZE;
    }

    size_t getConsoleNumber() const
    {
        return m_ConsoleNumber;
    }

    virtual size_t getPhysicalConsoleNumber() const
    {
        return ~0U;
    }

    virtual void eventComplete()
    {
        if (!isMaster())
            m_pOther->eventComplete();
        else
            m_EventTrigger.release();
    }

  protected:
    virtual int select(bool bWriting, int timeout);

    void inject(char *buf, size_t len, bool canBlock);

    virtual void performInject(char *buf, size_t len, bool canBlock);

    virtual void performEventTrigger(char cause);

    ConsoleFile *m_pOther;

    size_t m_Flags;
    char m_ControlChars[MAX_CONTROL_CHAR];

    unsigned short m_Rows;
    unsigned short m_Cols;

    static size_t
    outputLineDiscipline(char *buf, size_t len, size_t maxSz, size_t flags = 0);

    size_t processInput(char *buf, size_t len);

    void inputLineDiscipline(
        char *buf, size_t len, size_t flags = ~0U,
        const char *controlChars = 0);

    char m_LineBuffer[LINEBUFFER_MAXIMUM];

    size_t m_LineBufferSize;

    size_t m_LineBufferFirstNewline;

    char m_Last;

    Buffer<char> m_Buffer;

  private:
    size_t m_ConsoleNumber;
    String m_Name;

    Event *m_pEvent;

    Mutex m_EventTrigger;

    bool checkForEvent(size_t flags, char check, const char *controlChars);

    void triggerEvent(char cause);

    virtual bool isBytewise() const
    {
        return true;
    }
};

class EXPORTED_PUBLIC ConsoleMasterFile : public ConsoleFile
{
  public:
    ConsoleMasterFile(
        size_t consoleNumber, String consoleName, Filesystem *pFs);
    virtual ~ConsoleMasterFile()
    {
    }

    virtual uint64_t readBytewise(
        uint64_t location, uint64_t size, uintptr_t buffer,
        bool bCanBlock = true);
    virtual uint64_t writeBytewise(
        uint64_t location, uint64_t size, uintptr_t buffer,
        bool bCanBlock = true);

    void setOther(ConsoleFile *pOther)
    {
        m_pOther = pOther;
        m_Flags = pOther->m_Flags;
    }

    bool bLocked;

    Process *pLocker;

    virtual bool isMaster()
    {
        return true;
    }

  private:
};

class EXPORTED_PUBLIC ConsoleSlaveFile : public ConsoleFile
{
  public:
    ConsoleSlaveFile(size_t consoleNumber, String consoleName, Filesystem *pFs);
    virtual ~ConsoleSlaveFile()
    {
    }

    virtual uint64_t readBytewise(
        uint64_t location, uint64_t size, uintptr_t buffer,
        bool bCanBlock = true);
    virtual uint64_t writeBytewise(
        uint64_t location, uint64_t size, uintptr_t buffer,
        bool bCanBlock = true);

    void setOther(ConsoleFile *pOther)
    {
        m_pOther = pOther;
    }

    virtual bool isMaster()
    {
        return false;
    }

    virtual char getLast()
    {
        return m_pOther->getLast();
    }
};

class EXPORTED_PUBLIC ConsolePhysicalFile : public ConsoleFile
{
  public:
    ConsolePhysicalFile(
        size_t nth, File *pTerminal, String consoleName, Filesystem *pFs);
    virtual ~ConsolePhysicalFile()
    {
    }

    virtual uint64_t readBytewise(
        uint64_t location, uint64_t size, uintptr_t buffer,
        bool bCanBlock = true);
    virtual uint64_t writeBytewise(
        uint64_t location, uint64_t size, uintptr_t buffer,
        bool bCanBlock = true);

    virtual bool isMaster()
    {
        return false;
    }

    virtual char getLast()
    {
        return '\0';
    }

    virtual size_t getPhysicalConsoleNumber() const
    {
        return m_TerminalNumber;
    }

    virtual int select(bool bWriting, int timeout);

  private:
    File *m_pTerminal;
    Buffer<char> m_ProcessedInput;
    size_t m_TerminalNumber;

    virtual void performInject(char *buf, size_t len, bool canBlock);
};

class EXPORTED_PUBLIC ConsoleManager : public Filesystem
{
  public:
    enum IAttribute
    {
        IMapCRToNL = 1,
        IIgnoreCR = 2,
        IMapNLToCR = 4,
        IStripToSevenBits = 8
    };
    enum OAttribute
    {
        OPostProcess = 16,
        OMapCRToNL = 32,
        ONoCrAtCol0 = 64,
        OMapNLToCRNL = 128,
        ONLCausesCR = 256
    };
    enum LAttribute
    {
        LEcho = 512,
        LEchoErase = 1024,
        LEchoKill = 2048,
        LEchoNewline = 4096,
        LCookedMode = 8192,
        LGenerateEvent = 16384
    };

    ConsoleManager();

    virtual ~ConsoleManager();

    static ConsoleManager &instance();

    //
    // ConsoleManager interface.
    //
    File *getConsole(String consoleName);
    ConsoleFile *getConsoleFile(RequestQueue *pBackend);

    bool lockConsole(File *file);

    void unlockConsole(File *file);

    void newConsole(char c, size_t i);

    bool isConsole(File *file);
    bool isMasterConsole(File *file);

    void setAttributes(File *file, size_t flags);
    void getAttributes(File *file, size_t *flags);
    void getControlChars(File *file, void *p);
    void setControlChars(File *file, void *p);
    int getWindowSize(File *file, unsigned short *rows, unsigned short *cols);
    int setWindowSize(File *file, unsigned short rows, unsigned short cols);
    bool hasDataAvailable(File *file);
    void flush(File *file);

    File *getOther(File *file);

    //
    // Filesystem interface.
    //

    virtual bool initialise(Disk *pDisk)
    {
        return false;
    }
    virtual File *getRoot() const
    {
        return 0;
    }
    virtual String getVolumeLabel() const
    {
        return String("consolemanager");
    }

  protected:
    virtual bool createFile(File *parent, const String &filename, uint32_t mask)
    {
        return false;
    }
    virtual bool
    createDirectory(File *parent, const String &filename, uint32_t mask)
    {
        return false;
    }
    virtual bool
    createSymlink(File *parent, const String &filename, const String &value)
    {
        return false;
    }
    virtual bool remove(File *parent, File *file)
    {
        return false;
    }

  private:
    Vector<ConsoleFile *> m_Consoles;
    static ConsoleManager m_Instance;
    Spinlock m_Lock;

    void newConsole(char c, size_t i, bool lock);
};

#endif