radius_pdu.c

The Kannel Open Source WAP and SMS gateway works as both an SMS gateway, for implementing keyword b

/* ==================================================================== 
 * The Kannel Software License, Version 1.0 
 * 
 * Copyright (c) 2001-2004 Kannel Group  
 * Copyright (c) 1998-2001 WapIT Ltd.   
 * All rights reserved. 
 * 
 * Redistribution and use in source and binary forms, with or without 
 * modification, are permitted provided that the following conditions 
 * are met: 
 * 
 * 1. Redistributions of source code must retain the above copyright 
 *    notice, this list of conditions and the following disclaimer. 
 * 
 * 2. Redistributions in binary form must reproduce the above copyright 
 *    notice, this list of conditions and the following disclaimer in 
 *    the documentation and/or other materials provided with the 
 *    distribution. 
 * 
 * 3. The end-user documentation included with the redistribution, 
 *    if any, must include the following acknowledgment: 
 *       "This product includes software developed by the 
 *        Kannel Group (http://www.kannel.org/)." 
 *    Alternately, this acknowledgment may appear in the software itself, 
 *    if and wherever such third-party acknowledgments normally appear. 
 * 
 * 4. The names "Kannel" and "Kannel Group" must not be used to 
 *    endorse or promote products derived from this software without 
 *    prior written permission. For written permission, please  
 *    contact [e-mail]. 
 * 
 * 5. Products derived from this software may not be called "Kannel", 
 *    nor may "Kannel" appear in their name, without prior written 
 *    permission of the Kannel Group. 
 * 
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED 
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
 * DISCLAIMED.  IN NO EVENT SHALL THE KANNEL GROUP OR ITS CONTRIBUTORS 
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,  
 * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT  
 * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR  
 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,  
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE  
 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,  
 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
 * ==================================================================== 
 * 
 * This software consists of voluntary contributions made by many 
 * individuals on behalf of the Kannel Group.  For more information on  
 * the Kannel Group, please see <http://www.kannel.org/>. 
 * 
 * Portions of this software are based upon software originally written at  
 * WapIT Ltd., Helsinki, Finland for the Kannel project.  
 */ 

/*
 * radius_pdu.c - parse and generate RADIUS Accounting PDUs
 *
 * Taken from gw/smsc/smpp_pdu.c writen by Lars Wirzenius.
 * This makes heavy use of C pre-processor macro magic.
 *
 * Stipe Tolj <[e-mail]>
 */


#include <string.h>
#include "radius_pdu.h"

#define MIN_RADIUS_PDU_LEN  20
#define MAX_RADIUS_PDU_LEN  4095 


static unsigned long decode_integer(Octstr *os, long pos, int octets)
{
    unsigned long u;
    int i;

    gw_assert(octstr_len(os) >= pos + octets);

    u = 0;
    for (i = 0; i < octets; ++i)
    	u = (u << 8) | octstr_get_char(os, pos + i);

    return u;
}


static void append_encoded_integer(Octstr *os, unsigned long u, long octets)
{
    long i;

    for (i = 0; i < octets; ++i)
    	octstr_append_char(os, (u >> ((octets - i - 1) * 8)) & 0xFF);
}


/*
static void *get_header_element(RADIUS_PDU *pdu, unsigned char *e) 
{
    switch (pdu->type) {
    #define INTEGER(name, octets) \
    if (strcmp(#name, e) == 0) return (void*) *(&p->name);
    #define NULTERMINATED(name, max_octets)
    #define OCTETS(name, field_giving_octets) \
    if (strcmp(#name, e) == 0) return (void*) p->name;
    #define PDU(name, id, fields) \
        case id: { \
        struct name *p = &pdu->u.name; \
    } break;
    #include "radius_pdu.def"
    default:
    	error(0, "Unknown RADIUS_PDU type, internal error.");
    	gw_free(pdu);
	   return NULL;
    }
}
*/


