const char* DHCP4_LEASE_LOGGER_NAME = "leases";
isc::log::Logger dhcp4_logger(DHCP4_APP_LOGGER_NAME);
-isc::log::Logger bad_packet_logger(DHCP4_BAD_PACKET_LOGGER_NAME);
-isc::log::Logger packet_logger(DHCP4_PACKET_LOGGER_NAME);
-isc::log::Logger options_logger(DHCP4_OPTIONS_LOGGER_NAME);
-isc::log::Logger ddns_logger(DHCP4_DDNS_LOGGER_NAME);
-isc::log::Logger lease_logger(DHCP4_LEASE_LOGGER_NAME);
+isc::log::Logger bad_packet4_logger(DHCP4_BAD_PACKET_LOGGER_NAME);
+isc::log::Logger packet4_logger(DHCP4_PACKET_LOGGER_NAME);
+isc::log::Logger options4_logger(DHCP4_OPTIONS_LOGGER_NAME);
+isc::log::Logger ddns4_logger(DHCP4_DDNS_LOGGER_NAME);
+isc::log::Logger lease4_logger(DHCP4_LEASE_LOGGER_NAME);
} // namespace dhcp
} // namespace isc
/// Here "bad packets" are packets that are either dropped (i.e malformed,
/// unsupported types) or packets that are rejected and NAKed for logical
/// reasons.
-extern isc::log::Logger bad_packet_logger;
+extern isc::log::Logger bad_packet4_logger;
/// @brief Logger for processed packets.
///
/// This logger is used to issue log messages related to the reception and
/// sending DHCP packets.
-extern isc::log::Logger packet_logger;
+extern isc::log::Logger packet4_logger;
/// @brief Logger for options parser.
///
/// This logger is used to issue log messages related to processing of the
/// DHCP options
-extern isc::log::Logger options_logger;
+extern isc::log::Logger options4_logger;
/// @brief Logger for Hostname or FQDN processing.
///
/// This logger is used to issue log messages related to processing the
/// hostnames, FQDNs and sending name change requests to D2.
-extern isc::log::Logger ddns_logger;
+extern isc::log::Logger ddns4_logger;
/// @brief Logger for lease allocation logic.
///
/// This logger is used to issue log messages related to lease allocation.
-extern isc::log::Logger lease_logger;
+extern isc::log::Logger lease4_logger;
//@}
if (subnet) {
// Log at higher debug level that subnet has been found.
- LOG_DEBUG(packet_logger, DBG_DHCP4_BASIC_DATA, DHCP4_SUBNET_SELECTED)
+ LOG_DEBUG(packet4_logger, DBG_DHCP4_BASIC_DATA, DHCP4_SUBNET_SELECTED)
.arg(query->getLabel())
.arg(subnet->getID());
// Log detailed information about the selected subnet at the
// lower debug level.
- LOG_DEBUG(packet_logger, DBG_DHCP4_DETAIL_DATA, DHCP4_SUBNET_DATA)
+ LOG_DEBUG(packet4_logger, DBG_DHCP4_DETAIL_DATA, DHCP4_SUBNET_DATA)
.arg(query->getLabel())
.arg(subnet->toText());
} else {
- LOG_DEBUG(packet_logger, DBG_DHCP4_DETAIL,
+ LOG_DEBUG(packet4_logger, DBG_DHCP4_DETAIL,
DHCP4_SUBNET_SELECTION_FAILED)
.arg(query->getLabel());
}
if (timeout == 0) {
timeout = 1000;
}
- LOG_DEBUG(packet_logger, DBG_DHCP4_DETAIL, DHCP4_BUFFER_WAIT).arg(timeout);
+ LOG_DEBUG(packet4_logger, DBG_DHCP4_DETAIL, DHCP4_BUFFER_WAIT).arg(timeout);
query = receivePacket(timeout);
// Log if packet has arrived. We can't log the detailed information
// point are: the interface, source address and destination addresses
// and ports.
if (query) {
- LOG_DEBUG(packet_logger, DBG_DHCP4_BASIC, DHCP4_BUFFER_RECEIVED)
+ LOG_DEBUG(packet4_logger, DBG_DHCP4_BASIC, DHCP4_BUFFER_RECEIVED)
.arg(query->getRemoteAddr().toText())
.arg(query->getRemotePort())
.arg(query->getLocalAddr().toText())
.arg(query->getIface());
} else {
- LOG_DEBUG(packet_logger, DBG_DHCP4_DETAIL, DHCP4_BUFFER_WAIT_INTERRUPTED)
+ LOG_DEBUG(packet4_logger, DBG_DHCP4_DETAIL, DHCP4_BUFFER_WAIT_INTERRUPTED)
.arg(timeout);
}
// SIGINT or SIGHUP which are handled by the server. For signals
// that are not handled by the server we rely on the default
// behavior of the system.
- LOG_DEBUG(packet_logger, DBG_DHCP4_DETAIL, DHCP4_BUFFER_WAIT_SIGNAL)
+ LOG_DEBUG(packet4_logger, DBG_DHCP4_DETAIL, DHCP4_BUFFER_WAIT_SIGNAL)
.arg(signal_set_->getNext());
} catch (const std::exception& e) {
// Log all other errors.
- LOG_ERROR(packet_logger, DHCP4_BUFFER_RECEIVE_FAIL).arg(e.what());
+ LOG_ERROR(packet4_logger, DHCP4_BUFFER_RECEIVE_FAIL).arg(e.what());
}
// Handle next signal received by the process. It must be called after
// indicated they did it
if (!skip_unpack) {
try {
- LOG_DEBUG(options_logger, DBG_DHCP4_DETAIL, DHCP4_BUFFER_UNPACK)
+ LOG_DEBUG(options4_logger, DBG_DHCP4_DETAIL, DHCP4_BUFFER_UNPACK)
.arg(query->getRemoteAddr().toText())
.arg(query->getLocalAddr().toText())
.arg(query->getIface());
query->unpack();
} catch (const std::exception& e) {
// Failed to parse the packet.
- LOG_DEBUG(bad_packet_logger, DBG_DHCP4_DETAIL,
+ LOG_DEBUG(bad_packet4_logger, DBG_DHCP4_DETAIL,
DHCP4_PACKET_DROP_0001)
.arg(query->getRemoteAddr().toText())
.arg(query->getLocalAddr().toText())
// We have sanity checked (in accept() that the Message Type option
// exists, so we can safely get it here.
int type = query->getType();
- LOG_DEBUG(packet_logger, DBG_DHCP4_BASIC_DATA, DHCP4_PACKET_RECEIVED)
+ LOG_DEBUG(packet4_logger, DBG_DHCP4_BASIC_DATA, DHCP4_PACKET_RECEIVED)
.arg(query->getLabel())
.arg(query->getName())
.arg(type)
.arg(query->getRemoteAddr())
.arg(query->getLocalAddr())
.arg(query->getIface());
- LOG_DEBUG(packet_logger, DBG_DHCP4_DETAIL_DATA, DHCP4_QUERY_DATA)
+ LOG_DEBUG(packet4_logger, DBG_DHCP4_DETAIL_DATA, DHCP4_QUERY_DATA)
.arg(query->getLabel())
.arg(query->toText());
// (The problem is logged as a debug message because debug is
// disabled by default - it prevents a DDOS attack based on the
// sending of problem packets.)
- LOG_DEBUG(bad_packet_logger, DBG_DHCP4_BASIC,
+ LOG_DEBUG(bad_packet4_logger, DBG_DHCP4_BASIC,
DHCP4_PACKET_DROP_0007)
.arg(query->getLabel())
.arg(e.what());
if (!skip_pack) {
try {
- LOG_DEBUG(options_logger, DBG_DHCP4_DETAIL, DHCP4_PACKET_PACK)
+ LOG_DEBUG(options4_logger, DBG_DHCP4_DETAIL, DHCP4_PACKET_PACK)
.arg(rsp->getLabel());
rsp->pack();
} catch (const std::exception& e) {
- LOG_ERROR(options_logger, DHCP4_PACKET_PACK_FAIL)
+ LOG_ERROR(options4_logger, DHCP4_PACKET_PACK_FAIL)
.arg(rsp->getLabel())
.arg(e.what());
}
callout_handle->getArgument("response4", rsp);
}
- LOG_DEBUG(packet_logger, DBG_DHCP4_BASIC, DHCP4_PACKET_SEND)
+ LOG_DEBUG(packet4_logger, DBG_DHCP4_BASIC, DHCP4_PACKET_SEND)
.arg(rsp->getLabel())
.arg(rsp->getName())
.arg(static_cast<int>(rsp->getType()))
.arg(rsp->getRemotePort())
.arg(rsp->getIface());
- LOG_DEBUG(packet_logger, DBG_DHCP4_DETAIL_DATA,
+ LOG_DEBUG(packet4_logger, DBG_DHCP4_DETAIL_DATA,
DHCP4_RESPONSE_DATA)
.arg(rsp->getLabel())
.arg(rsp->getName())
processStatsSent(rsp);
} catch (const std::exception& e) {
- LOG_ERROR(packet_logger, DHCP4_PACKET_SEND_FAIL)
+ LOG_ERROR(packet4_logger, DHCP4_PACKET_SEND_FAIL)
.arg(rsp->getLabel())
.arg(e.what());
}
Option4ClientFqdnPtr fqdn = boost::dynamic_pointer_cast<Option4ClientFqdn>
(ex.getQuery()->getOption(DHO_FQDN));
if (fqdn) {
- LOG_DEBUG(ddns_logger, DBG_DHCP4_DETAIL, DHCP4_CLIENT_FQDN_PROCESS)
+ LOG_DEBUG(ddns4_logger, DBG_DHCP4_DETAIL, DHCP4_CLIENT_FQDN_PROCESS)
.arg(ex.getQuery()->getLabel());
processClientFqdnOption(ex);
OptionStringPtr hostname = boost::dynamic_pointer_cast<OptionString>
(ex.getQuery()->getOption(DHO_HOST_NAME));
if (hostname) {
- LOG_DEBUG(ddns_logger, DBG_DHCP4_DETAIL, DHCP4_CLIENT_HOSTNAME_PROCESS)
+ LOG_DEBUG(ddns4_logger, DBG_DHCP4_DETAIL, DHCP4_CLIENT_HOSTNAME_PROCESS)
.arg(ex.getQuery()->getLabel());
processHostnameOption(ex);
}
// from the log. We don't want to throw an exception here because,
// it will impact the processing of the whole packet. We rather want
// the processing to continue, even if the client's name is wrong.
- LOG_DEBUG(ddns_logger, DBG_DHCP4_DETAIL_DATA, DHCP4_CLIENT_NAME_PROC_FAIL)
+ LOG_DEBUG(ddns4_logger, DBG_DHCP4_DETAIL_DATA, DHCP4_CLIENT_NAME_PROC_FAIL)
.arg(ex.getQuery()->getLabel())
.arg(e.what());
}
Option4ClientFqdnPtr fqdn = boost::dynamic_pointer_cast<
Option4ClientFqdn>(ex.getQuery()->getOption(DHO_FQDN));
- LOG_DEBUG(ddns_logger, DBG_DHCP4_DETAIL_DATA, DHCP4_CLIENT_FQDN_DATA)
+ LOG_DEBUG(ddns4_logger, DBG_DHCP4_DETAIL_DATA, DHCP4_CLIENT_FQDN_DATA)
.arg(ex.getQuery()->getLabel())
.arg(fqdn->toText());
// If we don't store the option in the response message, we will have to
// propagate it in the different way to the functions which acquire the
// lease. This would require modifications to the API of this class.
- LOG_DEBUG(ddns_logger, DBG_DHCP4_DETAIL_DATA, DHCP4_RESPONSE_FQDN_DATA)
+ LOG_DEBUG(ddns4_logger, DBG_DHCP4_DETAIL_DATA, DHCP4_RESPONSE_FQDN_DATA)
.arg(ex.getQuery()->getLabel())
.arg(fqdn_resp->toText());
ex.getResponse()->addOption(fqdn_resp);
OptionStringPtr opt_hostname = boost::dynamic_pointer_cast<OptionString>
(ex.getQuery()->getOption(DHO_HOST_NAME));
- LOG_DEBUG(ddns_logger, DBG_DHCP4_DETAIL_DATA, DHCP4_CLIENT_HOSTNAME_DATA)
+ LOG_DEBUG(ddns4_logger, DBG_DHCP4_DETAIL_DATA, DHCP4_CLIENT_HOSTNAME_DATA)
.arg(ex.getQuery()->getLabel())
.arg(opt_hostname->getValue());
/// @todo It would be more liberal to accept this and let it fall into
/// the case of replace or less than two below.
if (label_count == 0) {
- LOG_DEBUG(ddns_logger, DBG_DHCP4_DETAIL_DATA, DHCP4_EMPTY_HOSTNAME)
+ LOG_DEBUG(ddns4_logger, DBG_DHCP4_DETAIL_DATA, DHCP4_EMPTY_HOSTNAME)
.arg(ex.getQuery()->getLabel());
return;
}
opt_hostname_resp->setValue(d2_mgr.qualifyName(hostname, false));
}
- LOG_DEBUG(ddns_logger, DBG_DHCP4_DETAIL_DATA, DHCP4_RESPONSE_HOSTNAME_DATA)
+ LOG_DEBUG(ddns4_logger, DBG_DHCP4_DETAIL_DATA, DHCP4_RESPONSE_HOSTNAME_DATA)
.arg(ex.getQuery()->getLabel())
.arg(opt_hostname_resp->getValue());
ex.getResponse()->addOption(opt_hostname_resp);
try {
dhcid = computeDhcid(lease);
} catch (const DhcidComputeError& ex) {
- LOG_ERROR(ddns_logger, DHCP4_DHCID_COMPUTE_ERROR)
+ LOG_ERROR(ddns4_logger, DHCP4_DHCID_COMPUTE_ERROR)
.arg(lease->toText())
.arg(ex.what());
return;
lease->valid_lft_),
lease->valid_lft_));
- LOG_DEBUG(ddns_logger, DBG_DHCP4_DETAIL_DATA, DHCP4_QUEUE_NCR)
+ LOG_DEBUG(ddns4_logger, DBG_DHCP4_DETAIL_DATA, DHCP4_QUEUE_NCR)
.arg(chg_type == CHG_ADD ? "add" : "remove")
.arg(ncr->toText());
// misconfiguration of the server (or some relays).
// Perhaps this should be logged on some higher level?
- LOG_ERROR(bad_packet_logger, DHCP4_PACKET_NAK_0001)
+ LOG_ERROR(bad_packet4_logger, DHCP4_PACKET_NAK_0001)
.arg(query->getLabel())
.arg(query->getRemoteAddr().toText())
.arg(query->getName());
// and whether the client is known, i.e., has a lease.
if (!fake_allocation && !opt_serverid && opt_requested_address) {
- LOG_DEBUG(lease_logger, DBG_DHCP4_DETAIL, DHCP4_INIT_REBOOT)
+ LOG_DEBUG(lease4_logger, DBG_DHCP4_DETAIL, DHCP4_INIT_REBOOT)
.arg(query->getLabel())
.arg(hint.toText());
// validating the address sent because we don't want to respond if
// we don't know this client.
if (!lease || !lease->belongsToClient(hwaddr, client_id)) {
- LOG_DEBUG(bad_packet_logger, DBG_DHCP4_DETAIL,
+ LOG_DEBUG(bad_packet4_logger, DBG_DHCP4_DETAIL,
DHCP4_NO_LEASE_INIT_REBOOT)
.arg(query->getLabel())
.arg(hint.toText());
// We know this client so we can now check if his notion of the
// IP address is correct.
if (lease && (lease->addr_ != hint)) {
- LOG_DEBUG(bad_packet_logger, DBG_DHCP4_DETAIL,
+ LOG_DEBUG(bad_packet4_logger, DBG_DHCP4_DETAIL,
DHCP4_PACKET_NAK_0002)
.arg(query->getLabel())
.arg(hint.toText());
if (lease) {
// We have a lease! Let's set it in the packet and send it back to
// the client.
- LOG_DEBUG(lease_logger, DBG_DHCP4_BASIC_DATA, fake_allocation?
+ LOG_DEBUG(lease4_logger, DBG_DHCP4_BASIC_DATA, fake_allocation?
DHCP4_LEASE_ADVERT : DHCP4_LEASE_ALLOC)
.arg(query->getLabel())
.arg(lease->addr_.toText());
lease->hostname_ = CfgMgr::instance().getD2ClientMgr()
.generateFqdn(lease->addr_, static_cast<bool>(fqdn));
- LOG_DEBUG(ddns_logger, DBG_DHCP4_DETAIL, DHCP4_RESPONSE_HOSTNAME_GENERATE)
+ LOG_DEBUG(ddns4_logger, DBG_DHCP4_DETAIL, DHCP4_RESPONSE_HOSTNAME_GENERATE)
.arg(query->getLabel())
.arg(lease->hostname_);
}
} catch (const Exception& ex) {
- LOG_ERROR(ddns_logger, DHCP4_NAME_GEN_UPDATE_FAIL)
+ LOG_ERROR(ddns4_logger, DHCP4_NAME_GEN_UPDATE_FAIL)
.arg(query->getLabel())
.arg(lease->hostname_)
.arg(ex.what());
// real allocation.
if (!fake_allocation && CfgMgr::instance().ddnsEnabled()) {
try {
- LOG_DEBUG(ddns_logger, DBG_DHCP4_DETAIL, DHCP4_NCR_CREATE)
+ LOG_DEBUG(ddns4_logger, DBG_DHCP4_DETAIL, DHCP4_NCR_CREATE)
.arg(query->getLabel());
createNameChangeRequests(lease, ctx->old_lease_);
} catch (const Exception& ex) {
- LOG_ERROR(ddns_logger, DHCP4_NCR_CREATION_FAILED)
+ LOG_ERROR(ddns4_logger, DHCP4_NCR_CREATION_FAILED)
.arg(query->getLabel())
.arg(ex.what());
}
} else {
// Allocation engine did not allocate a lease. The engine logged
// cause of that failure.
- LOG_DEBUG(bad_packet_logger, DBG_DHCP4_DETAIL, fake_allocation ?
+ LOG_DEBUG(bad_packet4_logger, DBG_DHCP4_DETAIL, fake_allocation ?
DHCP4_PACKET_NAK_0003 : DHCP4_PACKET_NAK_0004)
.arg(query->getLabel())
.arg(query->getCiaddr().toText())
/// doing class specific processing.
if (!classSpecificProcessing(ex)) {
/// @todo add more verbosity here
- LOG_DEBUG(options_logger, DBG_DHCP4_DETAIL, DHCP4_DISCOVER_CLASS_PROCESSING_FAILED)
+ LOG_DEBUG(options4_logger, DBG_DHCP4_DETAIL, DHCP4_DISCOVER_CLASS_PROCESSING_FAILED)
.arg(discover->getLabel());
}
/// doing class specific processing.
if (!classSpecificProcessing(ex)) {
/// @todo add more verbosity here
- LOG_DEBUG(options_logger, DBG_DHCP4_DETAIL, DHCP4_REQUEST_CLASS_PROCESSING_FAILED)
+ LOG_DEBUG(options4_logger, DBG_DHCP4_DETAIL, DHCP4_REQUEST_CLASS_PROCESSING_FAILED)
.arg(ex.getQuery()->getLabel());
}
Subnet4Ptr subnet = selectSubnet(release);
if (!subnet) {
// No subnet - release no sent from the proper location
- LOG_DEBUG(bad_packet_logger, DBG_DHCP4_DETAIL,
+ LOG_DEBUG(bad_packet4_logger, DBG_DHCP4_DETAIL,
DHCP4_RELEASE_FAIL_NO_SUBNET)
.arg(release->getLabel())
.arg(release->getCiaddr().toText());
if (!lease) {
// No such lease - bogus release
- LOG_DEBUG(lease_logger, DBG_DHCP4_DETAIL, DHCP4_RELEASE_FAIL_NO_LEASE)
+ LOG_DEBUG(lease4_logger, DBG_DHCP4_DETAIL, DHCP4_RELEASE_FAIL_NO_LEASE)
.arg(release->getLabel())
.arg(release->getCiaddr().toText());
return;
}
if (!lease->belongsToClient(release->getHWAddr(), client_id)) {
- LOG_DEBUG(lease_logger, DBG_DHCP4_DETAIL, DHCP4_RELEASE_FAIL_WRONG_CLIENT)
+ LOG_DEBUG(lease4_logger, DBG_DHCP4_DETAIL, DHCP4_RELEASE_FAIL_WRONG_CLIENT)
.arg(release->getLabel())
.arg(release->getCiaddr().toText());
return;
if (success) {
// Release successful
- LOG_DEBUG(lease_logger, DBG_DHCP4_DETAIL, DHCP4_RELEASE)
+ LOG_DEBUG(lease4_logger, DBG_DHCP4_DETAIL, DHCP4_RELEASE)
.arg(release->getLabel())
.arg(lease->addr_.toText());
}
} else {
// Release failed
- LOG_ERROR(lease_logger, DHCP4_RELEASE_FAIL)
+ LOG_ERROR(lease4_logger, DHCP4_RELEASE_FAIL)
.arg(release->getLabel())
.arg(lease->addr_.toText());
}
}
} catch (const isc::Exception& ex) {
- LOG_ERROR(lease_logger, DHCP4_RELEASE_EXCEPTION)
+ LOG_ERROR(lease4_logger, DHCP4_RELEASE_EXCEPTION)
.arg(release->getLabel())
.arg(release->getCiaddr())
.arg(ex.what());
// be cleared (these fields were copied by the copyDefaultFields function).
// Also Relay Agent Options should be removed if present.
if (ack->getRemoteAddr() != inform->getGiaddr()) {
- LOG_DEBUG(packet_logger, DBG_DHCP4_DETAIL, DHCP4_INFORM_DIRECT_REPLY)
+ LOG_DEBUG(packet4_logger, DBG_DHCP4_DETAIL, DHCP4_INFORM_DIRECT_REPLY)
.arg(inform->getLabel())
.arg(ack->getRemoteAddr())
.arg(ack->getIface());
/// @todo: decide whether we want to add a new hook point for
/// doing class specific processing.
if (!classSpecificProcessing(ex)) {
- LOG_DEBUG(options_logger, DBG_DHCP4_DETAIL,
+ LOG_DEBUG(options4_logger, DBG_DHCP4_DETAIL,
DHCP4_INFORM_CLASS_PROCESSING_FAILED)
.arg(inform->getLabel());
}
// Check if the message from directly connected client (if directly
// connected) should be dropped or processed.
if (!acceptDirectRequest(query)) {
- LOG_DEBUG(bad_packet_logger, DBG_DHCP4_DETAIL, DHCP4_PACKET_DROP_0002)
+ LOG_DEBUG(bad_packet4_logger, DBG_DHCP4_DETAIL, DHCP4_PACKET_DROP_0002)
.arg(query->getLabel())
.arg(query->getIface());
return (false);
// Check if the DHCPv4 packet has been sent to us or to someone else.
// If it hasn't been sent to us, drop it!
if (!acceptServerId(query)) {
- LOG_DEBUG(bad_packet_logger, DBG_DHCP4_DETAIL, DHCP4_PACKET_DROP_0003)
+ LOG_DEBUG(bad_packet4_logger, DBG_DHCP4_DETAIL, DHCP4_PACKET_DROP_0003)
.arg(query->getLabel())
.arg(query->getIface());
return (false);
type = query->getType();
} catch (...) {
- LOG_DEBUG(bad_packet_logger, DBG_DHCP4_DETAIL, DHCP4_PACKET_DROP_0004)
+ LOG_DEBUG(bad_packet4_logger, DBG_DHCP4_DETAIL, DHCP4_PACKET_DROP_0004)
.arg(query->getLabel())
.arg(query->getIface());
return (false);
// If we receive a message with a non-existing type, we are logging it.
if (type > DHCPLEASEQUERYDONE) {
- LOG_DEBUG(bad_packet_logger, DBG_DHCP4_DETAIL, DHCP4_PACKET_DROP_0005)
+ LOG_DEBUG(bad_packet4_logger, DBG_DHCP4_DETAIL, DHCP4_PACKET_DROP_0005)
.arg(query->getLabel())
.arg(type);
return (false);
if ((type != DHCPDISCOVER) && (type != DHCPREQUEST) &&
(type != DHCPRELEASE) && (type != DHCPDECLINE) &&
(type != DHCPINFORM)) {
- LOG_DEBUG(bad_packet_logger, DBG_DHCP4_DETAIL, DHCP4_PACKET_DROP_0006)
+ LOG_DEBUG(bad_packet4_logger, DBG_DHCP4_DETAIL, DHCP4_PACKET_DROP_0006)
.arg(query->getLabel())
.arg(type);
return (false);
}
if (!classes.empty()) {
- LOG_DEBUG(options_logger, DBG_DHCP4_BASIC, DHCP4_CLASS_ASSIGNED)
+ LOG_DEBUG(options4_logger, DBG_DHCP4_BASIC, DHCP4_CLASS_ASSIGNED)
.arg(pkt->getLabel())
.arg(classes);
}
Dhcpv4Srv::d2ClientErrorHandler(const
dhcp_ddns::NameChangeSender::Result result,
dhcp_ddns::NameChangeRequestPtr& ncr) {
- LOG_ERROR(ddns_logger, DHCP4_DDNS_REQUEST_SEND_FAILED).
+ LOG_ERROR(ddns4_logger, DHCP4_DDNS_REQUEST_SEND_FAILED).
arg(result).arg((ncr ? ncr->toText() : " NULL "));
// We cannot communicate with kea-dhcp-ddns, suspend further updates.
/// @todo We may wish to revisit this, but for now we will simply turn
const char* DHCP6_LEASE_LOGGER_NAME = "leases";
isc::log::Logger dhcp6_logger(DHCP6_APP_LOGGER_NAME);
-isc::log::Logger bad_packet_logger(DHCP6_BAD_PACKET_LOGGER_NAME);
-isc::log::Logger packet_logger(DHCP6_PACKET_LOGGER_NAME);
-isc::log::Logger options_logger(DHCP6_OPTIONS_LOGGER_NAME);
-isc::log::Logger ddns_logger(DHCP6_DDNS_LOGGER_NAME);
-isc::log::Logger lease_logger(DHCP6_LEASE_LOGGER_NAME);
+isc::log::Logger bad_packet6_logger(DHCP6_BAD_PACKET_LOGGER_NAME);
+isc::log::Logger packet6_logger(DHCP6_PACKET_LOGGER_NAME);
+isc::log::Logger options6_logger(DHCP6_OPTIONS_LOGGER_NAME);
+isc::log::Logger ddns6_logger(DHCP6_DDNS_LOGGER_NAME);
+isc::log::Logger lease6_logger(DHCP6_LEASE_LOGGER_NAME);
} // namespace dhcp
} // namespace isc
///
/// Here "bad packets" are packets that are either dropped (i.e malformed,
/// unsupported types) or packets that are rejected for logical reasons.
-extern isc::log::Logger bad_packet_logger;
+extern isc::log::Logger bad_packet6_logger;
/// @brief Logger for processed packets.
///
/// This logger is used to issue log messages related to the reception and
/// sending DHCP packets.
-extern isc::log::Logger packet_logger;
+extern isc::log::Logger packet6_logger;
/// @brief Logger for options parser.
///
/// This logger is used to issue log messages related to processing of the
/// DHCP options
-extern isc::log::Logger options_logger;
+extern isc::log::Logger options6_logger;
/// @brief Logger for Hostname or FQDN processing.
///
/// This logger is used to issue log messages related to processing the
/// hostnames, FQDNs and sending name change requests to D2.
-extern isc::log::Logger ddns_logger;
+extern isc::log::Logger ddns6_logger;
/// @brief Logger for lease allocation logic.
///
/// This logger is used to issue log messages related to lease allocation.
-extern isc::log::Logger lease_logger;
+extern isc::log::Logger lease6_logger;
//@}
const std::string& status_message) {
Option6StatusCodePtr option_status(new Option6StatusCode(status_code,
status_message));
- LOG_DEBUG(options_logger, DBG_DHCP6_DETAIL, DHCP6_ADD_GLOBAL_STATUS_CODE)
+ LOG_DEBUG(options6_logger, DBG_DHCP6_DETAIL, DHCP6_ADD_GLOBAL_STATUS_CODE)
.arg(pkt.getLabel())
.arg(option_status->dataToText());
return (option_status);
const std::string& status_message) {
Option6StatusCodePtr option_status(new Option6StatusCode(status_code,
status_message));
- LOG_DEBUG(options_logger, DBG_DHCP6_DETAIL, DHCP6_ADD_STATUS_CODE_FOR_IA)
+ LOG_DEBUG(options6_logger, DBG_DHCP6_DETAIL, DHCP6_ADD_STATUS_CODE_FOR_IA)
.arg(pkt.getLabel())
.arg(ia.getIAID())
.arg(option_status->dataToText());
// Let us test received ServerID if it is same as ServerID
// which is being used by server
if (getServerID()->getData() != server_id->getData()){
- LOG_DEBUG(bad_packet_logger, DBG_DHCP6_DETAIL_DATA,
+ LOG_DEBUG(bad_packet6_logger, DBG_DHCP6_DETAIL_DATA,
DHCP6_PACKET_DROP_SERVERID_MISMATCH)
.arg(pkt->getLabel())
.arg(duidToString(server_id))
case DHCPV6_REBIND:
case DHCPV6_INFORMATION_REQUEST:
if (pkt->relay_info_.empty() && !pkt->getLocalAddr().isV6Multicast()) {
- LOG_DEBUG(bad_packet_logger, DBG_DHCP6_DETAIL, DHCP6_PACKET_DROP_UNICAST)
+ LOG_DEBUG(bad_packet6_logger, DBG_DHCP6_DETAIL, DHCP6_PACKET_DROP_UNICAST)
.arg(pkt->getLabel())
.arg(pkt->getName());
return (false);
if (timeout == 0) {
timeout = 1000;
}
- LOG_DEBUG(packet_logger, DBG_DHCP6_DETAIL, DHCP6_BUFFER_WAIT).arg(timeout);
+ LOG_DEBUG(packet6_logger, DBG_DHCP6_DETAIL, DHCP6_BUFFER_WAIT).arg(timeout);
query = receivePacket(timeout);
// Log if packet has arrived. We can't log the detailed information
// point are: the interface, source address and destination addresses
// and ports.
if (query) {
- LOG_DEBUG(packet_logger, DBG_DHCP6_BASIC, DHCP6_BUFFER_RECEIVED)
+ LOG_DEBUG(packet6_logger, DBG_DHCP6_BASIC, DHCP6_BUFFER_RECEIVED)
.arg(query->getRemoteAddr().toText())
.arg(query->getRemotePort())
.arg(query->getLocalAddr().toText())
StatsMgr::instance().addValue("pkt6-received", static_cast<int64_t>(1));
} else {
- LOG_DEBUG(packet_logger, DBG_DHCP6_DETAIL, DHCP6_BUFFER_WAIT_INTERRUPTED)
+ LOG_DEBUG(packet6_logger, DBG_DHCP6_DETAIL, DHCP6_BUFFER_WAIT_INTERRUPTED)
.arg(timeout);
}
// SIGINT or SIGHUP which are handled by the server. For signals
// that are not handled by the server we rely on the default
// behavior of the system.
- LOG_DEBUG(packet_logger, DBG_DHCP6_DETAIL, DHCP6_BUFFER_WAIT_SIGNAL)
+ LOG_DEBUG(packet6_logger, DBG_DHCP6_DETAIL, DHCP6_BUFFER_WAIT_SIGNAL)
.arg(signal_set_->getNext());
} catch (const std::exception& e) {
- LOG_ERROR(packet_logger, DHCP6_PACKET_RECEIVE_FAIL).arg(e.what());
+ LOG_ERROR(packet6_logger, DHCP6_PACKET_RECEIVE_FAIL).arg(e.what());
}
// Handle next signal received by the process. It must be called after
// indicated they did it
if (!skip_unpack) {
try {
- LOG_DEBUG(options_logger, DBG_DHCP6_DETAIL, DHCP6_BUFFER_UNPACK)
+ LOG_DEBUG(options6_logger, DBG_DHCP6_DETAIL, DHCP6_BUFFER_UNPACK)
.arg(query->getRemoteAddr().toText())
.arg(query->getLocalAddr().toText())
.arg(query->getIface());
query->unpack();
} catch (const std::exception &e) {
// Failed to parse the packet.
- LOG_DEBUG(bad_packet_logger, DBG_DHCP6_DETAIL,
+ LOG_DEBUG(bad_packet6_logger, DBG_DHCP6_DETAIL,
DHCP6_PACKET_DROP_PARSE_FAIL)
.arg(query->getRemoteAddr().toText())
.arg(query->getLocalAddr().toText())
continue;
}
- LOG_DEBUG(packet_logger, DBG_DHCP6_BASIC_DATA, DHCP6_PACKET_RECEIVED)
+ LOG_DEBUG(packet6_logger, DBG_DHCP6_BASIC_DATA, DHCP6_PACKET_RECEIVED)
.arg(query->getLabel())
.arg(query->getName())
.arg(query->getType())
.arg(query->getRemoteAddr())
.arg(query->getLocalAddr())
.arg(query->getIface());
- LOG_DEBUG(packet_logger, DBG_DHCP6_DETAIL_DATA, DHCP6_QUERY_DATA)
+ LOG_DEBUG(packet6_logger, DBG_DHCP6_DETAIL_DATA, DHCP6_QUERY_DATA)
.arg(query->getLabel())
.arg(query->toText());
default:
// We received a packet type that we do not recognize.
- LOG_DEBUG(bad_packet_logger, DBG_DHCP6_BASIC, DHCP6_UNKNOWN_MSG_RECEIVED)
+ LOG_DEBUG(bad_packet6_logger, DBG_DHCP6_BASIC, DHCP6_UNKNOWN_MSG_RECEIVED)
.arg(static_cast<int>(query->getType()))
.arg(query->getIface());
// Only action is to output a message if debug is enabled,
}
} catch (const RFCViolation& e) {
- LOG_DEBUG(bad_packet_logger, DBG_DHCP6_BASIC, DHCP6_REQUIRED_OPTIONS_CHECK_FAIL)
+ LOG_DEBUG(bad_packet6_logger, DBG_DHCP6_BASIC, DHCP6_REQUIRED_OPTIONS_CHECK_FAIL)
.arg(query->getName())
.arg(query->getRemoteAddr().toText())
.arg(e.what());
// (The problem is logged as a debug message because debug is
// disabled by default - it prevents a DDOS attack based on the
// sending of problem packets.)
- LOG_DEBUG(bad_packet_logger, DBG_DHCP6_BASIC, DHCP6_PACKET_PROCESS_FAIL)
+ LOG_DEBUG(bad_packet6_logger, DBG_DHCP6_BASIC, DHCP6_PACKET_PROCESS_FAIL)
.arg(query->getName())
.arg(query->getRemoteAddr().toText())
.arg(e.what());
}
}
- LOG_DEBUG(packet_logger, DBG_DHCP6_DETAIL_DATA,
+ LOG_DEBUG(packet6_logger, DBG_DHCP6_DETAIL_DATA,
DHCP6_RESPONSE_DATA)
.arg(static_cast<int>(rsp->getType())).arg(rsp->toText());
try {
rsp->pack();
} catch (const std::exception& e) {
- LOG_ERROR(options_logger, DHCP6_PACK_FAIL)
+ LOG_ERROR(options6_logger, DHCP6_PACK_FAIL)
.arg(e.what());
continue;
}
callout_handle->getArgument("response6", rsp);
}
- LOG_DEBUG(packet_logger, DBG_DHCP6_DETAIL_DATA,
+ LOG_DEBUG(packet6_logger, DBG_DHCP6_DETAIL_DATA,
DHCP6_RESPONSE_DATA)
.arg(static_cast<int>(rsp->getType())).arg(rsp->toText());
processStatsSent(rsp);
} catch (const std::exception& e) {
- LOG_ERROR(packet_logger, DHCP6_PACKET_SEND_FAIL)
+ LOG_ERROR(packet6_logger, DHCP6_PACKET_SEND_FAIL)
.arg(e.what());
}
}
if (subnet) {
// Log at higher debug level that subnet has been found.
- LOG_DEBUG(packet_logger, DBG_DHCP6_BASIC_DATA, DHCP6_SUBNET_SELECTED)
+ LOG_DEBUG(packet6_logger, DBG_DHCP6_BASIC_DATA, DHCP6_SUBNET_SELECTED)
.arg(question->getLabel())
.arg(subnet->getID());
// Log detailed information about the selected subnet at the
// lower debug level.
- LOG_DEBUG(packet_logger, DBG_DHCP6_DETAIL_DATA, DHCP6_SUBNET_DATA)
+ LOG_DEBUG(packet6_logger, DBG_DHCP6_DETAIL_DATA, DHCP6_SUBNET_DATA)
.arg(question->getLabel())
.arg(subnet->toText());
} else {
- LOG_DEBUG(packet_logger, DBG_DHCP6_DETAIL, DHCP6_SUBNET_SELECTION_FAILED)
+ LOG_DEBUG(packet6_logger, DBG_DHCP6_DETAIL, DHCP6_SUBNET_SELECTION_FAILED)
.arg(question->getLabel());
}
return;
}
- LOG_DEBUG(ddns_logger, DBG_DHCP6_DETAIL, DHCP6_DDNS_RECEIVE_FQDN)
+ LOG_DEBUG(ddns6_logger, DBG_DHCP6_DETAIL, DHCP6_DDNS_RECEIVE_FQDN)
.arg(question->getLabel())
.arg(fqdn->toText());
// response to be sent to a client. Note that the Client FQDN option is
// always sent back to the client if Client FQDN was included in the
// client's message.
- LOG_DEBUG(ddns_logger, DBG_DHCP6_DETAIL, DHCP6_DDNS_RESPONSE_FQDN_DATA)
+ LOG_DEBUG(ddns6_logger, DBG_DHCP6_DETAIL, DHCP6_DDNS_RESPONSE_FQDN_DATA)
.arg(question->getLabel())
.arg(fqdn_resp->toText());
answer->addOption(fqdn_resp);
iaaddr->getAddress().toText(),
dhcid, 0, iaaddr->getValid()));
- LOG_DEBUG(ddns_logger, DBG_DHCP6_DETAIL,
+ LOG_DEBUG(ddns6_logger, DBG_DHCP6_DETAIL,
DHCP6_DDNS_CREATE_ADD_NAME_CHANGE_REQUEST).arg(ncr->toText());
// Post the NCR to the D2ClientMgr.
// Don't create NameChangeRequests if DNS updates are disabled
// or DNS update hasn't been performed.
if (!CfgMgr::instance().ddnsEnabled() || (!lease->fqdn_fwd_ && !lease->fqdn_rev_)) {
- LOG_DEBUG(ddns_logger, DBG_DHCP6_DETAIL_DATA,
+ LOG_DEBUG(ddns6_logger, DBG_DHCP6_DETAIL_DATA,
DHCP6_DDNS_SKIP_REMOVE_NAME_CHANGE_REQUEST)
.arg(query->getLabel())
.arg(lease->toText());
OptionDataTypeUtil::writeFqdn(lease->hostname_, hostname_wire, true);
} catch (const Exception& ex) {
- LOG_ERROR(ddns_logger, DHCP6_DDNS_REMOVE_INVALID_HOSTNAME)
+ LOG_ERROR(ddns6_logger, DHCP6_DDNS_REMOVE_INVALID_HOSTNAME)
.arg(query->getLabel())
.arg(lease->hostname_.empty() ? "(empty)" : lease->hostname_)
.arg(lease->addr_.toText());
lease->addr_.toText(),
dhcid, 0, lease->valid_lft_));
- LOG_DEBUG(ddns_logger, DBG_DHCP6_DETAIL,
+ LOG_DEBUG(ddns6_logger, DBG_DHCP6_DETAIL,
DHCP6_DDNS_CREATE_REMOVE_NAME_CHANGE_REQUEST)
.arg(query->getLabel())
.arg(ncr->toText());
hint = hint_opt->getAddress();
}
- LOG_DEBUG(lease_logger, DBG_DHCP6_DETAIL, DHCP6_PROCESS_IA_NA_REQUEST)
+ LOG_DEBUG(lease6_logger, DBG_DHCP6_DETAIL, DHCP6_PROCESS_IA_NA_REQUEST)
.arg(query->getLabel())
.arg(ia->getIAID())
.arg(hint_opt ? hint.toText() : "(no hint)");
if (lease) {
// We have a lease! Let's wrap its content into IA_NA option
// with IAADDR suboption.
- LOG_DEBUG(lease_logger, DBG_DHCP6_DETAIL, fake_allocation ?
+ LOG_DEBUG(lease6_logger, DBG_DHCP6_DETAIL, fake_allocation ?
DHCP6_LEASE_ADVERT : DHCP6_LEASE_ALLOC)
.arg(query->getLabel())
.arg(lease->addr_.toText())
.arg(ia->getIAID());
- LOG_DEBUG(lease_logger, DBG_DHCP6_DETAIL_DATA, DHCP6_LEASE_DATA)
+ LOG_DEBUG(lease6_logger, DBG_DHCP6_DETAIL_DATA, DHCP6_LEASE_DATA)
.arg(query->getLabel())
.arg(ia->getIAID())
.arg(lease->toText());
// cause of that failure. The only thing left is to insert
// status code to pass the sad news to the client.
- LOG_DEBUG(lease_logger, DBG_DHCP6_DETAIL, fake_allocation ?
+ LOG_DEBUG(lease6_logger, DBG_DHCP6_DETAIL, fake_allocation ?
DHCP6_LEASE_ADVERT_FAIL : DHCP6_LEASE_ALLOC_FAIL)
.arg(query->getLabel())
.arg(ia->getIAID());
Lease6Ptr& new_lease, const std::string& hostname,
bool do_fwd, bool do_rev) {
if (old_lease && !new_lease->hasIdenticalFqdn(*old_lease)) {
- LOG_DEBUG(ddns_logger, DBG_DHCP6_DETAIL, DHCP6_DDNS_LEASE_ASSIGN_FQDN_CHANGE)
+ LOG_DEBUG(ddns6_logger, DBG_DHCP6_DETAIL, DHCP6_DDNS_LEASE_ASSIGN_FQDN_CHANGE)
.arg(query->getLabel())
.arg(old_lease->toText())
.arg(hostname)
hint = hint_opt->getAddress();
}
- LOG_DEBUG(lease_logger, DBG_DHCP6_DETAIL, DHCP6_PROCESS_IA_PD_REQUEST)
+ LOG_DEBUG(lease6_logger, DBG_DHCP6_DETAIL, DHCP6_PROCESS_IA_PD_REQUEST)
.arg(query->getLabel())
.arg(ia->getIAID())
.arg(hint_opt ? hint.toText() : "(no hint)");
// We have a lease! Let's wrap its content into IA_PD option
// with IAADDR suboption.
- LOG_DEBUG(lease_logger, DBG_DHCP6_DETAIL, fake_allocation ?
+ LOG_DEBUG(lease6_logger, DBG_DHCP6_DETAIL, fake_allocation ?
DHCP6_PD_LEASE_ADVERT : DHCP6_PD_LEASE_ALLOC)
.arg(query->getLabel())
.arg((*l)->addr_.toText())
// cause of that failure. The only thing left is to insert
// status code to pass the sad news to the client.
- LOG_DEBUG(lease_logger, DBG_DHCP6_DETAIL, fake_allocation ?
+ LOG_DEBUG(lease6_logger, DBG_DHCP6_DETAIL, fake_allocation ?
DHCP6_PD_LEASE_ADVERT_FAIL : DHCP6_PD_LEASE_ALLOC_FAIL)
.arg(query->getLabel())
.arg(ia->getIAID());
AllocEngine::ClientContext6& orig_ctx,
boost::shared_ptr<Option6IA> ia) {
- LOG_DEBUG(lease_logger, DBG_DHCP6_DETAIL, DHCP6_PROCESS_IA_NA_EXTEND)
+ LOG_DEBUG(lease6_logger, DBG_DHCP6_DETAIL, DHCP6_PROCESS_IA_NA_EXTEND)
.arg(query->getLabel())
.arg(ia->getIAID());
// delete any existing FQDN records for this lease.
if (((*l)->hostname_ != ctx.hostname_) || ((*l)->fqdn_fwd_ != do_fwd) ||
((*l)->fqdn_rev_ != do_rev)) {
- LOG_DEBUG(ddns_logger, DBG_DHCP6_DETAIL,
+ LOG_DEBUG(ddns6_logger, DBG_DHCP6_DETAIL,
DHCP6_DDNS_LEASE_RENEW_FQDN_CHANGE)
.arg(query->getLabel())
.arg((*l)->toText())
ia_rsp->addOption(createStatusCode(*query, *ia_rsp, STATUS_NoBinding,
"Sorry, no known leases for this duid/iaid/subnet."));
- LOG_DEBUG(lease_logger, DBG_DHCP6_DETAIL, DHCP6_EXTEND_NA_UNKNOWN)
+ LOG_DEBUG(lease6_logger, DBG_DHCP6_DETAIL, DHCP6_EXTEND_NA_UNKNOWN)
.arg(query->getLabel())
.arg(ia->getIAID())
.arg(subnet->toText());
AllocEngine::ClientContext6& orig_ctx,
boost::shared_ptr<Option6IA> ia) {
- LOG_DEBUG(lease_logger, DBG_DHCP6_DETAIL, DHCP6_PROCESS_IA_PD_EXTEND)
+ LOG_DEBUG(lease6_logger, DBG_DHCP6_DETAIL, DHCP6_PROCESS_IA_PD_EXTEND)
.arg(query->getLabel())
.arg(ia->getIAID());
Dhcpv6Srv::releaseIA_NA(const DuidPtr& duid, const Pkt6Ptr& query,
int& general_status, boost::shared_ptr<Option6IA> ia) {
- LOG_DEBUG(lease_logger, DBG_DHCP6_DETAIL, DHCP6_PROCESS_IA_NA_RELEASE)
+ LOG_DEBUG(lease6_logger, DBG_DHCP6_DETAIL, DHCP6_PROCESS_IA_NA_RELEASE)
.arg(query->getLabel())
.arg(ia->getIAID());
// have mandatory DUID information attached. Someone was messing with our
// database.
- LOG_ERROR(lease_logger, DHCP6_LEASE_NA_WITHOUT_DUID)
+ LOG_ERROR(lease6_logger, DHCP6_LEASE_NA_WITHOUT_DUID)
.arg(query->getLabel())
.arg(release_addr->getAddress().toText());
if (*duid != *(lease->duid_)) {
// Sorry, it's not your address. You can't release it.
- LOG_INFO(lease_logger, DHCP6_RELEASE_NA_FAIL_WRONG_DUID)
+ LOG_INFO(lease6_logger, DHCP6_RELEASE_NA_FAIL_WRONG_DUID)
.arg(query->getLabel())
.arg(release_addr->getAddress().toText())
.arg(lease->duid_->toText());
if (ia->getIAID() != lease->iaid_) {
// This address belongs to this client, but to a different IA
- LOG_WARN(lease_logger, DHCP6_RELEASE_NA_FAIL_WRONG_IAID)
+ LOG_WARN(lease6_logger, DHCP6_RELEASE_NA_FAIL_WRONG_IAID)
.arg(query->getLabel())
.arg(release_addr->getAddress().toText())
.arg(lease->iaid_)
ia_rsp->addOption(createStatusCode(*query, *ia_rsp, STATUS_UnspecFail,
"Server failed to release a lease"));
- LOG_ERROR(lease_logger, DHCP6_RELEASE_NA_FAIL)
+ LOG_ERROR(lease6_logger, DHCP6_RELEASE_NA_FAIL)
.arg(query->getLabel())
.arg(lease->addr_.toText())
.arg(lease->iaid_);
return (ia_rsp);
} else {
- LOG_DEBUG(lease_logger, DBG_DHCP6_DETAIL, DHCP6_RELEASE_NA)
+ LOG_DEBUG(lease6_logger, DBG_DHCP6_DETAIL, DHCP6_RELEASE_NA)
.arg(query->getLabel())
.arg(lease->addr_.toText())
.arg(lease->iaid_);
// Something is gravely wrong here. We do have a lease, but it does not
// have mandatory DUID information attached. Someone was messing with our
// database.
- LOG_ERROR(lease_logger, DHCP6_LEASE_PD_WITHOUT_DUID)
+ LOG_ERROR(lease6_logger, DHCP6_LEASE_PD_WITHOUT_DUID)
.arg(query->getLabel())
.arg(release_prefix->getAddress().toText())
.arg(static_cast<int>(release_prefix->getLength()));
if (*duid != *(lease->duid_)) {
// Sorry, it's not your address. You can't release it.
- LOG_INFO(lease_logger, DHCP6_RELEASE_PD_FAIL_WRONG_DUID)
+ LOG_INFO(lease6_logger, DHCP6_RELEASE_PD_FAIL_WRONG_DUID)
.arg(query->getLabel())
.arg(release_prefix->getAddress().toText())
.arg(static_cast<int>(release_prefix->getLength()))
if (ia->getIAID() != lease->iaid_) {
// This address belongs to this client, but to a different IA
- LOG_WARN(lease_logger, DHCP6_RELEASE_PD_FAIL_WRONG_IAID)
+ LOG_WARN(lease6_logger, DHCP6_RELEASE_PD_FAIL_WRONG_IAID)
.arg(query->getLabel())
.arg(release_prefix->getAddress().toText())
.arg(static_cast<int>(release_prefix->getLength()))
ia_rsp->addOption(createStatusCode(*query, *ia_rsp, STATUS_UnspecFail,
"Server failed to release a lease"));
- LOG_ERROR(lease_logger, DHCP6_RELEASE_PD_FAIL)
+ LOG_ERROR(lease6_logger, DHCP6_RELEASE_PD_FAIL)
.arg(query->getLabel())
.arg(lease->addr_.toText())
.arg(static_cast<int>(lease->prefixlen_))
general_status = STATUS_UnspecFail;
} else {
- LOG_DEBUG(lease_logger, DBG_DHCP6_DETAIL, DHCP6_RELEASE_PD)
+ LOG_DEBUG(lease6_logger, DBG_DHCP6_DETAIL, DHCP6_RELEASE_PD)
.arg(query->getLabel())
.arg(lease->addr_.toText())
.arg(static_cast<int>(lease->prefixlen_))
OptionPtr opt_rapid_commit = solicit->getOption(D6O_RAPID_COMMIT);
if (opt_rapid_commit) {
- /// @todo uncomment when #3807 is merged!
-/* LOG_DEBUG(options_logger, DBG_DHCP6_DETAIL, DHCP6_RAPID_COMMIT)
- .arg(solicit->getLabel()); */
+ LOG_DEBUG(options6_logger, DBG_DHCP6_DETAIL, DHCP6_RAPID_COMMIT)
+ .arg(solicit->getLabel());
// If Rapid Commit has been sent by the client, change the
// response type to Reply and include Rapid Commit option.
std::string generated_name =
CfgMgr::instance().getD2ClientMgr().generateFqdn(addr);
- LOG_DEBUG(ddns_logger, DBG_DHCP6_DETAIL_DATA, DHCP6_DDNS_FQDN_GENERATED)
+ LOG_DEBUG(ddns6_logger, DBG_DHCP6_DETAIL_DATA, DHCP6_DDNS_FQDN_GENERATED)
.arg(answer->getLabel())
.arg(generated_name);
fqdn->setDomainName(generated_name, Option6ClientFqdn::FULL);
} catch (const Exception& ex) {
- LOG_ERROR(ddns_logger, DHCP6_DDNS_GENERATED_FQDN_UPDATE_FAIL)
+ LOG_ERROR(ddns6_logger, DHCP6_DDNS_GENERATED_FQDN_UPDATE_FAIL)
.arg(answer->getLabel())
.arg(addr.toText())
.arg(ex.what());
Dhcpv6Srv::d2ClientErrorHandler(const
dhcp_ddns::NameChangeSender::Result result,
dhcp_ddns::NameChangeRequestPtr& ncr) {
- LOG_ERROR(ddns_logger, DHCP6_DDNS_REQUEST_SEND_FAILED).
+ LOG_ERROR(ddns6_logger, DHCP6_DDNS_REQUEST_SEND_FAILED).
arg(result).arg((ncr ? ncr->toText() : " NULL "));
// We cannot communicate with kea-dhcp-ddns, suspend further updates.
/// @todo We may wish to revisit this, but for now we will simply turn
projects / thirdparty / kea.git / commitdiff
