mn_api.c

Go to the documentation of this file.

/* $Id: mn_api.c,v 1.46 2001/09/29 16:06:39 jm Exp $
 * Mobile Node - API handling
 *
 * Dynamic hierarchial IP tunnel
 * Copyright (C) 1998-2001, Dynamics group
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation. See README and COPYING for
 * more details.
 */

#include "config.h"
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <time.h>

#include "agentapi.h"
#include "debug.h"
#include "dyn_ip.h"
#include "list.h"
#include "util.h"
#ifdef WITH_WIRELESS
#include "monitor.h"
#endif
#include "mn.h"

extern struct mn_data mn;
extern struct mn_config config; /* configuration information */
extern struct timeval timers[TIMER_COUNT];

/* Policies can be changed on/off from dynmn_tool (policy) */
static struct policy_vars monitor_policy[] = {
        {EARLY_EXPIRE_STR,    EARLY_EXPIRE_BIT},
        {NEWEST_FA_STR,       NEWEST_FA_BIT},
        {EAGER_SWITCH_STR,    EAGER_SWITCH_BIT},
        {NEWEST_ADV_STR,      NEWEST_ADV_BIT},
        {"", -1}
};

static dyn_api_sockaddr api_addr; /* address of progressing api call */
static socklen_t api_addr_len = 0;

/* String representations of the states */
char *state_strings[MN_STATE_COUNT] = {
        "Startup", "Disconnected", "Find Agent", "Passive Find",
        "Request Tunnel", "Connected",
        "Close For Home", "At Home", "Error", "Stop" };


/* Fill static status structure and return a pointer to it. */
static struct dynamics_mobile_status *
get_mobile_status(void)
{
        static struct dynamics_mobile_status status;

        status.state = mn.state;

        if (mn.state >= 0 && mn.state < MN_STATE_COUNT)
                dynamics_strlcpy(status.state_str, state_strings[mn.state],
                                 API_STATE_LEN);
        else
                memset(status.state_str, 0, sizeof(status.state_str));
        status.local_addr = mn.local_addr;
        status.co_addr = mn.co_addr;
        status.fa_addr = mn.fa_addr;
        status.ha_addr = config.ha_ip_addr;
        status.home_addr = config.mn_home_ip_addr;
        status.tunnel_up = mn.tunnel_up;
        status.tunnel_mode = mn.tunnel_mode;
        if (mn.tunnel_up) {
                status.lifetime = timers[TIMER_LIFETIME].tv_sec - time(NULL);
        } else {
                status.lifetime = 0;
        }
        status.last_reply_code = mn.last_reply_code;
        status.last_reply_rcvd = mn.last_reply_rcvd;
        status.last_request_sent = mn.last_request_sent;
        if (mn.info_str == NULL)
                memset(status.info_str, 0, API_INFO_LEN + 1);
        else
                dynamics_strlcpy(status.info_str, mn.info_str,
                                 API_INFO_LEN + 1);
        if (mn.warn_str == NULL)
                memset(status.warn_str, 0, API_INFO_LEN + 1);
        else
                dynamics_strlcpy(status.warn_str, mn.warn_str,
                                 API_INFO_LEN + 1);
        status.device_count = mn.device_count;
        status.discarded_msgs = mn.discarded_msgs;

        return &status;
}


/*
 * Handling function for API update location call. API message is in msg.
 * Set own local address according to msg. If in disconnected state, stay
 * there, but otherwise go to find_agent state, because we have
 * moved under another FA and we will want hear its address.
 * Tunnels must be updated for new address.
 */
static void handle_api_locupd(int s, dyn_api_sockaddr *addr, socklen_t addrlen,
                              struct api_msg *msg, int block_api)
{
        int ok, i;
        char device[IFNAMSIZ + 1];
        struct in_addr iaddr;

        /* locupd should have new IP address or interface name after four
         * zero octets */

