mn_ipay.c

Go to the documentation of this file.

/* $Id: mn_ipay.c,v 1.7 2001/01/31 22:06:13 jm Exp $
 * Mobile Node - Ipay interface routines
 *
 * 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.
 */


#ifdef INCLUDE_IPAY

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <string.h>
#include <errno.h>
#include <ctype.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#include "mn.h"
#include "mn_handler.h"
#include "hashtable.h"
#include "debug.h"
#include "ipay-msg.h"
#include "mn_ipay.h"


extern struct mn_data mn;
extern struct mn_config config;

/* the last reported faIdentifier to Ipay buyer (with new FA message) */
static IPAY_CHAR prev_faIdentifier;

#define DEBUG_IPAY 'i'

static void show_ipay_char(char *title, char *p)
{
        int i;
        DEBUG(DEBUG_IPAY, "\t  %s: ", title);
        for (i = 0; i < IPAY_CHAR_LEN; i++) {
                if (p[i] == '\0')
                        break;
                if (isprint(p[i]))
                        DEBUG(DEBUG_IPAY, "%c", p[i]);
                else
                        DEBUG(DEBUG_IPAY, "<%u>", (unsigned int) p[i]);
        }
        DEBUG(DEBUG_IPAY, "\n");
}


static int ipay_check_len(int len, int expected)
{
        if (len != expected) {
                DEBUG(DEBUG_IPAY, "\t - length mismatch (expected %i bytes)\n",
                      expected);
                if (len < expected) {
                        DEBUG(DEBUG_IPAY, "\t - too short - cannot parse\n");
                        return -1;
                }
                DEBUG(DEBUG_IPAY, "\t - ignoring extra bytes\n");
        }
        return 0;
}


static int send_to_buyer(void *data, int len)
{
        struct sockaddr_in addr;
        int res;

        if (!mn.ipay_in_use)
                return 0;

        memset(&addr, 0, sizeof(addr));
        addr.sin_family = AF_INET;
        addr.sin_addr = config.ipay_buyer_addr;
        addr.sin_port = htons(config.ipay_buyer_port);

        DEBUG(DEBUG_IPAY, "\tsending %i bytes to %s:%i\n", len,
              inet_ntoa(addr.sin_addr), ntohs(addr.sin_port));

        res = sendto(mn.ipay_sock, data, len, 0, (struct sockaddr *) &addr,
                     sizeof(addr));
        if (res < 0) {
                DEBUG(DEBUG_IPAY, "\tsendto - %s\n", strerror(errno));
                return -1;
        } else if (res != len) {
                DEBUG(DEBUG_IPAY, "\tsend only %i/%i bytes\n", res, len);
                return -1;
        }
        return 0;
}


static int send_to_fa(void *data, int len)
{
        struct sockaddr_in addr;
        int res;

        if (!mn.ipay_in_use)
                return 0;

        memset(&addr, 0, sizeof(addr));
        addr.sin_family = AF_INET;
        addr.sin_addr = mn.fa_addr;
        addr.sin_port = htons(config.ipay_fa_port);

        DEBUG(DEBUG_IPAY, "\tsending %i bytes to %s:%i\n", len,
              inet_ntoa(addr.sin_addr), ntohs(addr.sin_port));

        res = sendto(mn.ipay_sock_fa, data, len, 0, (struct sockaddr *) &addr,
                     sizeof(addr));

        if (res < 0) {
                DEBUG(DEBUG_IPAY, "\tsendto - %s\n", strerror(errno));
                return -1;
        } else if (res != len) {
                DEBUG(DEBUG_IPAY, "\tsend only %i/%i bytes\n", res, len);
                return -1;
        }
        return 0;
}


static void handle_initialize(int s, char *msg, int len)
{
        struct ipay_initialize *ini;
        int l;

        DEBUG(DEBUG_IPAY, "\tinitialize message\n");
        if (ipay_check_len(len, sizeof(struct ipay_initialize)) < 0)
                return;

        ini = (struct ipay_initialize *) msg;

        show_ipay_char("mnIdentifier", ini->mnIdentifier);

        l = 0;
        while (l < IPAY_CHAR_LEN && ini->mnIdentifier[l] != '\0')
                l++;
        if (l == 0) {
                DEBUG(DEBUG_IPAY, "\tzero length NAI - ignoring\n");
                return;
        }
        if (mn.nai.nai != NULL)
                free(mn.nai.nai);
        mn.nai.nai = malloc(l);
        if (mn.nai.nai == NULL) {
                DEBUG(DEBUG_IPAY, "\tmalloc failed\n");
                mn.nai.len = 0;
                return;
        }
        mn.nai.len = l;
        memcpy(mn.nai.nai, ini->mnIdentifier, l);

        mn.ipay_in_use = 1;
        ipay_flush_priority_cache(0);
}


