namespace isc {
namespace dhcp {
+/// @brief Exchange MySQL Structure for Lease6
+///
+/// On the INSERT, SELECT and UPDATE statements, an array of MYSQL_BIND
+/// structures must be built to reflect the data being inserted or retrieved
+/// from the database.
+///
+/// Owing to the MySQL API, this process requires some intermediate variables
+/// to hold things like length etc. This object holds the intermediate
+/// variables and can:
+/// 1. Build the MYSQL_BIND structures for a Lease6 object ready for passing
+/// in to the MYSQL code.
+/// 1. Copy information from the MYSQL_BIND structures into a Lease6 object.
+
+class MySqlLease6Exchange {
+public:
+ /// @brief Constructor
+ MySqlLease6Exchange() : false_(0), true_(1) {
+ }
+
+ /// @brief Create MYSQL_BIND objects for Lease6 Pointer
+ ///
+ /// Fills in the bind_ objects for the Lease6 passed to it.
+ ///
+ /// The MySQL documentation
+ ///
+ /// @param lease Lease object to be added to the database
+ ///
+ /// @return Pointer to MYSQL_BIND array holding the bind information.
+ /// This is a pointer to data internal to this object, and remains
+ /// valid only for as long as (1) this object is in existence and
+ /// (2) the lease object passed to it is in existence. The
+ /// caller should NOT delete it.
+ MYSQL_BIND* createBindFromLease(const Lease6Ptr& lease) {
+ // Store lease object to ensure it remains valid.
+ lease_ = lease;
+
+ // Ensure bind array clear.
+ memset(bind_, 0, sizeof(bind_));
+
+ // address: varchar(40)
+ addr6_ = lease_->addr_.toText();
+ addr6_length_ = addr6_.size();
+
+ bind_[0].buffer_type = MYSQL_TYPE_STRING;
+ bind_[0].buffer = const_cast<char*>(addr6_.c_str());
+ bind_[0].buffer_length = addr6_length_;
+ bind_[0].length = &addr6_length_;
+
+ // hwaddr: binary(20)
+ hwaddr_length_ = lease_->hwaddr_.size();
+
+ bind_[1].buffer_type = MYSQL_TYPE_BLOB;
+ bind_[1].buffer = reinterpret_cast<char*>(&(lease_->hwaddr_[0]));
+ bind_[1].buffer_length = hwaddr_length_;
+ bind_[1].length = &hwaddr_length_;
+
+ // client_id: varchar(128)
+ clientid_ = lease_->duid_->getDuid();
+ clientid_length_ = clientid_.size();
+
+ bind_[2].buffer_type = MYSQL_TYPE_BLOB;
+ bind_[2].buffer = reinterpret_cast<char*>(&(clientid_[0]));
+ bind_[2].buffer_length = clientid_length_;
+ bind_[2].length = &clientid_length_;
+
+ // The lease structure holds the client last transmission time (cltt_)
+ // and the valid lifetime (valid_lft_). For convenience for external
+ // tools, the data stored in the database is expiry time (expire) and
+ // lease time (lease+time). The relationship is given by:
+ //
+ // lease_time - valid_lft_
+ // expire = cltt_ + valid_lft_
+ //
+ MySqlLeaseMgr::convertToDatabaseTime(lease_->cltt_, lease_->valid_lft_,
+ expire_, lease_time_);
+
+ // lease_time: unsigned int
+ bind_[3].buffer_type = MYSQL_TYPE_LONG;
+ bind_[3].buffer = reinterpret_cast<char*>(&lease_time_);
+ bind_[3].is_unsigned = true_;
+
+ // expire: timestamp
+ bind_[4].buffer_type = MYSQL_TYPE_TIMESTAMP;
+ bind_[4].buffer = reinterpret_cast<char*>(&expire_);
+ bind_[4].buffer_length = sizeof(expire_);
+
+ // subnet_id: unsigned int
+ // Can use lease_->subnet_id_ directly as it is of type uint32_t.
+ bind_[5].buffer_type = MYSQL_TYPE_LONG;
+ bind_[5].buffer = reinterpret_cast<char*>(&lease_->subnet_id_);
+ bind_[5].is_unsigned = true_;
+
+ // pref_lifetime: unsigned int
+ // Can use lease_->preferred_lft_ directly as it is of type uint32_t.
+ bind_[6].buffer_type = MYSQL_TYPE_LONG;
+ bind_[6].buffer = reinterpret_cast<char*>(&lease_->preferred_lft_);
+ bind_[6].is_unsigned = true_;
+
+ // lease_type: tinyint
+ // Must convert to uint8_t as lease_->type_ is a LeaseType variable
+ lease_type_ = lease_->type_;
+ bind_[7].buffer_type = MYSQL_TYPE_TINY;
+ bind_[7].buffer = reinterpret_cast<char*>(&lease_type_);
+ bind_[7].is_unsigned = static_cast<my_bool>(1);
+
+ // iaid: unsigned int
+ // Can use lease_->iaid_ directly as it is of type uint32_t.
+ bind_[8].buffer_type = MYSQL_TYPE_LONG;
+ bind_[8].buffer = reinterpret_cast<char*>(&lease_->iaid_);
+ bind_[8].is_unsigned = true_;
+
+ // prefix_len: unsigned tinyint
+ // Can use lease_->prefixlen_ directly as it is uint32_t.
+ bind_[9].buffer_type = MYSQL_TYPE_TINY;
+ bind_[9].buffer = reinterpret_cast<char*>(&lease_->prefixlen_);
+ bind_[9].is_unsigned = true_;
+
+ return(bind_);
+ }
+
+private:
+ std::string addr6_; ///< String form of address
+ unsigned long addr6_length_; ///< Length of the address
+ MYSQL_BIND bind_[10]; ///< Static array for speed of access
+ std::vector<uint8_t> clientid_; ///< Client identification
+ unsigned long clientid_length_; ///< Length of client ID
+ MYSQL_TIME expire_; ///< Lease expiry time
+ const my_bool false_; ///< "false" for MySql
+ unsigned long hwaddr_length_; ///< Length of hardware address
+ Lease6Ptr lease_; ///< Pointer to lease object
+ uint32_t lease_time_; ///< Lease time
+ uint8_t lease_type_; ///< Lease type
+ const my_bool true_; ///< "true_" for MySql
+};
+
+
+
+///
+
// Time conversion methods.
//
// Note that the MySQL TIMESTAMP data type (used for "expire") converts data
// must be local time.
void
-MySqlLeaseMgr::convertFromLeaseTime(time_t cltt, uint32_t valid_lft,
+MySqlLeaseMgr::convertToDatabaseTime(time_t cltt, uint32_t valid_lft,
MYSQL_TIME& expire, uint32_t& lease_time) {
// Calculate expiry time and convert to various date/time fields.
}
void
-MySqlLeaseMgr::convertToLeaseTime(const MYSQL_TIME& expire, uint32_t lease_time,
+MySqlLeaseMgr::convertFromDatabaseTime(const MYSQL_TIME& expire, uint32_t lease_time,
time_t& cltt, uint32_t& valid_lft) {
valid_lft = lease_time;
bool
MySqlLeaseMgr::addLease(const Lease6Ptr& lease) {
- my_bool MLM_FALSE = 0;
- MYSQL_BIND bind[10];
- memset(bind, 0, sizeof(bind));
-
- // address: varchar(40)
- std::string addr6 = lease->addr_.toText();
- unsigned long addr6_length = addr6.size();
-
- bind[0].buffer_type = MYSQL_TYPE_STRING;
- bind[0].buffer = const_cast<char*>(addr6.c_str());
- bind[0].buffer_length = addr6_length;
- bind[0].length = &addr6_length;
- bind[0].is_null = &MLM_FALSE;
-
- // hwaddr: binary(20)
- unsigned long hwaddr_length = lease->hwaddr_.size();
-
- bind[1].buffer_type = MYSQL_TYPE_BLOB;
-
- bind[1].buffer = reinterpret_cast<char*>(&(lease->hwaddr_[0]));
- bind[1].buffer_length = hwaddr_length;
- bind[1].length = &hwaddr_length;
- bind[1].is_null = &MLM_FALSE;
-
- // client_id: varchar(128)
- vector<uint8_t> clientid = lease->duid_->getDuid();
- unsigned long clientid_length = clientid.size();
-
- bind[2].buffer_type = MYSQL_TYPE_BLOB;
- bind[2].buffer = reinterpret_cast<char*>(&(clientid[0]));
- bind[2].buffer_length = clientid_length;
- bind[2].length = &clientid_length;
- bind[2].is_null = &MLM_FALSE;
-
- // The lease structure holds the client last transmission time (cltt_)
- // and the valid lifetime (valid_lft_). For convenience, the data stored
- // in the database is expiry time (expire) and lease time (lease+time).
- // The relationship is given by:
- //
- // lease_time - valid_lft_
- // expire = cltt_ + valid_lft_
- MYSQL_TIME mysql_expire;
- uint32_t lease_time;
- convertFromLeaseTime(lease->cltt_, lease->valid_lft_,
- mysql_expire, lease_time);
-
- // lease_time: unsigned int
- bind[3].buffer_type = MYSQL_TYPE_LONG;
- bind[3].buffer = reinterpret_cast<char*>(&lease_time);
- bind[3].is_unsigned = 1;
- bind[3].is_null = &MLM_FALSE;
-
- // expire: timestamp
- bind[4].buffer_type = MYSQL_TYPE_TIMESTAMP;
- bind[4].buffer = reinterpret_cast<char*>(&mysql_expire);
- bind[4].buffer_length = sizeof(mysql_expire);
- bind[4].is_null = &MLM_FALSE;
-
- // subnet_id: unsigned int
- bind[5].buffer_type = MYSQL_TYPE_LONG;
- bind[5].buffer = reinterpret_cast<char*>(&(lease->subnet_id_));
- bind[5].is_unsigned = static_cast<my_bool>(1);
- bind[5].is_null = &MLM_FALSE;
-
- // pref_lifetime: unsigned int
- bind[6].buffer_type = MYSQL_TYPE_LONG;
- bind[6].buffer = reinterpret_cast<char*>(&(lease->preferred_lft_));
- bind[6].is_unsigned = static_cast<my_bool>(1);
- bind[6].is_null = &MLM_FALSE;
-
- // lease_type: tinyint
- uint8_t lease_type = lease->type_; // Needed for int -> uint8_t conversion
- bind[7].buffer_type = MYSQL_TYPE_TINY;
- bind[7].buffer = reinterpret_cast<char*>(&lease_type);
- bind[7].is_unsigned = static_cast<my_bool>(1);
- bind[7].is_null = &MLM_FALSE;
-
- // iaid: unsigned int
- bind[8].buffer_type = MYSQL_TYPE_LONG;
- bind[8].buffer = reinterpret_cast<char*>(&(lease->iaid_));
- bind[8].is_unsigned = static_cast<my_bool>(1);
- bind[8].is_null = &MLM_FALSE;
-
- // prefix_len: unsigned tinyint
- bind[9].buffer_type = MYSQL_TYPE_TINY;
- bind[9].buffer = reinterpret_cast<char*>(&(lease->prefixlen_));
- bind[9].is_unsigned = static_cast<my_bool>(1);
- bind[9].is_null = &MLM_FALSE;
+ // Create the MYSQL_BIND array for the lease
+ MySqlLease6Exchange exchange;
+ MYSQL_BIND* bind = exchange.createBindFromLease(lease);
// Bind the parameters to the statement
my_bool status = mysql_stmt_bind_param(statements_[INSERT_LEASE6], bind);
result->addr_ = addr;
result->hwaddr_ = vector<uint8_t>(&hwaddr[0], &hwaddr[hwaddr_length]);
result->duid_.reset(new DUID(clientid, clientid_length));
- convertToLeaseTime(mysql_expire, lease_time,
- result->cltt_, result->valid_lft_);
+ convertFromDatabaseTime(mysql_expire, lease_time,
+ result->cltt_, result->valid_lft_);
result->subnet_id_ = subnet_id;
result->preferred_lft_ = pref_lifetime;
switch (lease_type) {
/// @exception DbOperationError Database function failed
virtual bool addLease(const Lease6Ptr& lease);
- /// @brief Returns existing IPv4 lease for specified IPv4 address and subnet_id
+ /// @brief Return IPv4 lease for specified IPv4 address and subnet_id
///
/// This method is used to get a lease for specific subnet_id. There can be
/// at most one lease for any given subnet, so this method returns a single
/// pointer.
///
- /// @param addr address of the searched lease
+ /// @param addr address of the sought lease
/// @param subnet_id ID of the subnet the lease must belong to
///
/// @return smart pointer to the lease (or NULL if a lease is not found)
///@{
/// The following methods are used to convert between times and time
- /// intervals stored in the server in the Lease object, and the times
- /// stored in the database. The reason for the difference is because
- /// in the DHCP server, the cltt (Client Time Since Last Transmission)
- /// is the natural data: in the lease file - which may be read by the
- /// user - it is the expiry time of the lease.
+ /// intervals stored in the Lease object, and the times stored in the
+ /// database. The reason for the difference is because in the DHCP server,
+ /// the cltt (Client Time Since Last Transmission) is the natural data; in
+ /// the lease file - which may be read by the user - it is the expiry time
+ /// of the lease.
/// @brief Convert Lease Time to Database Times
///
/// is stored as lease_time (lease time) and expire (time of expiry of the
/// lease). They are related by the equations:
///
- /// lease_time = valid_lft
- /// expire = cltt + valid_lft
+ /// - lease_time = valid_lft
+ /// - expire = cltt + valid_lft
///
/// This method converts from the times in the lease object into times
/// able to be added to the database.
/// @param lease_time Reference to the time_t object where the lease time
/// will be put.
static
- void convertFromLeaseTime(time_t cltt, uint32_t valid_lft,
+ void convertToDatabaseTime(time_t cltt, uint32_t valid_lft,
MYSQL_TIME& expire, uint32_t& lease_time);
/// @brief Convert Database Time to Lease Times
/// Within the database, time is stored as lease_time (lease time) and
/// expire (time of expiry of the lease). In the DHCP server, the
/// information is stored as cltt (client last transmit time) and
- /// valid_lft (valid lifetime). These arr related by the equations:
+ /// valid_lft (valid lifetime). These are related by the equations:
///
- /// valid_lft = lease_time
- /// cltt = expire - lease_time
+ /// - valid_lft = lease_time
+ /// - cltt = expire - lease_time
///
/// This method converts from the times in the database into times
/// able to be inserted into the lease object.
/// is put.
/// @param valid_lft Reference to location where valid lifetime is put.
static
- void convertToLeaseTime(const MYSQL_TIME& expire, uint32_t lease_time,
- time_t& cltt, uint32_t& valid_lft);
+ void convertFromDatabaseTime(const MYSQL_TIME& expire, uint32_t lease_time,
+ time_t& cltt, uint32_t& valid_lft);
///@}
private:
- /// @brief Enum of Statements
+ /// @brief Statement Tags
///
- /// This is provided to set indexes into a list of prepared statements.
+ /// The contents of the enum are indexes into the list of SQL statements
enum StatementIndex {
GET_LEASE6,
GET_VERSION, // Obtain version number
projects / thirdparty / kea.git / commitdiff