        ok = 1;
        if (msg->length == 4) {
                if (mn.local_addr.s_addr != (__u32) *msg->params) {
                        /* set local address */
                        memcpy(&mn.local_addr, msg->params, 4);
                        DEBUG(DEBUG_INFO, "Address changed to %s\n",
                              inet_ntoa(mn.local_addr));
                }
        } else if (msg->length > 4 && msg->params[0] == 0 &&
                msg->params[1] == 0 && msg->params[2] == 0 &&
                msg->params[3] == 0) {
                if (msg->length > IFNAMSIZ)
                        ok = 0;
                else {
                        memcpy(device, msg->params + 4, msg->length - 4);
                        device[msg->length - 4] = '\0';
                        ok = 2;
                }
        } else if (msg->length == 0) {
                /* try to use the first available interface */
                for (i = 0; i < MAX_INTERFACES; i++) {
                        if (mn.iface[i].s > -1) {
                                memcpy(device, mn.iface[i].device, IFNAMSIZ);
                                device[sizeof(device) - 1] = '\0';
                                ok = 2;
                                break;
                        }
                }
                if (ok != 2) ok = 0;
        } else ok = 0;

        if (ok == 2) {
                DEBUG(DEBUG_INFO, "\tinterface[%s]\n", device);
                if (dyn_ip_get_ifaddr(device, &iaddr) < 0)
                        ok = 0;
                else if (mn.local_addr.s_addr != iaddr.s_addr) {
                        DEBUG(DEBUG_INFO,
                              "Address changed to %s (%s)\n",
                              inet_ntoa(iaddr), device);
                        mn.local_addr.s_addr = iaddr.s_addr;
                }
        }

        if (!ok) {
                DEBUG(DEBUG_INFO, "API: locupd failed - illegal parameter\n");
                api_send_reply(s, addr, addrlen, API_ILLEGAL_PARAMETERS, NULL,
                               0);
                return;
        }

        /* check if we are at home */
        if (mn.local_addr.s_addr == config.mn_home_ip_addr.s_addr &&
            !config.enable_fa_decapsulation) {
                close_for_home(STATE_INIT);
        } else {
                switch (mn.state) {
                case MN_DISCONNECTED:
                        break;
                default:
                        /* allow quick locupd */
                        timerclear(&mn.last_reg_send_time);
                        find_agent(STATE_INIT);
                        break;
                }
        }

        if (!block_api)
                api_send_reply(s, addr, addrlen, API_SUCCESS, NULL, 0);
}


static void handle_api_force_fa(int s, dyn_api_sockaddr *addr,
                                socklen_t addrlen,
                                struct api_msg *msg)
{
        /* force_fa should have new address */
        if (msg->length != 4) {
                api_send_reply(s, addr, addrlen, API_ILLEGAL_PARAMETERS, NULL,
                               0);
                return;
        }

        /* set local address */
        memcpy(&mn.force_fa_addr, msg->params, 4);
        DEBUG(DEBUG_INFO, "Force FA address set to %s\n",
              inet_ntoa(mn.force_fa_addr));

        api_send_reply(s, addr, addrlen, API_SUCCESS, NULL, 0);
}