static int prio_avail = 0;
static __u32 last_prio = 0;

static void handle_policy_prio_reply(int s, char *msg, int len)
{
        struct ipay_policy_prio_reply *prio;

        DEBUG(DEBUG_IPAY, "\tpolicy prio reply message\n");
        if (ipay_check_len(len, sizeof(struct ipay_policy_prio_reply)) < 0)
                return;

        prio = (struct ipay_policy_prio_reply *) msg;
        DEBUG(DEBUG_IPAY, "\tpriority=%u\n", ntohl(prio->priority));

        prio_avail = 1;
        last_prio = ntohl(prio->priority);
}


static void handle_purchase(int s, char *msg, int len)
{
        struct ipay_purchase *pur;

        DEBUG(DEBUG_IPAY, "\tpurchase message\n");
        if (ipay_check_len(len, sizeof(struct ipay_purchase)) < 0)
                return;

        pur = (struct ipay_purchase *) msg;

        DEBUG(DEBUG_IPAY, "\t  timeStamp: %u\n", ntohl(pur->timeStamp));
        show_ipay_char("mnIdentifier", pur->mnIdentifier);
        show_ipay_char("faIdentifier", pur->faIdentifier);
        DEBUG(DEBUG_IPAY, "\t  purchaseSerialNumber: %u\n",
              ntohl(pur->purchaseSerialNumber));
        DEBUG(DEBUG_IPAY, "\t  microPaymentUnit: %u\n",
              ntohl(pur->microPaymentUnit));
        DEBUG(DEBUG_IPAY, "\t  maxNumberOfUnits: %u\n",
              ntohl(pur->maxNumberOfUnits));
        show_ipay_char("firstPayment", pur->firstPayment);
        DEBUG(DEBUG_IPAY, "\t  timePrice: %u\n", ntohl(pur->timePrice));
        DEBUG(DEBUG_IPAY, "\t  bytePrice: %u\n", ntohl(pur->bytePrice));
        show_ipay_char("signature", pur->signature);

        send_to_fa(pur, len);
}


static void handle_allowance(int s, char *msg, int len)
{
        struct ipay_allowance *allow;

        DEBUG(DEBUG_IPAY, "\tallowance message\n");
        if (ipay_check_len(len, sizeof(struct ipay_allowance)))
                return;

        allow = (struct ipay_allowance *) msg;

        DEBUG(DEBUG_IPAY, "\t  allowance: %u\n", ntohl(allow->allowance));
        show_ipay_char("mnIdentifier", allow->mnIdentifier);
        DEBUG(DEBUG_IPAY, "\t  timePrice: %u\n", ntohl(allow->timePrice));
        DEBUG(DEBUG_IPAY, "\t  bytePrice: %u\n", ntohl(allow->bytePrice));
        DEBUG(DEBUG_IPAY, "\t  apporovedNumberOfUnits: %u\n",
              ntohl(allow->approvedNumberOfUnits));
        show_ipay_char("sessionKey", allow->sessionKey);
        show_ipay_char("signature", allow->signature);

        send_to_buyer(msg, len);

        if (!ntohl(allow->allowance)) {
                DEBUG(DEBUG_IPAY, "\tconnection to FA not allowed => marking "
                      "FA unusable\n");
                if (mn.current_adv != NULL) {
                        mn.current_adv->priority = 0;
                        mn.current_adv->reg_failed = 1;
                }
                find_agent(STATE_INIT);
        }
}

