kea/hooks/amqp/src/callouts.cc

#include <hooks/hooks.h>
#include <dhcp/pkt4.h>
#include <dhcp/hwaddr.h>
#include <dhcpsrv/subnet.h>
#include <dhcpsrv/lease.h>
#include <util/strutil.h>
#include <dhcp/option_string.h>
#include <dhcp/option4_addrlst.h>
#include <dhcp/docsis3_option_defs.h>
#include <string>
#include <dhcp/dhcp6.h>
#include <dhcp/pkt6.h>
#include <dhcp/option6_ia.h>

#include <boost/foreach.hpp>

#include "logger.h"
#include "common.h"

using namespace isc::dhcp;
using namespace isc::hooks;

extern "C" {

#include <numeric>    //inner_product
#include <functional> //plus, equal_to, not2
#include <string>   
#include <stdexcept>


#include "amqppublisher.h"

AMQPPublisher amqp;

/* IPv4 callouts */
int pkt4_receive(CalloutHandle& handle) 
{
    Pkt4Ptr query;
    handle.getArgument("query4", query);

    amqp.publish(query->toText());

    return 0;
}

int pkt4_send(CalloutHandle& handle) 
{
    Pkt4Ptr response;
    Pkt4Ptr query;
    handle.getArgument("response4", response);
    handle.getArgument("query4", query);

    amqp.publish(query->toText());
    amqp.publish(response->toText());

    return 0;
}

int subnet4_select(CalloutHandle& handle) {
    std::vector<std::string> env;
    Pkt4Ptr query;
    Subnet4Ptr subnet;
    handle.getArgument("query4", query);
    handle.getArgument("subnet4", subnet);
    
    amqp.publish(query->toText());
    amqp.publish("subnet4_select: " + subnet->toText());
    
    return 0;
}

int lease4_select(CalloutHandle& handle) {
    std::vector<std::string> env;
    Pkt4Ptr query;
    Subnet4Ptr subnet;
    bool fake_allocation;
    Lease4Ptr lease;
    handle.getArgument("query4", query);
    handle.getArgument("subnet4", subnet);
    handle.getArgument("fake_allocation", fake_allocation);
    handle.getArgument("lease4", lease);
    
    amqp.publish(query->toText());
    amqp.publish("lease4_select: " + subnet->toText());
    amqp.publish("lease4_select: " + lease->toText());
    
    return 0;
}

int lease4_renew(CalloutHandle& handle) {
    std::vector<std::string> env;
    Pkt4Ptr query;
    Subnet4Ptr subnet;
    Lease4Ptr lease;
    handle.getArgument("query4", query);
    handle.getArgument("subnet4", subnet);
    handle.getArgument("lease4", lease);
    
    amqp.publish(query->toText());
    amqp.publish("lease4_renew: " + subnet->toText());
    amqp.publish("lease4_renew: " + lease->toText());
    
    return 0;
}

int lease4_release(CalloutHandle& handle) {
    std::vector<std::string> env;
    Pkt4Ptr query;
    Lease4Ptr lease;
    handle.getArgument("query4", query);
    handle.getArgument("lease4", lease);
    
    amqp.publish(query->toText());
    amqp.publish("lease4_release: " + lease->toText());
    
    return 0;
}

int lease4_decline(CalloutHandle& handle) {
    std::vector<std::string> env;
    Pkt4Ptr query;
    Lease4Ptr lease;
    handle.getArgument("query4", query);
    handle.getArgument("lease4", lease);
    
    amqp.publish(query->toText());
    amqp.publish("lease4_decline: " + lease->toText());
    
    return 0;
}

int lease4_expire(CalloutHandle& handle) {
    std::vector<std::string> env;
    Lease4Ptr lease;
    bool remove_lease;
    handle.getArgument("lease4", lease);
    handle.getArgument("remove_lease", remove_lease);
    
    amqp.publish("lease4_expire: " + lease->toText());
    
    return 0;
}

int lease4_recover(CalloutHandle& handle) {
    std::vector<std::string> env;
    Lease4Ptr lease;
    handle.getArgument("lease4", lease);
    
    amqp.publish("lease4_recover: " + lease->toText());
    
    return 0;
}

/* IPv6 callouts */
int pkt6_receive(CalloutHandle& handle) {
    std::vector<std::string> env;
    Pkt6Ptr query;
    handle.getArgument("query6", query);
    
    amqp.publish(query->toText());
    
    return 0;
}

int pkt6_send(CalloutHandle& handle) {
    std::vector<std::string> env;
    Pkt6Ptr query, response;
    handle.getArgument("query6", query);
    handle.getArgument("response6", response);
    
    amqp.publish(query->toText());
    amqp.publish(response->toText());
    
    return 0;
}

int subnet6_select(CalloutHandle& handle) {
    std::vector<std::string> env;
    Pkt6Ptr query;
    Subnet6Ptr subnet;
    handle.getArgument("query6", query);
    handle.getArgument("subnet6", subnet);
    
    amqp.publish(query->toText());
    amqp.publish("subnet6_select: " + subnet->toText());
    
    return 0;
}

int lease6_select(CalloutHandle& handle) {
    std::vector<std::string> env;
    Pkt6Ptr query;
    Subnet6Ptr subnet;
    bool fake_allocation;
    Lease6Ptr lease;
    handle.getArgument("query6", query);
    handle.getArgument("subnet6", subnet);
    handle.getArgument("fake_allocation", fake_allocation);
    handle.getArgument("lease6", lease);
    
    amqp.publish(query->toText());
    amqp.publish("lease6_select: " + subnet->toText());
    amqp.publish("lease6_select: " + lease->toText());
    
    return 0;
}

int lease6_renew(CalloutHandle& handle) {
    std::vector<std::string> env;
    Pkt6Ptr query;
    Lease6Ptr lease;
    boost::shared_ptr<Option6IA> ia_na;
    boost::shared_ptr<Option6IA> ia_pd;
    handle.getArgument("query6", query);
    handle.getArgument("lease6", lease);
    
    amqp.publish(query->toText());
    amqp.publish("lease6_renew: " + lease->toText());
    
    try {
        handle.getArgument("ia_na", ia_na);
        amqp.publish("lease6_renew: " + ia_na->toText());
    } catch (const NoSuchArgument&) { }
    
    try {
        handle.getArgument("ia_pd", ia_pd);
        amqp.publish("lease6_renew: " + ia_pd->toText());
    } catch (const NoSuchArgument&) { }
    
    return 0;
}

int lease6_rebind(CalloutHandle& handle) {
    std::vector<std::string> env;
    Pkt6Ptr query;
    Lease6Ptr lease;
    boost::shared_ptr<Option6IA> ia_na;
    boost::shared_ptr<Option6IA> ia_pd;
    handle.getArgument("query6", query);
    handle.getArgument("lease6", lease);
    
    amqp.publish(query->toText());
    amqp.publish("lease6_rebind: " + lease->toText());
    
    try {
        handle.getArgument("ia_na", ia_na);
        amqp.publish("lease6_rebind: " + ia_na->toText());
    } catch (const NoSuchArgument&) { }
    
    try {
        handle.getArgument("ia_pd", ia_pd);
        amqp.publish("lease6_rebind: " + ia_pd->toText());
    } catch (const NoSuchArgument&) { }
    
    return 0;
}

int lease6_decline(CalloutHandle& handle) {
    std::vector<std::string> env;
    Pkt6Ptr query;
    Lease6Ptr lease;
    handle.getArgument("query6", query);
    handle.getArgument("lease6", lease);
    
    amqp.publish(query->toText());
    amqp.publish("lease6_decline: " + lease->toText());
    
    return 0;
}

int lease6_release(CalloutHandle& handle) {
    std::vector<std::string> env;
    Pkt6Ptr query;
    Lease6Ptr lease;
    handle.getArgument("query6", query);
    handle.getArgument("lease6", lease);
    
    amqp.publish(query->toText());
    amqp.publish("lease6_release: " + lease->toText());
    
    return 0;
}

int lease6_expire(CalloutHandle& handle) {
    std::vector<std::string> env;
    Lease6Ptr lease;
    bool remove_lease;
    handle.getArgument("lease6", lease);
    handle.getArgument("remove_lease", remove_lease);
    
    amqp.publish("lease6_expire: " + lease->toText());
    
    return 0;
}

int lease6_recover(CalloutHandle& handle) {
    std::vector<std::string> env;
    Lease6Ptr lease;
    handle.getArgument("lease6", lease);
    
    amqp.publish("lease6_recover: " + lease->toText());
    
    return 0;
}


} // end extern "C"