radius_pdu.c File Reference

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

Go to the source code of this file.

Macros
#define	MIN_RADIUS_PDU_LEN   20
#define	MAX_RADIUS_PDU_LEN   4095
#define	INTEGER(name, octets)
#define	OCTETS(name, field_giving_octets)   p->name = NULL;
#define	PDU(name, id, fields)
#define	ATTR(attr, type, string, min, max)
#define	UNASSIGNED(attr)
#define	ATTRIBUTES(fields)   pdu->attr = dict_create(20, (void (*)(void *))octstr_destroy);
#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;
#define	ATTR(attr, type, string, min, max)
#define	UNASSIGNED(attr)
#define	ATTRIBUTES(fields)   dict_destroy(pdu->attr);
#define	ATTR(atype, type, string, pmin, pmax)
#define	UNASSIGNED(attr)
#define	ATTRIBUTES(fields)
#define	INTEGER(name, octets)   append_encoded_integer(os, p->name, octets);
#define	OCTETS(name, field_giving_octets)   octstr_append(os, p->name);
#define	PDU(name, id, fields)
#define	ATTR(atype, type, string, pmin, pmax)
#define	UNASSIGNED(attr)
#define	ATTRIBUTES(fields)
#define	INTEGER(name, octets)
#define	OCTETS(name, field_giving_octets)   p->name = parse_get_octets(context, field_giving_octets);
#define	PDU(name, id, fields)
#define	UNASSIGNED(attr)
#define	ATTR(atype, type, string, pmin, pmax)
#define	ATTRIBUTES(fields)
#define	INTEGER(name, octets)   debug("radius", 0, " %s: %lu = 0x%08lx", #name, p->name, p->name);
#define	OCTETS(name, field_giving_octets)   octstr_dump_short(p->name, 2, #name);
#define	PDU(name, id, fields)

Functions
static unsigned long	decode_integer (Octstr *os, long pos, int octets)
static void	append_encoded_integer (Octstr *os, unsigned long u, long octets)
RADIUS_PDU *	radius_pdu_create (int type, RADIUS_PDU *req)
void	radius_pdu_destroy (RADIUS_PDU *pdu)
static Octstr *	radius_attr_pack (RADIUS_PDU *pdu)
Octstr *	radius_pdu_pack (RADIUS_PDU *pdu)
static Octstr *	radius_type_convert (int type, Octstr *value)
static void	radius_attr_unpack (ParseContext **context, RADIUS_PDU **pdu)
RADIUS_PDU *	radius_pdu_unpack (Octstr *data_without_len)
int	radius_authenticate_pdu (RADIUS_PDU *pdu, Octstr **data, Octstr *secret)
static void	radius_attr_dump (RADIUS_PDU *pdu)
void	radius_pdu_dump (RADIUS_PDU *pdu)
Octstr *	radius_get_attribute (RADIUS_PDU *pdu, Octstr *attribute)

Macro Definition Documentation

ATTR [1/5]

#define ATTR	(		attr,
			type,
			string,
			min,
			max
	)

ATTR [2/5]

#define ATTR	(		attr,
			type,
			string,
			min,
			max
	)

ATTR [3/5]

#define ATTR	(		atype,
			type,
			string,
			pmin,
			pmax
	)

Value:

{                                                                        \
            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);                                            \
        }

ATTR [4/5]

#define ATTR	(		atype,
			type,
			string,
			pmin,
			pmax
	)

Value:

if (atype == attr_type) {  \
                    Octstr *tmp, *value; \
                    if ((attr_len-2) < pmin || (attr_len-2) > pmax) { \
                        error(0, "RADIUS: Attribute (%d) `%s' has invalid len %d, droppped.", \
                              attr_type, string, (attr_len-2)); \
                        continue;  \
                    } \
                    attr_val = parse_get_octets(*context, attr_len - 2); \
                    tmp = octstr_format("RADIUS: Attribute (%d) `%s', len %d", \
                          attr_type, string, attr_len - 2); \
                    value = radius_type_convert(type, attr_val); \
                    octstr_destroy(attr_val); \
                    octstr_dump_short(value, 0, octstr_get_cstr(tmp)); \
                    octstr_destroy(tmp); \
                    attr_str = octstr_create(string);  \
                    dict_put((*pdu)->attr, attr_str, value);  \
                    octstr_destroy(attr_str);  \
                    value = NULL;  \
                } else