static void handle_please_pay_more(int s, char *msg, int len)
{
        struct ipay_please_pay_more *pay;
        struct ipay_statistics stat;
        static time_t prev_stat = 0;
        time_t now;

        DEBUG(DEBUG_IPAY, "\tplease pay more message\n");
        if (ipay_check_len(len, sizeof(struct ipay_please_pay_more)))
                return;

        pay = (struct ipay_please_pay_more *) msg;

        show_ipay_char("mnIdentifier", pay->mnIdentifier);
        DEBUG(DEBUG_IPAY, "\t  usedTime: %u\n", ntohl(pay->usedTime));
        DEBUG(DEBUG_IPAY, "\t  usedByte: %u\n", ntohl(pay->usedByte));
        show_ipay_char("sessionKey", pay->sessionKey);
        show_ipay_char("signature", pay->signature);

        memset(&stat, 0, sizeof(stat));
        stat.type = htonl(IPAY_MSG_STATISTICS);
        if (mn.current_adv != NULL) {
                struct fa_nai_ext *nai;
                nai = (struct fa_nai_ext *) mn.current_adv->fa_nai;
                memcpy(stat.faIdentifier, MSG_NAI_DATA(nai),
                       MIN(IPAY_CHAR_LEN, GET_NAI_LEN(nai)));
        }
        /* FIX statistics */
        stat.bytes = htonl(0);
        time(&now);
        if (prev_stat == 0 || now < prev_stat) {
                stat.time = htonl(0);
                prev_stat = now;
        } else {
                stat.time = htonl(now - prev_stat);
                prev_stat = now;
        }
        DEBUG(DEBUG_IPAY, "\tsending statistics (bytes=%u, time=%u)\n",
              ntohl(stat.bytes), ntohl(stat.time));
        send_to_buyer(&stat, sizeof(stat));
        DEBUG(DEBUG_IPAY, "\tforwarding please pay more\n");
        send_to_buyer(msg, len);
}


static void handle_micro_payment(int s, char *msg, int len)
{
        struct ipay_micro_payment *pay;

        DEBUG(DEBUG_IPAY, "\tmicro payment message\n");
        if (ipay_check_len(len, sizeof(struct ipay_micro_payment)) < 0)
                return;

        pay = (struct ipay_micro_payment *) msg;

        show_ipay_char("mnIdentifier", pay->mnIdentifier);
        show_ipay_char("nextPayment", pay->nextPayment);

        send_to_fa(msg, len);
}


void handle_ipay(int s)
{
        char msg[MAXMSG];
        struct sockaddr_in from;
        int fromlen, len;
        IPAY_TYPE *type;

        DEBUG(DEBUG_IPAY, "Ipay message from socket %i\n", s);

        fromlen = sizeof(from);
        len = recvfrom(s, msg, MAXMSG, 0, (struct sockaddr *) &from, &fromlen);
        if (len < 0) {
                DEBUG(DEBUG_IPAY, "\trecvfrom failed - %s\n", strerror(errno));
                return;
        }
        DEBUG(DEBUG_IPAY, "\t%i bytes from %s:%i\n", len,
              inet_ntoa(from.sin_addr), ntohs(from.sin_port));

        if (len < sizeof(IPAY_TYPE)) {
                DEBUG(DEBUG_IPAY, "\ttoo short message - ignoring it\n");
                return;
        }
        type = (IPAY_TYPE *) msg;
        DEBUG(DEBUG_IPAY, "\ttype=%i\n", ntohl(*type));

        switch (ntohl(*type)) {
        case IPAY_MSG_INITIALIZE:
                handle_initialize(s, msg, len);
                break;
        case IPAY_MSG_POLICY_REPLY:
                handle_policy_prio_reply(s, msg, len);
                break;
        case IPAY_MSG_PURCHASE:
                handle_purchase(s, msg, len);
                break;
        case IPAY_MSG_ALLOWANCE:
                handle_allowance(s, msg, len);
                break;
        case IPAY_MSG_PLEASE_PAY_MORE:
                handle_please_pay_more(s, msg, len);
                break;
        case IPAY_MSG_MICRO_PAYMENT:
                handle_micro_payment(s, msg, len);
                break;
        default:
                DEBUG(DEBUG_IPAY, "\tunknown message type - ignoring "
                      "message\n");
                break;
        }
}


/* maximum wait time for 'blocking' prio req call in usecs */
#define IPAY_MAX_WAIT_TIME 1500000
/* policy request retry time in seconds */
#define IPAY_RETRY_TIME 120

struct prio_cache_data {
        struct node node;
        __u32 timePrice;
        __u32 bytePrice;
        __u32 priority;

        time_t req_time;
        int reply_ok; /* whether a reply was received or not; if not, retry
                       * after IPAY_RETRY_TYIME seconds */
};

#define PRIO_CACHE_SIZE 19
static struct hashtable *prio_cache = NULL;