static int adv_iter(struct node *node, void *data)
{
        struct agentadv_data *adv;
        struct api_msg *api_msg;
        struct dynamics_mobile_fa_list *list;
        int size, tmp;
        unsigned int flags;

        adv = (struct agentadv_data *) node;
        api_msg = (struct api_msg *) data;

        list = (struct dynamics_mobile_fa_list *)
                ((char *) api_msg->params + api_msg->length);

        size = sizeof(struct dynamics_mobile_fa_list);
        if ((api_msg->length + size) > API_DATA_SIZE) {
                DEBUG(DEBUG_INFO, "adv_iter: Not enough room in msg "
                      " (itemsize %d, length %d)\n",
                      size, api_msg->length);
                return 0;
        }
        api_msg->length += size;

        /* copy values */
        UNALIGNED_(&list->addr, &adv->addr);
        MOVE_UNALIGNED(list->interface, adv->ifname, IFNAMSIZ);
        UNALIGNED_(&list->in_use, &adv->in_use);

        if (mn.current_adv != NULL && 
            adv->addr.s_addr == mn.current_adv->addr.s_addr) {
                tmp = 1;
        } else {
                tmp = 0;
        }
        UNALIGNED_(&list->current_adv, &tmp);
        flags = 0;
        if (adv->adv.ext) {
                int opts = ntohs(adv->adv.ext->opts);
                if (opts & AGENT_ADV_FOREIGN_AGENT)
                        flags |= API_MA_FLAGS_FA;
                if (opts & AGENT_ADV_HOME_AGENT)
                        flags |= API_MA_FLAGS_HA;
                if (opts & AGENT_ADV_BUSY)
                        flags |= API_MA_FLAGS_BUSY;
        }
        if (adv->adv.own_ext)
                flags |= API_MA_FLAGS_DYNAMICS;
        UNALIGNED_(&list->flags, &flags);

#ifdef WITH_WIRELESS
        if (adv->mon != NULL) {
                tmp = adv->mon->avg;
        } else {
                tmp = -1;
        }
#else
        tmp = -1;
#endif
        UNALIGNED_(&list->quality_avg, &tmp);
        
        /* Priorities aren't calculated if MN is in DISCONNECTED
           state. That is why we don't want to update priority because
           it's not up to date information and may confuse the
           user. */
        if (mn.state == MN_DISCONNECTED) {
                tmp = -2;  /* not up to date information */
                UNALIGNED_(&list->priority, &tmp); 
        } else 
                UNALIGNED_(&list->priority, &adv->priority);
        UNALIGNED_(&list->last, &adv->last.tv_sec);
        UNALIGNED_(&list->reduce, &adv->prio_degrade_percent);
        
        return 1;
}


static void handle_api_get_fa_list(int s, dyn_api_sockaddr *addr,
                                   socklen_t addrlen,
                                   struct api_msg *msg)
{
        msg->length = 0;
        hashtable_iterator(mn.agentadv, adv_iter, msg);
        api_send_reply(s, addr, addrlen, API_SUCCESS,
                       (unsigned char *) &msg->params, msg->length);
}


static void handle_api_get_fa_info(int s, dyn_api_sockaddr *addr,
                                   socklen_t addrlen,
                                   struct api_msg *msg)
{
        struct dynamics_mobile_fa_info *info;
        struct agentadv_data *adv;
        struct in_addr fa_addr;
        int ifindex, tmp;
        char interface[IFNAMSIZ + 1];
        char nai[API_MAX_NAI_LEN + 1];

        /* should have fa address */
        if (msg->length != sizeof(struct dynamics_mobile_fa_info)) {
                api_send_reply(s, addr, addrlen, API_ILLEGAL_PARAMETERS, NULL,
                               0);
                return;
        }
        info = (struct dynamics_mobile_fa_info *)&msg->params;
        MOVE_UNALIGNED(&fa_addr, &info->list.addr, sizeof(struct in_addr));
        DEBUG(DEBUG_API, "handle_api_get_fa_info: %s\n",
              inet_ntoa(fa_addr));
        
        ifindex = 0;
        MOVE_UNALIGNED(interface, &info->list.interface, IFNAMSIZ);
        interface[IFNAMSIZ] = '\0';
        if (strlen(interface) > 0) {
                ifindex = dyn_ip_get_ifindex(interface);
                DEBUG(DEBUG_API, "handle_api_get_fa_info: interface \"%s\""
                      " ifindex %d\n", interface, ifindex);
        }
        adv = adv_fetch(mn.agentadv, &fa_addr, ifindex);
        if (adv == NULL) {
                DEBUG(DEBUG_API, "handle_api_get_fa_info: %s not found\n",
                      inet_ntoa(fa_addr));
                api_send_reply(s, addr, addrlen, API_FAILED, NULL, 0);
                return;
        }