ATTR [5/5]

#define ATTR	(		atype,
			type,
			string,
			pmin,
			pmax
	)

Value:

id = atype; \
        key = octstr_create(string); \
        val = dict_get(pdu->attr, key); \
        if (val != NULL) \
            octstr_dump_short(val, 2, #atype); \
        octstr_destroy(key);

ATTRIBUTES [1/5]

#define ATTRIBUTES

(

fields

)

pdu->attr = dict_create(20, (void (*)(void *))octstr_destroy);

ATTRIBUTES [2/5]

#define ATTRIBUTES

(

fields

)

dict_destroy(pdu->attr);

ATTRIBUTES [3/5]

#define ATTRIBUTES

(

fields

)

ATTRIBUTES [4/5]

#define ATTRIBUTES

(

fields

)

Value:

while (parse_octets_left(*context) > 0 && !parse_error(*context)) {                          \
            int attr_type, attr_len;                                                                 \
            Octstr *attr_val = NULL;                                                                 \
            Octstr *attr_str = NULL;                                                                 \
            attr_type = parse_get_char(*context);                                                    \
            attr_len = parse_get_char(*context);                                                     \
            fields                                                                                   \
            {                                                                                        \
                debug("radius.unpack", 0, "RADIUS: Unknown attribute type (0x%03lx) "                \
                      "len %d in PDU `%s'.",                                                         \
                        (long unsigned int)attr_type, attr_len, (*pdu)->type_name);                  \
                parse_skip(*context, attr_len - 2);                                                  \
            }                                                                                        \
        }

ATTRIBUTES [5/5]

#define ATTRIBUTES

(

fields

)

Value:

if (pdu->attr != NULL) { \
        Octstr *key = NULL, *val = NULL; \
        int id; \
        fields \
    }

INTEGER [1/5]

#define INTEGER	(		name,
			octets
	)

Value:

if (strcmp(#name, "code") == 0) p->name = type; \
    else p->name = 0;

INTEGER [2/5]

#define INTEGER	(		name,
			octets
	)		p->name = 0;

INTEGER [3/5]

#define INTEGER	(		name,
			octets
	)		append_encoded_integer(os, p->name, octets);

INTEGER [4/5]

#define INTEGER	(		name,
			octets
	)

Value:

pos = octstr_len(data_without_len) - parse_octets_left(context); \
        p->name = decode_integer(data_without_len, pos, octets); \
        parse_skip(context, octets);

INTEGER [5/5]

#define INTEGER	(		name,
			octets
	)		debug("radius", 0, " %s: %lu = 0x%08lx", #name, p->name, p->name);

MAX_RADIUS_PDU_LEN

#define MAX_RADIUS_PDU_LEN   4095

Definition at line 73 of file radius_pdu.c.

MIN_RADIUS_PDU_LEN

#define MIN_RADIUS_PDU_LEN   20

Definition at line 72 of file radius_pdu.c.

OCTETS [1/5]

#define OCTETS	(		name,
			field_giving_octets
	)		p->name = NULL;

OCTETS [2/5]

#define OCTETS	(		name,
			field_giving_octets
	)		octstr_destroy(p->name);

OCTETS [3/5]

#define OCTETS	(		name,
			field_giving_octets
	)		octstr_append(os, p->name);

OCTETS [4/5]

#define OCTETS	(		name,
			field_giving_octets
	)		p->name = parse_get_octets(context, field_giving_octets);

OCTETS [5/5]

#define OCTETS	(		name,
			field_giving_octets
	)		octstr_dump_short(p->name, 2, #name);

PDU [1/5]

#define PDU	(		name,
			id,
			fields
	)

Value:

case id: { \
        struct name *p = &pdu->u.name; \
        pdu->type_name = #name; \
        fields \
    } break;

PDU [2/5]

#define PDU	(		name,
			id,
			fields
	)		case id: { struct name *p = &pdu->u.name; fields } break;

PDU [3/5]