static int
prio_hash(void *key, const int hashsize)
{
        int res;
        struct prio_cache_data *data = (struct prio_cache_data *) key;
        res = (data->timePrice + data->bytePrice) % PRIO_CACHE_SIZE;
        return (unsigned) res;
}

static int
prio_cmp(void *key, struct node *cmprd)
{
        struct prio_cache_data *prio1, *prio2;

        prio1 = (struct prio_cache_data *) key;
        prio2 = (struct prio_cache_data *) cmprd;

        if (prio1->timePrice == prio2->timePrice &&
            prio1->bytePrice == prio2->bytePrice)
                return 1;
        return 0;
}

static void
wait_for_reply(void)
{
        fd_set set;
        struct timeval tv, start, now;
        int diff;

        /* wait for the reply for a limited time and also process any other
         * Ipay messages */

        gettimeofday(&start, NULL);
        diff = 0;

        for (;;) {
                tv.tv_sec = (IPAY_MAX_WAIT_TIME - diff) / 1000000;
                tv.tv_usec = (IPAY_MAX_WAIT_TIME - diff) % 1000000;
                DEBUG(DEBUG_IPAY, "\twaiting for Ipay reply - timeout %i sec "
                      "%i usec\n", tv.tv_sec, tv.tv_usec);

                FD_ZERO(&set);
                FD_SET(mn.ipay_sock, &set);

                select(mn.ipay_sock + 1, &set, NULL, NULL, &tv);
                if (FD_ISSET(mn.ipay_sock, &set))
                        handle_ipay(mn.ipay_sock);

                if (prio_avail)
                        return;

                gettimeofday(&now, NULL);
                diff = (now.tv_sec - start.tv_sec) * 1000000 + now.tv_usec -
                        start.tv_usec;
                if (diff < 0) {
                        DEBUG(DEBUG_IPAY, "Clock changed?\n");
                        return;
                }
                if (diff >= IPAY_MAX_WAIT_TIME) {
                        DEBUG(DEBUG_IPAY, "Timeout while waiting a reply from "
                              "Ipay buyer\n");
                              return;
                }
        }
}


__u32 ipay_get_priority(__u32 timePrice, __u32 bytePrice)
{
        struct prio_cache_data *entry = NULL, key;
        struct ipay_policy_prio_req req;
        int update_entry = 0;

        if (!mn.ipay_in_use)
                return 1;

        if (prio_cache != NULL) {
                memset(&key, 0, sizeof(key));
                key.timePrice = timePrice;
                key.bytePrice = bytePrice;
                if (prio_cache == NULL) {
                        DEBUG(DEBUG_IPAY, "prio_cache == NULL\n");
                        entry = NULL;
                } else {
                        entry = (struct prio_cache_data *)
                                hashtable_fetch(prio_cache, prio_hash, &key,
                                                prio_cmp);
                }
                if (entry != NULL &&
                    (entry->reply_ok ||
                     time(NULL) < entry->req_time + IPAY_RETRY_TIME)) {
                        DEBUG(DEBUG_IPAY, "ipay_get_priority - prio=%u "
                              "(from cache)\n", entry->priority);
                        return entry->priority;
                }
                update_entry = 1;
        } else {
                prio_cache = hashtable_init(PRIO_CACHE_SIZE);
                if (prio_cache == NULL) {
                        DEBUG(DEBUG_IPAY, "Priority cache initialization "
                              "failed\n");
                        return 1;
                }
        }

        /* ask policy priority from Ipay Buyer */
        prio_avail = 0;

        memset(&req, 0, sizeof(req));
        req.type = htonl(IPAY_MSG_POLICY_REQ);
        req.timePrice = htonl(timePrice);
        req.bytePrice = htonl(bytePrice);

        if (send_to_buyer(&req, sizeof(req)) < 0)
                return 1;

        wait_for_reply();

        /* save the result */
        if (!update_entry || entry == NULL) {
                entry = (struct prio_cache_data *)
                        malloc(sizeof(struct prio_cache_data));
                if (entry == NULL) {
                        DEBUG(DEBUG_IPAY,
                              "ipay_get_priority - malloc failed\n");
                        return 1;
                }
        }

        memset(entry, 0, sizeof(struct prio_cache_data));
        entry->timePrice = timePrice;
        entry->bytePrice = bytePrice;
        time(&entry->req_time);

        if (!prio_avail) {
                DEBUG(DEBUG_IPAY, "No priority reply received in time - "
                      "assuming priority 1\n");
                entry->priority = 1;
        } else {
                entry->priority = last_prio;
                entry->reply_ok = 1;
        }

        if (!update_entry) {
                list_init_node(&entry->node);
                hashtable_add(prio_cache, prio_hash, &entry, &entry->node);
        }

        return entry->priority;
}

