radius_pdu.h File Reference

#include "gwlib/gwlib.h"
#include "gwlib/dict.h"
#include "radius_attributes.def"
#include "radius_pdu.def"

Go to the source code of this file.

Data Structures
struct	RADIUS_PDU

Macros
#define	ATTR(attr, type, string, min, max)
#define	UNASSIGNED(attr)
#define	ATTRIBUTES(fields)
#define	INTEGER(name, octets)
#define	OCTETS(name, field_giving_octets)
#define	PDU(name, id, fields)   name = id,
#define	ATTR(attr, type, string, min, max)
#define	UNASSIGNED(attr)
#define	ATTRIBUTES(fields)
#define	INTEGER(name, octets)   unsigned long name;
#define	NULTERMINATED(name, max_octets)   Octstr *name;
#define	OCTETS(name, field_giving_octets)   Octstr *name;
#define	PDU(name, id, fields)   struct name { fields } name;

Typedefs
typedef struct RADIUS_PDU	RADIUS_PDU

Enumerations
enum	{ t_int, t_string, t_ipaddr }
enum	{ ATTRIBUTES, ATTRIBUTES }

Functions
RADIUS_PDU *	radius_pdu_create (int type, RADIUS_PDU *req)
void	radius_pdu_destroy (RADIUS_PDU *pdu)
int	radius_authenticate_pdu (RADIUS_PDU *pdu, Octstr **data, Octstr *secret)
Octstr *	radius_pdu_pack (RADIUS_PDU *pdu)
RADIUS_PDU *	radius_pdu_unpack (Octstr *data_without_len)
void	radius_pdu_dump (RADIUS_PDU *pdu)
Octstr *	radius_get_attribute (RADIUS_PDU *pdu, Octstr *attribute)

Macro Definition Documentation

ATTR [1/2]

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

Definition at line 95 of file radius_pdu.h.

ATTR [2/2]

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

Definition at line 95 of file radius_pdu.h.

ATTRIBUTES [1/2]

#define ATTRIBUTES

(

fields

)

Definition at line 97 of file radius_pdu.h.

ATTRIBUTES [2/2]

#define ATTRIBUTES

(

fields

)

Definition at line 97 of file radius_pdu.h.

INTEGER [1/2]

#define INTEGER	(		name,
			octets
	)

INTEGER [2/2]

#define INTEGER	(		name,
			octets
	)		unsigned long name;

NULTERMINATED

#define NULTERMINATED	(		name,
			max_octets
	)		Octstr *name;

OCTETS [1/2]

#define OCTETS	(		name,
			field_giving_octets
	)

OCTETS [2/2]

#define OCTETS	(		name,
			field_giving_octets
	)		Octstr *name;

PDU [1/2]

#define PDU	(		name,
			id,
			fields
	)		name = id,

PDU [2/2]

#define PDU	(		name,
			id,
			fields
	)		struct name { fields } name;

UNASSIGNED [1/2]

#define UNASSIGNED

(

attr

)

Definition at line 96 of file radius_pdu.h.

UNASSIGNED [2/2]

#define UNASSIGNED

(

attr

)

Definition at line 96 of file radius_pdu.h.

Typedef Documentation

RADIUS_PDU

typedef struct RADIUS_PDU RADIUS_PDU

Definition at line 89 of file radius_pdu.h.

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
t_int
t_string
t_ipaddr

Definition at line 72 of file radius_pdu.h.

     {
    t_int, t_string, t_ipaddr
};

anonymous enum

anonymous enum

Enumerator
ATTRIBUTES
ATTRIBUTES

Definition at line 76 of file radius_pdu.h.

     {
    #define ATTR(attr, type, string, min, max)
    #define UNASSIGNED(attr)
    #define ATTRIBUTES(fields)
    #include "radius_attributes.def"
    #define INTEGER(name, octets)
    #define OCTETS(name, field_giving_octets)
    #define PDU(name, id, fields) name = id,
    #include "radius_pdu.def"
    RADIUS_PDU_DUMMY_TYPE
};

Function Documentation

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