RADIUS_PDU *radius_pdu_create(int type, RADIUS_PDU *req)
{
    RADIUS_PDU *pdu;

    pdu = gw_malloc(sizeof(*pdu));
    pdu->type = type;

    switch (type) {
    #define INTEGER(name, octets) \
   	if (strcmp(#name, "code") == 0) p->name = type; \
    else p->name = 0;
    #define OCTETS(name, field_giving_octets) p->name = NULL;
    #define PDU(name, id, fields) \
    	case id: { \
	    struct name *p = &pdu->u.name; \
	    pdu->type_name = #name; \
	    fields \
	} break;
    #include "radius_pdu.def"
    default:
    	error(0, "Unknown RADIUS_PDU type, internal error.");
    	gw_free(pdu);
	return NULL;
    }
    #define ATTR(attr, type, string, min, max)
    #define UNASSIGNED(attr)
    #define ATTRIBUTES(fields) \
        pdu->attr = dict_create(20, (void (*)(void *))octstr_destroy);
    #include "radius_attributes.def"

    return pdu;
}

void radius_pdu_destroy(RADIUS_PDU *pdu)
{
    if (pdu == NULL)
    	return;

    switch (pdu->type) {
    #define INTEGER(name, octets) p->name = 0;
    #define OCTETS(name, field_giving_octets) octstr_destroy(p->name);
    #define PDU(name, id, fields) \
    	case id: { struct name *p = &pdu->u.name; fields } break;
    #include "radius_pdu.def"
    default:
    	error(0, "Unknown RADIUS_PDU type, internal error while destroying.");
    }

    #define ATTR(attr, type, string, min, max)
    #define UNASSIGNED(attr)
    #define ATTRIBUTES(fields) dict_destroy(pdu->attr);
    #include "radius_attributes.def"

    gw_free(pdu);
}

/*
static void radius_type_append(Octstr **os, int type, int pmin, int pmax, 
                               Octstr *value) 
{
    long l;

    switch (type) {
        case t_int:
            octstr_parse_long(&l, value, 0, 10);
    	    append_encoded_integer(*os, l, pmin);
            break;
        case t_string:
            octstr_append(*os, value);
            break;
        case t_ipaddr:
            ret = octstr_create("");
            for (i = 0; i < 4; i++) {
                int c = octstr_get_char(value, i);
                Octstr *b = octstr_format("%d", c);
                octstr_append(ret, b);
                i < 3 ? octstr_append_cstr(ret, ".") : NULL;
                octstr_destroy(b);
            }
            break;
        default:
            panic(0, "RADIUS: Attribute type %d does not exist.", type);
            break;
    }
}
*/

static Octstr *radius_attr_pack(RADIUS_PDU *pdu) 
{
    Octstr *os;

    os = octstr_create("");

    gw_assert(pdu != NULL);

    #define ATTR(atype, type, string, pmin, pmax)                                \
        {                                                                        \
            Octstr *attr_strg = octstr_create(string);                           \
            Octstr *attr_val = dict_get(p->attr, attr_str);                      \
            if (attr_str != NULL) {                                              \
                int attr_len = octstr_len(attr_val) + 2;                         \
                octstr_format_append(os, "%02X", atype);                         \
                octstr_append_data(os, (char*) &attr_len, 2);                    \
                radius_type_append(&os, type, pmin, pmax, attr_val);             \
            }                                                                    \
            octstr_destroy(attr_str);                                            \
        } 
    #define UNASSIGNED(attr)
    #define ATTRIBUTES(fields)                                                                     
    #include "radius_attributes.def"

    return os;
}

Octstr *radius_pdu_pack(RADIUS_PDU *pdu)
{
    Octstr *os,*oos;
    Octstr *temp;

    os = octstr_create("");

    gw_assert(pdu != NULL);

    /*
    switch (pdu->type) {
    #define INTEGER(name, octets) p = *(&p);
    #define NULTERMINATED(name, max_octets) p = *(&p);
    #define OCTETS(name, field_giving_octets) \
    	p->field_giving_octets = octstr_len(p->name);
    #define PDU(name, id, fields) \
    	case id: { struct name *p = &pdu->u.name; fields } break;
    #include "radius_pdu.def"
    default:
    	error(0, "Unknown RADIUS_PDU type, internal error while packing.");
    }