#define PDU	(		name,
			id,
			fields
	)

Value:

case id: { struct name *p = &pdu->u.name; fields; oos = radius_attr_pack(pdu); \
                   octstr_append(os, oos);octstr_destroy(oos); } break;

PDU [4/5]

#define PDU	(		name,
			id,
			fields
	)

Value:

case id: { struct name *p = &pdu->u.name; fields; \
                   radius_attr_unpack(&context, &pdu); } break;

PDU [5/5]

#define PDU	(		name,
			id,
			fields
	)

Value:

case id: { struct name *p = &pdu->u.name; fields; \
                   radius_attr_dump(pdu); } break;

UNASSIGNED [1/5]

#define UNASSIGNED

(

attr

)

UNASSIGNED [2/5]

#define UNASSIGNED

(

attr

)

UNASSIGNED [3/5]

#define UNASSIGNED

(

attr

)

UNASSIGNED [4/5]

#define UNASSIGNED

(

attr

)

Value:

if (attr == attr_type) {  \
                    error(0, "RADIUS: Attribute (%d) is unassigned and should not be used.", \
                              attr_type); \
                    continue;  \
                } else

UNASSIGNED [5/5]

#define UNASSIGNED

(

attr

)

Function Documentation

append_encoded_integer()

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

static

Definition at line 91 of file radius_pdu.c.

References octstr_append_char().

Referenced by radius_pdu_pack().