        msg->length = sizeof(struct dynamics_mobile_fa_info);
        UNALIGNED_(&info->list.addr, &adv->addr);
        UNALIGNED_(&info->list.in_use, &adv->in_use);
        UNALIGNED_(&info->ifindex, &ifindex);
#ifdef WITH_WIRELESS
        if (adv->mon != NULL)
                UNALIGNED_(&info->list.quality_avg, &adv->mon->avg);
        else {
                tmp = -1;
                UNALIGNED_(&info->list.quality_avg, &tmp);
        }
#else
        tmp = -1;
        UNALIGNED_(&info->list.quality_avg, &tmp);
#endif
        UNALIGNED_(&tmp, &info->list.quality_avg);
        DEBUG(DEBUG_INFO, "quality: %d\n", tmp);
        UNALIGNED_(&info->list.priority, &adv->priority);
        UNALIGNED_(&info->ifindex, &adv->ifindex);
        MOVE_UNALIGNED(info->list.interface, adv->ifname, sizeof(adv->ifname));
        UNALIGNED_(&info->list.last, &adv->last.tv_sec);
        UNALIGNED_(&info->expire, &adv->expire.tv_sec);
        UNALIGNED_(&info->arpentry, &adv->arpentry);
        nai[0] = '\0';
        if (adv->adv.fa_nai != NULL &&
            API_MAX_NAI_LEN >= GET_NAI_LEN(adv->adv.fa_nai)) {
                memcpy(nai, MSG_NAI_DATA(adv->adv.fa_nai), API_MAX_NAI_LEN);
                nai[GET_NAI_LEN(adv->adv.fa_nai)] = '\0';
        }
        DEBUG(DEBUG_INFO, "\tNAI[%s]\n", nai);
        MOVE_UNALIGNED(&info->nai, &nai, API_MAX_NAI_LEN + 1);

        api_send_reply(s, addr, addrlen, API_SUCCESS,
                       (unsigned char *) &msg->params, msg->length);
}


#ifdef WITH_WIRELESS
static void handle_api_get_iw_ch(int s, dyn_api_sockaddr *addr,
                                 socklen_t addrlen,
                                 struct api_msg *msg)
{
        int r;
        struct dynamics_mn_iw_ch_info *info;

        msg->length = 0;
        r = monitor_api_get_ch((unsigned char *)msg->params, &msg->length);

        info = (struct dynamics_mn_iw_ch_info *)msg->params;
        DEBUG(DEBUG_API, "handle_api_get_iw_ch: %s: %d "
              "(msg->length: %d(%d) num: %d)\n",
              info->ifname, info->channel,
              msg->length, sizeof(struct dynamics_mn_iw_ch_info),
              msg->length/sizeof(struct dynamics_mn_iw_ch_info));

        if (r)
                api_send_reply(s, addr, addrlen, API_FAILED, NULL, 0);
        else
                api_send_reply(s, addr, addrlen, API_SUCCESS,
                               (unsigned char *) msg->params, msg->length);
}


static void handle_api_set_iw_ch(int s, dyn_api_sockaddr *addr,
                                 socklen_t addrlen,
                                 struct api_msg *msg)
{
        struct dynamics_mn_iw_ch_info info;

        memcpy((char *)&info, (char *)msg->params,
               sizeof(struct dynamics_mn_iw_ch_info));

        if (monitor_api_set_ch(info.ifname, info.channel))
                api_send_reply(s, addr, addrlen, API_FAILED, NULL, 0);
        else
                api_send_reply(s, addr, addrlen, API_SUCCESS, NULL, 0);
}
#endif /* WITH_WIRELESS */

static void handle_api_rescan(int s, dyn_api_sockaddr *addr,
                              socklen_t addrlen,
                              struct api_msg *msg)
{
        int r = check_interfaces(mn.iface, MAX_INTERFACES);
        api_send_reply(s, addr, addrlen, r ? API_FAILED : API_SUCCESS, NULL,
                       0);
}

static void handle_register_dev_info_socket(int s, dyn_api_sockaddr *addr,
                                            socklen_t addrlen,
                                            struct api_msg *msg)
{
        char *path = (char *) msg->params;

        DEBUG(DEBUG_API, "API register device info socket[%s]\n", path);
        if (msg->length < 2) {
                DEBUG(DEBUG_API, "\ttoo short message\n");
                api_send_reply(s, addr, addrlen, API_FAILED, NULL, 0);
                return;
        }
        path[msg->length - 1] = '\0';
        memset(&mn.dev_info_addr, 0, sizeof(mn.dev_info_addr));
        mn.dev_info_addr.sun_family = AF_LOCAL;
        dynamics_strlcpy(mn.dev_info_addr.sun_path, path, msg->length);
        api_send_reply(s, addr, addrlen, API_SUCCESS, NULL, 0);
}


