ircproxy  The Ultimate Cyborg

---

WhoRequest.cc

Go to the documentation of this file.

// ircproxy -- An IRC bouncer.
//
//! @file WhoRequest.cc
//! @brief This file contains the implementation of class WhoRequest.
//
// Copyright (C) 2007 by
//
// Carlo Wood, Run on IRC <carlo@alinoe.com>
// RSA-1024 0x624ACAD5 1997-01-26                    Sign & Encrypt
// Fingerprint16 = 32 EC A7 B6 AC DB 65 A6  F6 F6 55 DD 1C DC FF 61
//
// This file may be distributed under the terms of the Q Public License
// version 1.0 as appearing in the file LICENSE.QPL included in the
// packaging of this file.

#ifndef USE_PCH
#include "sys.h"
#include "debug.h"
#endif

#include "WhoRequest.h"
#include "is_channel.h"
#include "ircd_chattr.h"
#include "Channel.h"
#include "Nick.h"
#include "exceptions.h"
#include "ClientSession.h"

WhoOptions::WhoOptions(std::string const& options) : M_fields(0)
{
  std::string::size_type pos1 = options.find('%');
  M_flags = options.substr(0, pos1);
  std::string::size_type pos2 = options.find(',');
  if (pos1 == std::string::npos)
    pos2 = std::string::npos;           // To get "sane" behaviour in the case "xyz,abc", where ',' should be interpreted as a flag.
  else
    M_fields = field_percentage;
  if (pos2 != std::string::npos)
    M_querytype = options.substr(pos2 + 1);
  std::string fields_str;
  if (pos1 != std::string::npos)
    fields_str = options.substr(pos1 + 1, pos2 - pos1 - 1);
  for (std::string::iterator c = fields_str.begin(); c != fields_str.end(); ++c)
  {
    switch(*c)
    {
      case 'c':
        M_fields |= field_c;
        break;
      case 'd':
        M_fields |= field_d;
        break;
      case 'f':
        M_fields |= field_f;
        break;
      case 'h':
        M_fields |= field_h;
        break;
      case 'i':
        M_fields |= field_i;
        break;
      case 'l':
        M_fields |= field_l;
        break;
      case 'n':
        M_fields |= field_n;
        break;
      case 'r':
        M_fields |= field_r;
        break;
      case 's':
        M_fields |= field_s;
        break;
      case 't':
        M_fields |= field_t;
        break;
      case 'u':
        M_fields |= field_u;
        break;
      case 'a':
        M_fields |= field_a;
        break;
      case 'o':
        M_fields |= field_o;
        break;
    }
  }
}

std::string WhoOptions::str(void) const
{
  std::string result(M_flags);
  if (M_fields != 0)
    result += '%';
  for (unsigned int field = 1; field < field_percentage; field <<= 1)
    if ((M_fields & field))
      switch(field)
      {
        case field_c:
          result += 'c';
          break;
        case field_d:
          result += 'd';
          break;
        case field_f:
          result += 'f';
          break;
        case field_h:
          result += 'h';
          break;
        case field_i:
          result += 'i';
          break;
        case field_l:
          result += 'l';
          break;
        case field_n:
          result += 'n';
          break;
        case field_r:
          result += 'r';
          break;
        case field_s:
          result += 's';
          break;
        case field_t:
          result += 't';
          break;
        case field_u:
          result += 'u';
          break;
        case field_a:
          result += 'a';
          break;
        case field_o:
          result += 'o';
          break;
      }
  if (!M_querytype.empty())
  {
    if (M_fields == 0)
      result += '%';
    result += ',';
    result += M_querytype;
  }
  return result;
}

bool WhoOptions::matches_against_channel(void) const
{
  return (M_fields & ~field_percentage) == 0 || ((M_fields & field_c) == field_c);
}

void WhoRequest::decode_mask(ClientSession& client_session)
{
  DoutEntering(dc::debug, "WhoRequest::decode_mask(" << client_session << ")");
  M_mask_contains_space = false;
  bool mask_is_channel = is_channel(M_mask) && (M_mask[0] != '@');
  bool mask_is_nick = is_nick(M_mask);
  for (std::string::iterator iter = M_mask.begin(); iter != M_mask.end(); ++iter)
  {
    char c = *iter;
    if (c == ' ')
    {
      M_mask_contains_space = true;
      mask_is_channel = false;
      mask_is_nick = false;
      break;
    }
    if (!IsChannelChar(c))         
      mask_is_channel = false;
    if (!IsNickChar(c))
      mask_is_nick = false;
  }
  if (mask_is_channel)
  {
    try
    {
      // FIXME! M_target = boost::static_pointer_cast<Target>(client_session.get_channel(M_mask));
      M_mask_is_target = true;
    }
    catch(unknown_target& error)
    {
      Debug(edragon::caught(error));
      M_mask_is_target = false;
    }
  }
  else if (mask_is_nick)
  {
    try
    {
      M_target = boost::static_pointer_cast<Target>(client_session.get_nick(M_mask));
      M_mask_is_target = true;
    }
    catch(unknown_target& error)
    {
      Debug(edragon::caught(error));
      M_mask_is_target = false;
    }
  }
  else
    M_mask_is_target = false;
#ifdef CWDEBUG
  if (M_mask_contains_space)
    Dout(dc::debug, "WHO mask contains a space");
  if (M_mask_is_target)
    Dout(dc::debug, "WHO matches the target: " << M_target);
#endif
}

---