{
    long i;

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

decode_integer()

static unsigned long decode_integer ( Octstr *  os, long  pos, int  octets  )

static

Definition at line 76 of file radius_pdu.c.

References gw_assert(), octstr_get_char(), and octstr_len().

Referenced by radius_pdu_unpack(), and radius_type_convert().

{
    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;
}

radius_attr_dump()

static void radius_attr_dump ( RADIUS_PDU *  pdu )

static

Definition at line 459 of file radius_pdu.c.

{
    #define UNASSIGNED(attr)
    #define ATTR(atype, type, string, pmin, pmax)  \
        id = atype; \
        key = octstr_create(string); \
        val = dict_get(pdu->attr, key); \
        if (val != NULL) \
            octstr_dump_short(val, 2, #atype); \
        octstr_destroy(key);
    #define ATTRIBUTES(fields) \
    if (pdu->attr != NULL) { \
        Octstr *key = NULL, *val = NULL; \
        int id; \
        fields \
    }
    #include "radius_attributes.def"
}

radius_attr_pack()

static Octstr* radius_attr_pack ( RADIUS_PDU *  pdu )

static

Definition at line 210 of file radius_pdu.c.

References gw_assert(), and octstr_create.

{
    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;
}

radius_attr_unpack()

static void radius_attr_unpack ( ParseContext **  context, RADIUS_PDU **  pdu  )

static

Definition at line 314 of file radius_pdu.c.

{
    #define ATTR(atype, type, string, pmin, pmax) \
                if (atype == attr_type) {  \
                    Octstr *tmp, *value; \
                    if ((attr_len-2) < pmin || (attr_len-2) > pmax) { \
                        error(0, "RADIUS: Attribute (%d) `%s' has invalid len %d, droppped.", \
                              attr_type, string, (attr_len-2)); \
                        continue;  \
                    } \
                    attr_val = parse_get_octets(*context, attr_len - 2); \
                    tmp = octstr_format("RADIUS: Attribute (%d) `%s', len %d", \
                          attr_type, string, attr_len - 2); \
                    value = radius_type_convert(type, attr_val); \
                    octstr_destroy(attr_val); \
                    octstr_dump_short(value, 0, octstr_get_cstr(tmp)); \
                    octstr_destroy(tmp); \
                    attr_str = octstr_create(string);  \
                    dict_put((*pdu)->attr, attr_str, value);  \
                    octstr_destroy(attr_str);  \
                    value = NULL;  \
                } else 
    #define UNASSIGNED(attr)  \
                if (attr == attr_type) {  \
                    error(0, "RADIUS: Attribute (%d) is unassigned and should not be used.", \
                              attr_type); \
                    continue;  \
                } else 
    #define ATTRIBUTES(fields)                                                                       \
        while (parse_octets_left(*context) > 0 && !parse_error(*context)) {                          \
            int attr_type, attr_len;                                                                 \
            Octstr *attr_val = NULL;                                                                 \
            Octstr *attr_str = NULL;                                                                 \
            attr_type = parse_get_char(*context);                                                    \
            attr_len = parse_get_char(*context);                                                     \
            fields                                                                                   \
            {                                                                                        \
                debug("radius.unpack", 0, "RADIUS: Unknown attribute type (0x%03lx) "                \
                      "len %d in PDU `%s'.",                                                         \
                        (long unsigned int)attr_type, attr_len, (*pdu)->type_name);                  \
                parse_skip(*context, attr_len - 2);                                                  \
            }                                                                                        \
        }                                                                                          
    #include "radius_attributes.def"
}

radius_authenticate_pdu()

int radius_authenticate_pdu	(	RADIUS_PDU *	pdu,
		Octstr **	data,
		Octstr *	secret
	)

Definition at line 416 of file radius_pdu.c.

References md5(), octstr_append(), octstr_append_data(), octstr_compare(), octstr_copy, octstr_delete(), octstr_destroy(), octstr_duplicate, octstr_insert(), octstr_len(), RADIUS_PDU::type, and RADIUS_PDU::u.

Referenced by main(), proxy_thread(), and server().

{
    int rc = 0;
    Octstr *stream; 
    Octstr *attributes;
    Octstr *digest;

    stream = attributes = digest = NULL;

    /* first extract attributes from raw data, where
     * the first 20 octets are code, idendifier, length
     * and authenticator value as described in RFC2866, sec. 3 */
    if (octstr_len(*data) > 20)
        attributes = octstr_copy(*data, 20, octstr_len(*data)-20);
  
    switch (pdu->type) {
        case 0x04:  /* Accounting-Request, see RFC2866, page 6 */
            stream = octstr_copy(*data, 0, 4);
            octstr_append_data(stream, "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0", 16);
            octstr_append(stream, attributes);
            octstr_append(stream, secret);
            digest = md5(stream);
            rc = octstr_compare(pdu->u.Accounting_Request.authenticator, 
                                digest) == 0 ? 1 : 0;
            break;
        case 0x05:  /* Accounting-Response, create Response authenticator */
            stream = octstr_duplicate(*data);
            octstr_append(stream, secret);
            digest = md5(stream);
            octstr_delete(*data, 4, 16);
            octstr_insert(*data, digest, 4);
            break;
        default:
            break;
    }

    octstr_destroy(attributes);
    octstr_destroy(stream);
    octstr_destroy(digest);

    return rc;
}

radius_get_attribute()

Octstr* radius_get_attribute	(	RADIUS_PDU *	pdu,
		Octstr *	attribute
	)

Definition at line 498 of file radius_pdu.c.

References RADIUS_PDU::attr, dict_get(), and gw_assert().

{
    gw_assert(pdu != NULL);
    
    if (pdu->attr == NULL)
        return NULL;

    return dict_get(pdu->attr, attribute);
}

radius_pdu_create()

RADIUS_PDU* radius_pdu_create	(	int	type,
		RADIUS_PDU *	req
	)

Definition at line 123 of file radius_pdu.c.

References error(), RADIUS_PDU::type, and type.

Referenced by main(), proxy_thread(), radius_pdu_unpack(), and server().

{
    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;
}

radius_pdu_destroy()

void radius_pdu_destroy

(

RADIUS_PDU *

pdu

)

Definition at line 156 of file radius_pdu.c.

References error(), and RADIUS_PDU::type.

Referenced by main(), proxy_thread(), and server().

{
    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);
}

radius_pdu_dump()

void radius_pdu_dump

(

RADIUS_PDU *

pdu

)

Definition at line 478 of file radius_pdu.c.

References debug(), and error().

{
    debug("radius", 0, "RADIUS PDU %p dump:", (void *) pdu);
    debug("radius", 0, "  type_name: %s", pdu->type_name);
    switch (pdu->type) {
    #define INTEGER(name, octets) \
        debug("radius", 0, "  %s: %lu = 0x%08lx", #name, p->name, p->name);
    #define OCTETS(name, field_giving_octets) \
        octstr_dump_short(p->name, 2, #name);
    #define PDU(name, id, fields) \
        case id: { struct name *p = &pdu->u.name; fields; \
                   radius_attr_dump(pdu); } break;
    #include "radius_pdu.def"
    default:
        error(0, "Unknown RADIUS_PDU type, internal error.");
    break;
    }
    debug("radius", 0, "RADIUS PDU dump ends.");
}

radius_pdu_pack()

Octstr* radius_pdu_pack

(

RADIUS_PDU *

pdu

)

Definition at line 237 of file radius_pdu.c.

References append_encoded_integer(), error(), gw_assert(), octstr_create, octstr_delete(), octstr_destroy(), octstr_insert(), octstr_len(), and RADIUS_PDU::type.

Referenced by main(), proxy_thread(), and server().

{
    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.");
    }
    */

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

    /* now set PDU length */
    temp = octstr_create("");
    append_encoded_integer(temp, octstr_len(os), 2);
    octstr_delete(os, 2, 2);
    octstr_insert(os, temp, 2);
    octstr_destroy(temp);
    
    return os;
}

radius_pdu_unpack()

RADIUS_PDU* radius_pdu_unpack

(

Octstr *

data_without_len

)

Definition at line 360 of file radius_pdu.c.

References debug(), decode_integer(), error(), octstr_destroy(), octstr_dump_short(), octstr_len(), parse_context_create(), parse_context_destroy(), parse_get_char(), parse_get_octets(), parse_skip(), radius_pdu_create(), and type.

Referenced by main(), proxy_thread(), and server().

{
    RADIUS_PDU *pdu;
    int type;
    long len, pos;
    ParseContext *context;
    Octstr *authenticator; 

    len = octstr_len(data_without_len);

    if (len < 20) {
        error(0, "RADIUS: PDU was too short (%ld bytes).",
              octstr_len(data_without_len));
        return NULL;
    }

    context = parse_context_create(data_without_len);

    type = parse_get_char(context);
    parse_get_char(context);
    pdu = radius_pdu_create(type, NULL);
    if (pdu == NULL)
        return NULL;

    len = decode_integer(data_without_len, 2, 2) - 19;
    parse_skip(context, 2);
    debug("radius", 0, "RADIUS: Attributes len is %ld", len);

    authenticator = parse_get_octets(context, 16);
    octstr_dump_short(authenticator, 0, "RADIUS: Authenticator (md5) is:");

    /* skipping back to context start for macro magic */
    parse_context_destroy(context);
    context = parse_context_create(data_without_len);

    switch (type) {
    #define INTEGER(name, octets) \
        pos = octstr_len(data_without_len) - parse_octets_left(context); \
        p->name = decode_integer(data_without_len, pos, octets); \
        parse_skip(context, octets);
    #define OCTETS(name, field_giving_octets) \
        p->name = parse_get_octets(context, field_giving_octets); 
    #define PDU(name, id, fields) \
        case id: { struct name *p = &pdu->u.name; fields; \
                   radius_attr_unpack(&context, &pdu); } break;
    #include "radius_pdu.def"
    default:
        error(0, "Unknown RADIUS_PDU type, internal error while unpacking.");
    }

    parse_context_destroy(context);
    octstr_destroy(authenticator);

    return pdu;
}

radius_type_convert()

static Octstr* radius_type_convert ( int  type, Octstr *  value  )

static

Definition at line 283 of file radius_pdu.c.

References decode_integer(), octstr_append(), octstr_append_cstr(), octstr_create, octstr_destroy(), octstr_format(), octstr_get_char(), octstr_get_cstr, panic, t_int, t_ipaddr, t_string, and type.

{
    Octstr *ret = NULL;
    int i;

    switch (type) {
        case t_int:
            ret = octstr_format("%ld", decode_integer(value, 0, 4));
            break;
        case t_string:
            ret = octstr_format("%s", octstr_get_cstr(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);
                if (i < 3)
                    octstr_append_cstr(ret, ".");
                octstr_destroy(b);
            }
            break;
        default:
            panic(0, "RADIUS: Attribute type %d does not exist.", type);
            break;
    }

    return ret;
}