securityd/src/structure.cpp

   1 /*
   2  * Copyright (c) 2000-2001,2004,2009 Apple Inc. All Rights Reserved.
   3  *
   4  * @APPLE_LICENSE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License. Please obtain a copy of the License at
  10  * http://www.opensource.apple.com/apsl/ and read it before using this
  11  * file.
  12  *
  13  * The Original Code and all software distributed under the License are
  14  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  15  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  16  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  18  * Please see the License for the specific language governing rights and
  19  * limitations under the License.
  20  *
  21  * @APPLE_LICENSE_HEADER_END@
  22  */
  23
  24
  25 //
  26 // structure - structural framework for securityd objects
  27 //
  28 #include "structure.h"
  29
  30
  31 //
  32 // NodeCore always has a destructor (because it's virtual),
  33 // but its dump support is conditionally included.
  34 //
  35 NodeCore::~NodeCore()
  36 try {
  37 #if defined(DEBUGDUMP)
  38         StLock<Mutex> _(mCoreLock);
  39         mCoreNodes.erase(this);
  40 #endif //DEBUGDUMP
  41 } catch(...) {
  42     return;
  43 }
  44
  45
  46 //
  47 // Basic object mesh maintainance
  48 //
  49 void NodeCore::parent(NodeCore &p)
  50 {
  51         StLock<Mutex> _(*this);
  52         mParent = &p;
  53 }
  54
  55 void NodeCore::referent(NodeCore &r)
  56 {
  57         StLock<Mutex> _(*this);
  58         assert(!mReferent);
  59         mReferent = &r;
  60 }
  61
  62 void NodeCore::clearReferent()
  63 {
  64         StLock<Mutex> _(*this);
  65         mReferent = NULL;
  66 }
  67
  68
  69 void NodeCore::addReference(NodeCore &p)
  70 {
  71         StLock<Mutex> _(*this);
  72         assert(p.mReferent == this);
  73         mReferences.insert(&p);
  74 }
  75
  76 void NodeCore::removeReference(NodeCore &p)
  77 {
  78         StLock<Mutex> _(*this);
  79         mReferences.erase(&p);
  80 }
  81
  82 //
  83 // ClearReferences clears the reference set but does not propagate
  84 // anything; it is NOT recursive.
  85 //
  86 void NodeCore::clearReferences()
  87 {
  88         StLock<Mutex> _(*this);
  89         secinfo("ssnode", "%p clearing all %d references", this, int(mReferences.size()));
  90         mReferences.erase(mReferences.begin(), mReferences.end());
  91 }
  92
  93
  94 //
  95 // Kill should be overloaded by Nodes to implement any cleanup and release
  96 // operations that should happen at LOGICAL death of the represented object.
  97 // This is where you should release ports, close files, etc.
  98 // This default behavior, which you MUST include in your override,
  99 // propagates kills to all active references, recursively.
 100 //
 101 void NodeCore::kill()
 102 {
 103         StLock<Mutex> _(*this);
 104         for (ReferenceSet::const_iterator it = mReferences.begin(); it != mReferences.end(); it++)
 105                 (*it)->kill();
 106         clearReferences();
 107 }
 108
 109
 110 void NodeCore::kill(NodeCore &ref)
 111 {
 112         StLock<Mutex> _(*this);
 113         ref.kill();
 114         removeReference(ref);
 115 }
 116
 117
 118 //
 119 // NodeCore-level support for state dumping.
 120 // Call NodeCore::dumpAll() to debug-dump all nodes.
 121 // Note that enabling DEBUGDUMP serializes all node creation/destruction
 122 // operations, and thus may cause significant shifts in thread interactions.
 123 //
 124 #if defined(DEBUGDUMP)
 125
 126 // The (uncounted) set of all known NodeCores in existence, with protective lock
 127 set<NodeCore *> NodeCore::mCoreNodes;
 128 Mutex NodeCore::mCoreLock;
 129
 130 // add a new NodeCore to the known set
 131 NodeCore::NodeCore()
 132         : Mutex(Mutex::recursive)
 133 {
 134         StLock<Mutex> _(mCoreLock);
 135         mCoreNodes.insert(this);
 136 }
 137
 138 // partial-line common dump text for any NodeCore
 139 // override this to add text to your Node type's state dump output
 140 void NodeCore::dumpNode()
 141 {
 142  Debug::dump("%s@%p rc=%u", Debug::typeName(*this).c_str(), this, unsigned(refCountForDebuggingOnly()));
 143         if (mParent)
 144                 Debug::dump(" parent=%p", mParent.get());
 145         if (mReferent)
 146                 Debug::dump(" referent=%p", mReferent.get());
 147 }
 148
 149 // full-line dump of a NodeCore
 150 // override this to completely re-implement the dump format for your Node type
 151 void NodeCore::dump()
 152 {
 153  dumpNode();
 154         if (!mReferences.empty()) {
 155                 Debug::dump(" {");
 156                 for (ReferenceSet::const_iterator it = mReferences.begin(); it != mReferences.end(); it++) {
 157                         Debug::dump(" %p", it->get());
 158                         if ((*it)->mReferent != this)
 159                                 Debug::dump("!*INVALID*");
 160                 }
 161                 Debug::dump(" }");
 162         }
 163         Debug::dump("\n");
 164 }
 165
 166 // dump all known nodes
 167 void NodeCore::dumpAll()
 168 {
 169  StLock<Mutex> _(mCoreLock);
 170         time_t now; time(&now);
 171         Debug::dump("\nNODE DUMP (%24.24s)\n", ctime(&now));
 172         for (set<NodeCore *>::const_iterator it = mCoreNodes.begin(); it != mCoreNodes.end(); it++)
 173                 (*it)->dump();
 174         Debug::dump("END NODE DUMP\n\n");
 175 }
 176
 177 #endif //DEBUGDUMP