static int remove_prio(struct node *node, void *data)
{
        hashtable_remove(node);
        return 1;
}

void ipay_flush_priority_cache(int free_mem)
{
        if (prio_cache == NULL)
                return;
        hashtable_iterator(prio_cache, remove_prio, NULL);
        if (free_mem) {
                hashtable_destroy(prio_cache);
                prio_cache = NULL;
        }
}


void ipay_new_fa(struct agentadv_data *adv)
{
        struct ipay_new_fa new;
        int len, i;
        struct fa_nai_ext *nai;
        unsigned char *c;

        if (adv->adv.own_ext == NULL)
                return;
        if (strncmp(adv->fa_nai, prev_faIdentifier, IPAY_CHAR_LEN) == 0) {
                DEBUG(DEBUG_IPAY, "ipay_new_fa - using same FA - no report\n");
                return;
        }

        nai = (struct fa_nai_ext *) adv->fa_nai;
        DEBUG(DEBUG_IPAY, "ipay_new_fa - reporting FA[");
        c = MSG_NAI_DATA(nai);
        for (i = 0; i < GET_NAI_LEN(nai); i++) {
                if (*c < 32 || *c > 126)
                        DEBUG(DEBUG_IPAY, "<%i>", *c);
                else
                        DEBUG(DEBUG_IPAY, "%c", *c);
                c++;
        }
        DEBUG(DEBUG_IPAY, "], timePrice=%i, bytePrice=%i\n",
              ntohl(adv->adv.own_ext->timePrice),
              ntohl(adv->adv.own_ext->bytePrice));

        memset(&new, 0, sizeof(new));
        new.type = htonl(IPAY_MSG_NEW_FA);
        len = GET_NAI_LEN(nai);
        if (len > IPAY_CHAR_LEN) {
                DEBUG(DEBUG_IPAY, "\ttoo long FA NAI\n");
                len = IPAY_CHAR_LEN;
        }
        memcpy(new.faIdentifier, MSG_NAI_DATA(nai), len);
        new.timePrice = adv->adv.own_ext->timePrice;
        new.bytePrice = adv->adv.own_ext->bytePrice;

        send_to_buyer(&new, sizeof(new));
}


static int ipay_set_priority(struct node *node, void *data)
{
        __u32 prio;
        struct agentadv_data *adv = (struct agentadv_data *) node;

        if (adv->adv.own_ext == NULL ||
            (ntohs(adv->ext->opts) & AGENT_ADV_FOREIGN_AGENT) == 0)
                return 1;

        DEBUG(DEBUG_IPAY, "ipay_get_priority: time=%i byte=%i\n",
              ntohl(adv->adv.own_ext->timePrice),
              ntohl(adv->adv.own_ext->bytePrice));
        prio = ipay_get_priority(ntohl(adv->adv.own_ext->timePrice),
                                 ntohl(adv->adv.own_ext->bytePrice));

        if (prio == 0 && adv->priority > 0) {
                DEBUG(DEBUG_IPAY, "ipay_set_priority - marking FA unusable "
                      "(prio: %i ==> 0)\n", adv->priority);
        }

        /* FIX: adjust edata->adv->priority somehow according to Ipay prio */

        return 1;
}

static int ipay_handle_get_fa(void *data)
{
        struct event_FA *edata = (struct event_FA *) data;

        hashtable_iterator(edata->hash, ipay_set_priority, NULL);

        return 0;
}

static int ipay_handle_iface(void *data)
{
        /* quick hack to make sure that Ipay handler is after monitor handler.
         * Handler priorities would be a nicer solution.. */
        handler_unregister(FA_GET, ipay_handle_get_fa);
        handler_register(FA_GET, ipay_handle_get_fa);

        return 0;
}


void ipay_init(void)
{
        handler_register(FA_GET, ipay_handle_get_fa);
        handler_register(INTERFACE_INIT, ipay_handle_iface);
}

void ipay_cleanup(void)
{
        handler_unregister(FA_GET, ipay_handle_get_fa);
        handler_unregister(INTERFACE_INIT, ipay_handle_iface);
}

#endif

---