src/base.cpp

   1 /*
   2  * InspIRCd -- Internet Relay Chat Daemon
   3  *
   4  *   Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org>
   5  *   Copyright (C) 2007 Dennis Friis <peavey@inspircd.org>
   6  *   Copyright (C) 2004-2006 Craig Edwards <craigedwards@brainbox.cc>
   7  *   Copyright (C) 2006 Oliver Lupton <oliverlupton@gmail.com>
   8  *
   9  * This file is part of InspIRCd.  InspIRCd is free software: you can
  10  * redistribute it and/or modify it under the terms of the GNU General Public
  11  * License as published by the Free Software Foundation, version 2.
  12  *
  13  * This program is distributed in the hope that it will be useful, but WITHOUT
  14  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  15  * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
  16  * details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20  */
  21
  22
  23 #include "inspircd.h"
  24 #include "base.h"
  25 #include <time.h>
  26 #ifdef INSPIRCD_ENABLE_RTTI
  27 #include <typeinfo>
  28 #endif
  29
  30 classbase::classbase()
  31 {
  32         if (ServerInstance)
  33                 ServerInstance->Logs->Log("CULLLIST", LOG_DEBUG, "classbase::+ @%p", (void*)this);
  34 }
  35
  36 CullResult classbase::cull()
  37 {
  38         if (ServerInstance)
  39 #ifdef INSPIRCD_ENABLE_RTTI
  40                 ServerInstance->Logs->Log("CULLLIST", LOG_DEBUG, "classbase::-%s @%p",
  41                         typeid(*this).name(), (void*)this);
  42 #else
  43                 ServerInstance->Logs->Log("CULLLIST", LOG_DEBUG, "classbase::- @%p", (void*)this);
  44 #endif
  45         return CullResult();
  46 }
  47
  48 classbase::~classbase()
  49 {
  50         if (ServerInstance)
  51                 ServerInstance->Logs->Log("CULLLIST", LOG_DEBUG, "classbase::~ @%p", (void*)this);
  52 }
  53
  54 CullResult::CullResult()
  55 {
  56 }
  57
  58 // This trick detects heap allocations of refcountbase objects
  59 static void* last_heap = NULL;
  60
  61 void* refcountbase::operator new(size_t size)
  62 {
  63         last_heap = ::operator new(size);
  64         return last_heap;
  65 }
  66
  67 void refcountbase::operator delete(void* obj)
  68 {
  69         if (last_heap == obj)
  70                 last_heap = NULL;
  71         ::operator delete(obj);
  72 }
  73
  74 refcountbase::refcountbase() : refcount(0)
  75 {
  76         if (this != last_heap)
  77                 throw CoreException("Reference allocate on the stack!");
  78 }
  79
  80 refcountbase::~refcountbase()
  81 {
  82         if (refcount && ServerInstance)
  83                 ServerInstance->Logs->Log("CULLLIST", LOG_DEBUG, "refcountbase::~ @%p with refcount %d",
  84                         (void*)this, refcount);
  85 }
  86
  87 usecountbase::~usecountbase()
  88 {
  89         if (usecount && ServerInstance)
  90                 ServerInstance->Logs->Log("CULLLIST", LOG_DEBUG, "usecountbase::~ @%p with refcount %d",
  91                         (void*)this, usecount);
  92 }
  93
  94 ServiceProvider::~ServiceProvider()
  95 {
  96 }
  97
  98 void ServiceProvider::RegisterService()
  99 {
 100 }
 101
 102 ExtensionItem::ExtensionItem(const std::string& Key, ExtensibleType exttype, Module* mod)
 103         : ServiceProvider(mod, Key, SERVICE_METADATA)
 104         , type(exttype)
 105 {
 106 }
 107
 108 ExtensionItem::~ExtensionItem()
 109 {
 110 }
 111
 112 void* ExtensionItem::get_raw(const Extensible* container) const
 113 {
 114         Extensible::ExtensibleStore::const_iterator i =
 115                 container->extensions.find(const_cast<ExtensionItem*>(this));
 116         if (i == container->extensions.end())
 117                 return NULL;
 118         return i->second;
 119 }
 120
 121 void* ExtensionItem::set_raw(Extensible* container, void* value)
 122 {
 123         std::pair<Extensible::ExtensibleStore::iterator,bool> rv =
 124                 container->extensions.insert(std::make_pair(this, value));
 125         if (rv.second)
 126         {
 127                 return NULL;
 128         }
 129         else
 130         {
 131                 void* old = rv.first->second;
 132                 rv.first->second = value;
 133                 return old;
 134         }
 135 }
 136
 137 void* ExtensionItem::unset_raw(Extensible* container)
 138 {
 139         Extensible::ExtensibleStore::iterator i = container->extensions.find(this);
 140         if (i == container->extensions.end())
 141                 return NULL;
 142         void* rv = i->second;
 143         container->extensions.erase(i);
 144         return rv;
 145 }
 146
 147 void ExtensionItem::RegisterService()
 148 {
 149         if (!ServerInstance->Extensions.Register(this))
 150                 throw ModuleException("Extension already exists: " + name);
 151 }
 152
 153 bool ExtensionManager::Register(ExtensionItem* item)
 154 {
 155         return types.insert(std::make_pair(item->name, item)).second;
 156 }
 157
 158 void ExtensionManager::BeginUnregister(Module* module, std::vector<reference<ExtensionItem> >& list)
 159 {
 160         ExtMap::iterator i = types.begin();
 161         while (i != types.end())
 162         {
 163                 ExtMap::iterator me = i++;
 164                 ExtensionItem* item = me->second;
 165                 if (item->creator == module)
 166                 {
 167                         list.push_back(item);
 168                         types.erase(me);
 169                 }
 170         }
 171 }
 172
 173 ExtensionItem* ExtensionManager::GetItem(const std::string& name)
 174 {
 175         ExtMap::iterator i = types.find(name);
 176         if (i == types.end())
 177                 return NULL;
 178         return i->second;
 179 }
 180
 181 void Extensible::doUnhookExtensions(const std::vector<reference<ExtensionItem> >& toRemove)
 182 {
 183         for(std::vector<reference<ExtensionItem> >::const_iterator i = toRemove.begin(); i != toRemove.end(); ++i)
 184         {
 185                 ExtensionItem* item = *i;
 186                 ExtensibleStore::iterator e = extensions.find(item);
 187                 if (e != extensions.end())
 188                 {
 189                         item->free(e->second);
 190                         extensions.erase(e);
 191                 }
 192         }
 193 }
 194
 195 Extensible::Extensible()
 196         : culled(false)
 197 {
 198 }
 199
 200 CullResult Extensible::cull()
 201 {
 202         FreeAllExtItems();
 203         culled = true;
 204         return classbase::cull();
 205 }
 206
 207 void Extensible::FreeAllExtItems()
 208 {
 209         for(ExtensibleStore::iterator i = extensions.begin(); i != extensions.end(); ++i)
 210         {
 211                 i->first->free(i->second);
 212         }
 213         extensions.clear();
 214 }
 215
 216 Extensible::~Extensible()
 217 {
 218         if ((!extensions.empty() || !culled) && ServerInstance)
 219                 ServerInstance->Logs->Log("CULLLIST", LOG_DEBUG, "Extensible destructor called without cull @%p", (void*)this);
 220 }
 221
 222 LocalExtItem::LocalExtItem(const std::string& Key, ExtensibleType exttype, Module* mod)
 223         : ExtensionItem(Key, exttype, mod)
 224 {
 225 }
 226
 227 LocalExtItem::~LocalExtItem()
 228 {
 229 }
 230
 231 std::string LocalExtItem::serialize(SerializeFormat format, const Extensible* container, void* item) const
 232 {
 233         return "";
 234 }
 235
 236 void LocalExtItem::unserialize(SerializeFormat format, Extensible* container, const std::string& value)
 237 {
 238 }
 239
 240 LocalStringExt::LocalStringExt(const std::string& Key, ExtensibleType exttype, Module* Owner)
 241         : SimpleExtItem<std::string>(Key, exttype, Owner)
 242 {
 243 }
 244
 245 LocalStringExt::~LocalStringExt()
 246 {
 247 }
 248
 249 std::string LocalStringExt::serialize(SerializeFormat format, const Extensible* container, void* item) const
 250 {
 251         if ((item) && (format != FORMAT_NETWORK))
 252                 return *static_cast<std::string*>(item);
 253         return "";
 254 }
 255
 256 void LocalStringExt::unserialize(SerializeFormat format, Extensible* container, const std::string& value)
 257 {
 258         if (format != FORMAT_NETWORK)
 259                 set(container, value);
 260 }
 261
 262 LocalIntExt::LocalIntExt(const std::string& Key, ExtensibleType exttype, Module* mod)
 263         : LocalExtItem(Key, exttype, mod)
 264 {
 265 }
 266
 267 LocalIntExt::~LocalIntExt()
 268 {
 269 }
 270
 271 std::string LocalIntExt::serialize(SerializeFormat format, const Extensible* container, void* item) const
 272 {
 273         if (format == FORMAT_NETWORK)
 274                 return "";
 275         return ConvToStr(reinterpret_cast<intptr_t>(item));
 276 }
 277
 278 void LocalIntExt::unserialize(SerializeFormat format, Extensible* container, const std::string& value)
 279 {
 280         if (format != FORMAT_NETWORK)
 281                 set(container, ConvToInt(value));
 282 }
 283
 284 intptr_t LocalIntExt::get(const Extensible* container) const
 285 {
 286         return reinterpret_cast<intptr_t>(get_raw(container));
 287 }
 288
 289 intptr_t LocalIntExt::set(Extensible* container, intptr_t value)
 290 {
 291         if (value)
 292                 return reinterpret_cast<intptr_t>(set_raw(container, reinterpret_cast<void*>(value)));
 293         else
 294                 return reinterpret_cast<intptr_t>(unset_raw(container));
 295 }
 296
 297 void LocalIntExt::free(void*)
 298 {
 299 }
 300
 301 StringExtItem::StringExtItem(const std::string& Key, ExtensibleType exttype, Module* mod)
 302         : ExtensionItem(Key, exttype, mod)
 303 {
 304 }
 305
 306 StringExtItem::~StringExtItem()
 307 {
 308 }
 309
 310 std::string* StringExtItem::get(const Extensible* container) const
 311 {
 312         return static_cast<std::string*>(get_raw(container));
 313 }
 314
 315 std::string StringExtItem::serialize(SerializeFormat format, const Extensible* container, void* item) const
 316 {
 317         return item ? *static_cast<std::string*>(item) : "";
 318 }
 319
 320 void StringExtItem::unserialize(SerializeFormat format, Extensible* container, const std::string& value)
 321 {
 322         if (value.empty())
 323                 unset(container);
 324         else
 325                 set(container, value);
 326 }
 327
 328 void StringExtItem::set(Extensible* container, const std::string& value)
 329 {
 330         void* old = set_raw(container, new std::string(value));
 331         delete static_cast<std::string*>(old);
 332 }
 333
 334 void StringExtItem::unset(Extensible* container)
 335 {
 336         void* old = unset_raw(container);
 337         delete static_cast<std::string*>(old);
 338 }
 339
 340 void StringExtItem::free(void* item)
 341 {
 342         delete static_cast<std::string*>(item);
 343 }
 344
 345 ModuleException::ModuleException(const std::string &message, Module* who)
 346         : CoreException(message, who ? who->ModuleSourceFile : "A Module")
 347 {
 348 }