SocketException.h

Go to the documentation of this file.

/*
 * Deskflow -- mouse and keyboard sharing utility
 * SPDX-FileCopyrightText: (C) 2025 - 2026 Deskflow Developers
 * SPDX-FileCopyrightText: (C) 2012 - 2016 Synergy App Ltd
 * SPDX-FileCopyrightText: (C) 2002 Chris Schoeneman
 * SPDX-License-Identifier: GPL-2.0-only WITH LicenseRef-OpenSSL-Exception
 */
 
#pragma once
 
#include "base/BaseException.h"
#include "io/IOException.h"
 
#include <QByteArray>

class SocketException : public BaseException
{
  using BaseException::BaseException;
};


class SocketAddressException : public SocketException
{
public:
  enum class SocketError
  {
    Unknown,     
    NotFound,    
    NoAddress,   
    Unsupported, 
    BadPort      
  };
 
  SocketAddressException(SocketError, const std::string &hostname, int port) noexcept;
  ~SocketAddressException() throw() override = default;



  SocketError getError() const noexcept;
  std::string getHostname() const noexcept;
  int getPort() const noexcept;

 
protected:
  // BaseException overrides
  QString getWhat() const throw() override;
 
private:
  SocketError m_error;
  std::string m_hostname;
  int m_port;
};

class SocketIOCloseException : public IOCloseException
{
public:
  SocketIOCloseException() : IOCloseException(), m_state(kDone)
  {
    // do nothing
  }
  explicit SocketIOCloseException(const QString &msg) : IOCloseException(msg), m_state(kFirst)
  {
    // do nothing
  }
  ~SocketIOCloseException() throw() override = default;
 
  const char *what() const throw() override
  {
    if (m_state == kFirst) {
      m_state = kFormat;
      m_formatted = getWhat().toLocal8Bit();
      m_state = kDone;
    }
    if (m_state == kDone) {
      return m_formatted.constData();
    } else {
      return IOCloseException::what();
    }
  }
 
protected:
  QString getWhat() const throw() override;
 
private:
  enum EState
  {
    kFirst,
    kFormat,
    kDone
  };
  mutable EState m_state;
  mutable QByteArray m_formatted;
};

class SocketWithWhatException : public SocketException
{
public:
  SocketWithWhatException() : SocketException(), m_state(kDone)
  {
    // do nothing
  }
  explicit SocketWithWhatException(const QString &msg) : SocketException(msg), m_state(kFirst)
  {
    // do nothing
  }
  ~SocketWithWhatException() throw() override = default;
 
  const char *what() const throw() override
  {
    if (m_state == kFirst) {
      m_state = kFormat;
      m_formatted = getWhat().toLocal8Bit();
      m_state = kDone;
    }
    if (m_state == kDone) {
      return m_formatted.constData();
    } else {
      return SocketException::what();
    }
  }
 
private:
  enum EState
  {
    kFirst,
    kFormat,
    kDone
  };
  mutable EState m_state;
  mutable QByteArray m_formatted;
};

class SocketBindException : public SocketWithWhatException
{
  using SocketWithWhatException::SocketWithWhatException;
 
protected:
  QString getWhat() const throw() override;
};

class SocketAddressInUseException : public SocketWithWhatException
{
  using SocketWithWhatException::SocketWithWhatException;
 
protected:
  QString getWhat() const throw() override;
};

class SocketConnectException : public SocketWithWhatException
{
  using SocketWithWhatException::SocketWithWhatException;
 
protected:
  QString getWhat() const throw() override;
};

class SocketCreateException : public SocketWithWhatException
{
  using SocketWithWhatException::SocketWithWhatException;
 
protected:
  QString getWhat() const throw() override;
};