Kea  2.3.2-git
callout_handle.cc
Go to the documentation of this file.
1 // Copyright (C) 2013-2022 Internet Systems Consortium, Inc. ("ISC")
2 //
3 // This Source Code Form is subject to the terms of the Mozilla Public
4 // License, v. 2.0. If a copy of the MPL was not distributed with this
5 // file, You can obtain one at http://mozilla.org/MPL/2.0/.
6 
7 #include <config.h>
8 
9 #include <hooks/callout_handle.h>
10 #include <hooks/callout_manager.h>
11 #include <hooks/library_handle.h>
12 #include <hooks/server_hooks.h>
13 
14 #include <string>
15 #include <utility>
16 #include <vector>
17 
18 using namespace std;
19 
20 namespace isc {
21 namespace hooks {
22 
23 // Constructor.
24 CalloutHandle::CalloutHandle(const boost::shared_ptr<CalloutManager>& manager,
25  const boost::shared_ptr<LibraryManagerCollection>& lmcoll)
26  : lm_collection_(lmcoll), arguments_(), context_collection_(),
27  manager_(manager), server_hooks_(ServerHooks::getServerHooks()),
28  current_library_(-1), current_hook_(-1), next_step_(NEXT_STEP_CONTINUE) {
29 
30  // Call the "context_create" hook. We should be OK doing this - although
31  // the constructor has not finished running, all the member variables
32  // have been created.
33  manager_->callCallouts(ServerHooks::CONTEXT_CREATE, *this);
34 }
35 
36 // Destructor
38  // Call the "context_destroy" hook. We should be OK doing this - although
39  // the destructor is being called, all the member variables are still in
40  // existence.
41  manager_->callCallouts(ServerHooks::CONTEXT_DESTROY, *this);
42 
43  // Explicitly clear the argument and context objects. This should free up
44  // all memory that could have been allocated by libraries that were loaded.
45  arguments_.clear();
46  context_collection_.clear();
47 
48  // Normal destruction of the remaining variables will include the
49  // destruction of lm_collection_, an action that decrements the reference
50  // count on the library manager collection (which holds the libraries that
51  // could have allocated memory in the argument and context members.) When
52  // that goes to zero, the libraries will be unloaded: at that point nothing
53  // in the hooks framework will be pointing to memory in the libraries'
54  // address space.
55  //
56  // It is possible that some other data structure in the server (the program
57  // using the hooks library) still references the address space and attempts
58  // to access it causing a segmentation fault. That issue is outside the
59  // scope of this framework and is not addressed by it.
60 }
61 
62 // Return the name of all argument items.
63 
64 vector<string>
66  vector<string> names;
67  for (ElementCollection::const_iterator i = arguments_.begin();
68  i != arguments_.end(); ++i) {
69  names.push_back(i->first);
70  }
71 
72  return (names);
73 }
74 
77  return (boost::make_shared<ParkingLotHandle>(server_hooks_.getParkingLotPtr(current_hook_)));
78 }
79 
80 // Return the context for the currently pointed-to library. This version is
81 // used by the "setContext()" method and creates a context for the current
82 // library if it does not exist.
83 
85 CalloutHandle::getContextForLibrary() {
86  // Access a reference to the element collection for the given index,
87  // creating a new element collection if necessary, and return it.
88  return (context_collection_[current_library_]);
89 }
90 
91 // The "const" version of the above, used by the "getContext()" method. If
92 // the context for the current library doesn't exist, throw an exception.
93 
95 CalloutHandle::getContextForLibrary() const {
96  auto libcontext = context_collection_.find(current_library_);
97  if (libcontext == context_collection_.end()) {
98  isc_throw(NoSuchCalloutContext, "unable to find callout context "
99  "associated with the current library index (" << current_library_ <<
100  ")");
101  }
102 
103  // Return a reference to the context's element collection.
104  return (libcontext->second);
105 }
106 
107 // Return the name of all items in the context associated with the current]
108 // library.
109 
110 vector<string>
112  vector<string> names;
113  const ElementCollection& elements = getContextForLibrary();
114  for (ElementCollection::const_iterator i = elements.begin();
115  i != elements.end(); ++i) {
116  names.push_back(i->first);
117  }
118 
119  return (names);
120 }
121 
122 // Return name of current hook (the hook to which the current callout is
123 // attached) or the empty string if not called within the context of a
124 // callout.
125 
126 string
128  string hook = "";
129  try {
130  hook = server_hooks_.getName(current_hook_);
131  } catch (const NoSuchHook&) {
132  // Hook index is invalid, so this methods probably called from outside
133  // a callout being executed via a call to CalloutManager::callCallouts.
134  // In this case, the empty string is returned.
135  }
136 
137  return (hook);
138 }
139 
142  : callout_handle_(callout_handle) {
143  if (!callout_handle_) {
144  isc_throw(BadValue, "callout_handle argument must not be null");
145  }
146 
147  resetState();
148 }
149 
151  resetState();
152 
153  if (on_completion_) {
154  on_completion_();
155  }
156 }
157 
158 void
159 ScopedCalloutHandleState::resetState() {
160  // No need to check if the handle is null because the constructor
161  // already checked that.
162  callout_handle_->deleteAllArguments();
163  callout_handle_->setStatus(CalloutHandle::NEXT_STEP_CONTINUE);
164 }
165 
166 } // namespace hooks
167 } // namespace isc
static const int CONTEXT_CREATE
Index numbers for pre-defined hooks.
Definition: server_hooks.h:66
ParkingLotHandlePtr getParkingLotHandlePtr() const
Returns pointer to the parking lot handle for this hook point.
ParkingLotPtr getParkingLotPtr(const int hook_index)
Returns pointer to the ParkingLot for the specified hook index.
std::vector< std::string > getArgumentNames() const
Get argument names.
STL namespace.
std::string getName(int index) const
Get hook name.
ScopedCalloutHandleState(const CalloutHandlePtr &callout_handle)
Constructor.
#define isc_throw(type, stream)
A shortcut macro to insert known values into exception arguments.
A generic exception that is thrown if a parameter given to a method is considered invalid in that con...
std::function< void()> on_completion_
Continuation callback.
std::string getHookName() const
Get hook name.
std::map< std::string, boost::any > ElementCollection
Typedef to allow abbreviation of iterator specification in methods.
static const int CONTEXT_DESTROY
Definition: server_hooks.h:67
Defines the logger used by the top-level component of kea-lfc.
Invalid hook.
Definition: server_hooks.h:36
boost::shared_ptr< CalloutHandle > CalloutHandlePtr
A shared pointer to a CalloutHandle object.
std::vector< std::string > getContextNames() const
Get context names.
No such callout context item.
boost::shared_ptr< ParkingLotHandle > ParkingLotHandlePtr
Pointer to the parking lot handle.
Definition: parking_lots.h:381
Server hook collection.
Definition: server_hooks.h:62