static int monitor_api_set_policy(char *name, int on)
{
        struct policy_vars *t = monitor_policy;
        int i = 0, len;

        if (name == NULL || (on != 0 && on != 1))
                return 1;

        DEBUG(DEBUG_API, "monitor_set_policy: '%s' %s \n", 
              name, on == 0 ? "off" : "on");

        len = strlen(t[i].name);
        len = strlen(name) < len ? strlen(name) : len;
        while (t[i].bit != -1 && 
               strncasecmp(t[i].name, name, len) != 0)
                i++;
        
        if (t[i].bit == -1) {
                DEBUG(DEBUG_API, "monitor_set_policy: No policy matched!\n");
                return 1;
        }

        if (on)
                POLICY_SET(t[i].bit);
        else
                POLICY_CLR(t[i].bit);

        return 0;
}


static int monitor_api_get_policy(char *buffer, int len)
{
        int curr = 0, r, i;
        struct policy_vars *t = monitor_policy;

        for (i = 0, r = 0; t[i].bit != -1 && r == 0; i++)
                r = copy_str(buffer, len, &curr, t[i].name, 
                             POLICY(t[i].bit) ? "ON " : "OFF");
        if (r) {
                DEBUG(DEBUG_API, "monitor_api_get_policy: insufficient "
                      "space\n");
                return API_INSUFFICIENT_SPACE;
        }

        DEBUG(DEBUG_API, buffer);
        return API_SUCCESS;
}


static void handle_policy(int s, dyn_api_sockaddr *addr,
                          socklen_t addrlen,
                          struct api_msg *msg, int on)
{
        int r = monitor_api_set_policy((char *)msg->params, on);
        api_send_reply(s, addr, addrlen, r, msg->params, msg->length);
}

static void handle_get_policy(int s, dyn_api_sockaddr *addr,
                              socklen_t addrlen,
                              struct api_msg *msg)
{
        int r = monitor_api_get_policy((char *)msg->params, msg->length);
        api_send_reply(s, addr, addrlen, r, msg->params, msg->length);
}

#ifdef WITH_WIRELESS

static void handle_mon_conf(int s, dyn_api_sockaddr *addr,
                            socklen_t addrlen,
                            struct api_msg *msg, int type)
{
        int r = monitor_api_mon_conf((char *)msg->params, msg->length, type);
        api_send_reply(s, addr, addrlen, r, msg->params, msg->length);
}

#endif /* WITH_WIRELESS */


/* Handle API call from socket sock. If it is privileged, the admin
 * is nonzero. */
void handle_api(int sock, int admin)
{
        dyn_api_sockaddr addr;
        unsigned int addrlen;
        struct api_msg msg;
#ifdef MN_LOCUPD_PROFILER
        char *name;
        char tmp[30];
        struct in_addr faaddr;
#endif

        DEBUG(DEBUG_API, "receive from api\n");
        addrlen = sizeof(addr);
        memset(&addr, 0, addrlen);
        if (api_receive(sock, &addr, &addrlen, &msg) < 0) {
                LOG2(LOG_ERR, "api receive: %s\n", strerror(errno));
                return;
        }
        if (msg.type != API_CALL_MSG) return;
#ifdef MN_LOCUPD_PROFILER
        switch (msg.code) {
        case API_FORCE_FA:
                memcpy(&faaddr, msg.params, 4);
                snprintf(tmp, sizeof(tmp), "FORCE %s", inet_ntoa(faaddr));
                name = tmp;
                break;
        case API_UPDATE_LOCATION: name = "UPDATE"; break;
        case API_UPDATE_LOCATION_BLOCK: name = "UPDATEB"; break;
        case API_DISCONNECT: name = "DISCONNECT"; break;
        case API_CONNECT: name = "CONNECT"; break;
        default:
                snprintf(tmp, sizeof(tmp), "%i", msg.code);
                name = tmp;
                break;
        }
        gettimeofday(&mn.last_api, NULL);
        fprintf(mn.profile, "API %s %u.%06u\n", name,
                (unsigned int) mn.last_api.tv_sec,
                (unsigned int) mn.last_api.tv_usec);
#endif
        switch (msg.code) {
        case API_CONNECT:
                DEBUG(DEBUG_API, "api connect\n");
                if (!admin) break;
                mn.ha_error_count = 0;
                if (mn.state == MN_DISCONNECTED) {
                        /* allow quick locupd */
                        timerclear(&mn.last_reg_send_time);
                        check_interfaces(mn.iface, MAX_INTERFACES);
                        memcpy(&mn.tunnel_mode, msg.params,
                               sizeof(mn.tunnel_mode));
                        DEBUG(DEBUG_API, "tunnel_mode=%i\n", mn.tunnel_mode);
                        if (mn.tunnel_mode == API_TUNNEL_FULL_HA &&
                            mn.local_addr.s_addr ==
                            config.mn_home_ip_addr.s_addr) {
                                struct in_addr iaddr;
                                char device[IFNAMSIZ + 1];
                                if (dyn_ip_route_get(config.ha_ip_addr, device,
                                                     IFNAMSIZ) == 0 &&
                                    dyn_ip_get_ifaddr(device, &iaddr) == 0 &&
                                    mn.local_addr.s_addr != iaddr.s_addr) {
                                        DEBUG(DEBUG_INFO,
                                              "Address changed to %s\n",
                                              inet_ntoa(iaddr));
                                        mn.local_addr.s_addr = iaddr.s_addr;
                                }
                        }
                        find_agent(STATE_INIT);
                        memcpy(&api_addr, &addr, sizeof(addr));
                        api_addr_len = addrlen;
                        /* this API call is replied with reply_waiting_api
                         * after the status of the connection attempt is known
                         */
                } else {
                        api_send_reply(sock, &addr, addrlen, API_NOT_PERMITTED,
                                       NULL, 0);
                }
                break;
        case API_UPDATE_LOCATION:
                DEBUG(DEBUG_API, "api update location\n");
                if (!admin) break;
                check_interfaces(mn.iface, MAX_INTERFACES);
                handle_api_locupd(sock, &addr, addrlen, &msg, 0);
                break;
        case API_UPDATE_LOCATION_BLOCK:
                DEBUG(DEBUG_API, "api update location (block)\n");
                if (!admin) break;
                check_interfaces(mn.iface, MAX_INTERFACES);
                handle_api_locupd(sock, &addr, addrlen, &msg, 1);
                memcpy(&api_addr, &addr, sizeof(addr));
                api_addr_len = addrlen;
                /* this API call is replied with reply_waiting_api
                 * after the status of the connection attempt is known */
                break;
        case API_CANCEL:
                DEBUG(DEBUG_API, "Cancel received.\n");
                if (!admin) break;

                api_send_reply(sock, &addr, addrlen, API_SUCCESS, NULL, 0);
                break;
        case API_DISCONNECT:
                DEBUG(DEBUG_API, "api disconnect\n");
                if (!admin) break;
                check_interfaces(mn.iface, MAX_INTERFACES);
                disconnect();
                api_send_reply(sock, &addr, addrlen, API_SUCCESS, NULL, 0);
                break;
        case API_GET_CAREOF_ADDR:
                api_send_reply(sock, &addr, addrlen, API_SUCCESS,
                               (unsigned char *) &mn.co_addr,
                               sizeof(mn.co_addr));
                break;
        case API_GET_TUNNELING_MODE:
                api_send_reply(sock, &addr, addrlen, API_SUCCESS,
                               (unsigned char *) &mn.tunnel_mode, sizeof(int));
                break;
        case API_GET_STATUS:
                api_send_reply(sock, &addr, addrlen, API_SUCCESS,
                               (unsigned char *) get_mobile_status(),
                               sizeof(struct dynamics_mobile_status));
                break;
        case API_CONFIRM:
                DEBUG(DEBUG_API, "api confirm\n");
                if (!admin) break;
                if (mn.state != MN_CONNECTED &&
                    mn.state != MN_REQUEST_TUNNEL)  {
                        api_send_reply(sock, &addr, addrlen,
                                       API_NOT_PERMITTED, NULL, 0);
                        break;

                }
                memcpy(&api_addr, &addr, sizeof(addr));
                api_addr_len = addrlen;
                request_tunnel(STATE_INIT, 1, 0);
                break;
        case API_FORCE_FA:
                DEBUG(DEBUG_API, "api force fa\n");
                if (!admin) break;
                handle_api_force_fa(sock, &addr, addrlen, &msg);
                break;
        case API_GET_FA_LIST:
                DEBUG(DEBUG_API, "api get fa list\n");
                handle_api_get_fa_list(sock, &addr, addrlen, &msg);
                break;
        case API_GET_FA_INFO:
                DEBUG(DEBUG_API, "api get fa info\n");
                handle_api_get_fa_info(sock, &addr, addrlen, &msg);
                break;
#ifdef WITH_WIRELESS
        case API_IW_GET_CH:
                DEBUG(DEBUG_API, "api get wireless channel info\n");
                handle_api_get_iw_ch(sock, &addr, addrlen, &msg);
                break;
        case API_IW_SET_CH:
                DEBUG(DEBUG_API, "api set wireless channel info\n");
                if (!admin) break;
                handle_api_set_iw_ch(sock, &addr, addrlen, &msg);
                break;
#endif
        case API_RESCAN:
                DEBUG(DEBUG_API, "api rescan interfaces\n");
                handle_api_rescan(sock, &addr, addrlen, &msg);
                break;
        case API_REGISTER_DEV_INFO_SOCKET:
                DEBUG(DEBUG_API, "api register dev info socket\n");
                if (!admin) break;
                handle_register_dev_info_socket(sock, &addr, addrlen, &msg);
                break;
        case API_POLICY_OFF:
                DEBUG(DEBUG_API, "api policy off\n");
                if (!admin) break;
                handle_policy(sock, &addr, addrlen, &msg, 0);
                break;
        case API_POLICY_ON:
                DEBUG(DEBUG_API, "api policy on\n");
                if (!admin) break;
                handle_policy(sock, &addr, addrlen, &msg, 1);
                break;
        case API_GET_POLICY:
                DEBUG(DEBUG_API, "api get policy\n");
                handle_get_policy(sock, &addr, addrlen, &msg);
                break;
#ifdef WITH_WIRELESS
        case API_GET_MON_CONF:
                DEBUG(DEBUG_API, "api get mon conf\n");
                handle_mon_conf(sock, &addr, addrlen, &msg, GET_MONCONF);
                break;
        case API_GET_MON_CONF_VAR:
                DEBUG(DEBUG_API, "api get mon conf var\n");
                handle_mon_conf(sock, &addr, addrlen, &msg, GET_MONCONF_VAR);
                break;
        case API_SET_MON_CONF_VAR:
                DEBUG(DEBUG_API, "api set mon conf\n");
                if (!admin) break;
                handle_mon_conf(sock, &addr, addrlen, &msg, SET_MONCONF_VAR);
                break;
#endif
        default:
                /* Just send a message indicating that the function is not
                 * supported. No need to confirm that message gets through. */
                DEBUG(DEBUG_API, "api call not supported\n");
                api_send_reply(sock, &addr, addrlen, API_NOT_SUPPORTED, NULL,
                               0);
                break;
        }
}


/*
 * Reply to possibly waiting API call.
 * Parameters:
 *  code - error code to return
 */
void reply_waiting_api(int code, unsigned char *data, int datalen)
{
#ifdef DYN_TARGET_LINUX
        if (api_addr_len > 0) {
#endif
#ifdef DYN_TARGET_WINDOWS
        if (api_addr.sin_port != 0) {
#endif
                DEBUG(DEBUG_API, "Replying to waiting API call\n");
                api_send_reply(mn.api_rw_socket, &api_addr, api_addr_len, code,
                               data, datalen);
                memset(&api_addr, 0, sizeof(api_addr));
                api_addr_len = 0;
        } else DEBUG(DEBUG_API, "reply_waiting_api: no waiting call\n");
}

---