* Version: $Id$
*
*/
-
#include "autoconf.h"
-#if HAVE_SYS_TYPES_H
+#ifdef HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif
-#if HAVE_STDINT_H
+#ifdef HAVE_STDINT_H
#include <stdint.h>
#endif
-#if HAVE_INTTYPES_H
+#ifdef HAVE_INTTYPES_H
#include <inttypes.h>
#endif
-#if HAVE_ERRNO_H
+#ifdef HAVE_ERRNO_H
#include <errno.h>
#endif
# include <sys/time.h>
# include <time.h>
#else
-# if HAVE_SYS_TIME_H
+# ifdef HAVE_SYS_TIME_H
# include <sys/time.h>
# else
# include <time.h>
#endif
#endif
+/*
+ * Include for modules.
+ */
+#include <sha1.h>
+#include <md4.h>
+
+#define EAP_START 2
+
#define AUTH_VECTOR_LEN 16
#define CHAP_VALUE_LENGTH 16
#define MAX_STRING_LEN 254 /* RFC2138: string 0-253 octets */
-#define PW_AUTH_UDP_PORT 1645
-#define PW_ACCT_UDP_PORT 1646
-
#ifdef _LIBRADIUS
# define AUTH_HDR_LEN 20
# define VENDORPEC_USR 429
-# define VENDOR(x) (x >> 16)
+# define VENDOR(x) ((x >> 16) & 0xffff)
# define DEBUG if (librad_debug) printf
# define debug_pair(vp) do { if (librad_debug) { \
putchar('\t'); \
putchar('\n'); \
} \
} while(0)
+# define TAG_VALID(x) ((x) > 0 && (x) < 0x20)
+# define TAG_VALID_ZERO(x) ((x) >= 0 && (x) < 0x20)
+# define TAG_ANY -128 /* minimum signed char */
#endif
+#if defined(__GNUC__)
+# define PRINTF_LIKE(n) __attribute__ ((format(printf, n, n+1)))
+# define NEVER_RETURNS __attribute__ ((noreturn))
+# define UNUSED __attribute__ ((unused))
+# define BLANK_FORMAT " " /* GCC_LINT whines about empty formats */
+#else
+# define PRINTF_LIKE(n) /* ignore */
+# define NEVER_RETURNS /* ignore */
+# define UNUSED /* ignore */
+# define BLANK_FORMAT ""
+#endif
+
+typedef struct attr_flags {
+ unsigned int addport : 1; /* add NAS-Port to IP address */
+ unsigned int has_tag : 1; /* tagged attribute */
+ unsigned int do_xlat : 1; /* strvalue is dynamic */
+ unsigned int caseless : 1; /* case insensitive compares */
+ int8_t tag; /* tag for tunneled attributes */
+ uint8_t encrypt; /* encryption method */
+} ATTR_FLAGS;
+
+/*
+ * Values of the encryption flags.
+ */
+#define FLAG_ENCRYPT_NONE (0)
+#define FLAG_ENCRYPT_USER_PASSWORD (1)
+#define FLAG_ENCRYPT_TUNNEL_PASSWORD (2)
+#define FLAG_ENCRYPT_ASCEND_SECRET (3)
+
typedef struct dict_attr {
- char name[32];
+ char name[40];
int attr;
int type;
int vendor;
- struct dict_attr *next;
+ ATTR_FLAGS flags;
} DICT_ATTR;
typedef struct dict_value {
- char name[32];
- char attrname[32];
+ char name[40];
int attr;
int value;
- struct dict_value *next;
} DICT_VALUE;
typedef struct dict_vendor {
- char vendorname[32];
+ char name[40];
int vendorpec;
- int vendorcode;
struct dict_vendor *next;
} DICT_VENDOR;
typedef struct value_pair {
- char name[32];
+ char name[40];
int attribute;
int type;
int length; /* of strvalue */
uint32_t lvalue;
- int operator;
- int addport;
+ LRAD_TOKEN operator;
uint8_t strvalue[MAX_STRING_LEN];
+ ATTR_FLAGS flags;
struct value_pair *next;
} VALUE_PAIR;
u_short src_port;
u_short dst_port;
int id;
- int code;
+ unsigned int code;
uint8_t vector[AUTH_VECTOR_LEN];
time_t timestamp;
int verified;
* Dictionary functions.
*/
int dict_addvendor(const char *name, int value);
-int dict_addattr(const char *name, int vendor, int type, int value);
+int dict_addattr(const char *name, int vendor, int type, int value, ATTR_FLAGS flags);
int dict_addvalue(const char *namestr, char *attrstr, int value);
int dict_init(const char *dir, const char *fn);
+void dict_free(void);
DICT_ATTR *dict_attrbyvalue(int attr);
DICT_ATTR *dict_attrbyname(const char *attr);
DICT_VALUE *dict_valbyattr(int attr, int val);
DICT_VALUE *dict_valbyname(int attr, const char *val);
-int dict_vendorcode(int);
-int dict_vendorpec(int);
-int dict_vendorname(const char *name);
+int dict_vendorbyname(const char *name);
+DICT_VENDOR *dict_vendorbyvalue(int vendor);
+
+/*
+ * Compatibility
+ */
+#define dict_vendorcode
+#define dict_vendorpec
+
#if 1 /* FIXME: compat */
#define dict_attrget dict_attrbyvalue
/*#define dict_valget dict_valbyattr almost but not quite*/
#endif
+/* get around diffrent ctime_r styles */
+#ifdef CTIMERSTYLE
+#if CTIMERSTYLE == SOLARISSTYLE
+#define CTIME_R(a,b,c) ctime_r(a,b,c)
+#else
+#define CTIME_R(a,b,c) ctime_r(a,b)
+#endif
+#else
+#define CTIME_R(a,b,c) ctime_r(a,b)
+#endif
+
/* md5.c */
void librad_md5_calc(u_char *, u_char *, u_int);
+/* hmac.c */
+
+void lrad_hmac_md5(const unsigned char *text, int text_len,
+ const unsigned char *key, int key_len,
+ unsigned char *digest);
+
+/* hmacsha1.c */
+
+void lrad_hmac_sha1(const unsigned char *text, int text_len,
+ const unsigned char *key, int key_len,
+ unsigned char *digest);
+
/* radius.c */
-int rad_send(RADIUS_PACKET *, const char *secret);
+int rad_send(RADIUS_PACKET *, const RADIUS_PACKET *, const char *secret);
RADIUS_PACKET *rad_recv(int fd);
int rad_decode(RADIUS_PACKET *packet, RADIUS_PACKET *original, const char *secret);
RADIUS_PACKET *rad_alloc(int newvector);
void rad_free(RADIUS_PACKET **);
int rad_pwencode(char *encpw, int *len, const char *secret, const char *vector);
int rad_pwdecode(char *encpw, int len, const char *secret, const char *vector);
+int rad_tunnel_pwencode(char *encpw, int *len, const char *secret, const char *vector);
+int rad_tunnel_pwdecode(uint8_t *encpw, int *len, const char *secret, const char *vector);
int rad_chap_encode(RADIUS_PACKET *packet, char *output, int id, VALUE_PAIR *password);
-int calc_acctdigest(RADIUS_PACKET *packet, const char *secret,
- char *data, int len);
/* valuepair.c */
VALUE_PAIR *paircreate(int attr, int type);
void pairfree(VALUE_PAIR **);
+void pairbasicfree(VALUE_PAIR *pair);
VALUE_PAIR *pairfind(VALUE_PAIR *, int);
void pairdelete(VALUE_PAIR **, int);
void pairadd(VALUE_PAIR **, VALUE_PAIR *);
+void pairreplace(VALUE_PAIR **first, VALUE_PAIR *add);
VALUE_PAIR *paircopy(VALUE_PAIR *vp);
VALUE_PAIR *paircopy2(VALUE_PAIR *vp, int attr);
void pairmove(VALUE_PAIR **to, VALUE_PAIR **from);
void pairmove2(VALUE_PAIR **to, VALUE_PAIR **from, int attr);
+VALUE_PAIR *pairparsevalue(VALUE_PAIR *vp, const char *value);
VALUE_PAIR *pairmake(const char *attribute, const char *value, int operator);
-VALUE_PAIR *pairread(char **ptr, int *eol);
-int userparse(char *buffer, VALUE_PAIR **first_pair);
+VALUE_PAIR *pairread(char **ptr, LRAD_TOKEN *eol);
+LRAD_TOKEN userparse(char *buffer, VALUE_PAIR **first_pair);
+VALUE_PAIR *readvp2(FILE *fp, int *pfiledone, const char *errprefix);
/*
* Error functions.
#endif
;
extern char librad_errstr[];
-extern int librad_dodns;
-extern int librad_debug;
+extern int librad_dodns; /* 0 = no dns lookups */
+extern int librad_debug; /* 0 = no debugging information */
+extern int librad_max_attributes; /* per incoming packet */
/*
* Several handy miscellaneous functions.
*/
char * ip_hostname (char *buf, size_t buflen, uint32_t ipaddr);
uint32_t ip_getaddr (const char *);
-char * ip_ntoa(char *, uint32_t);
+const char * ip_ntoa(char *, uint32_t);
uint32_t ip_addr(const char *);
+char *ifid_ntoa(char *buffer, size_t size, uint8_t *ifid);
+uint8_t *ifid_aton(const char *ifid_str, uint8_t *ifid);
+const char *ipv6_ntoa(char *buffer, size_t size, void *ip6addr);
+int ipv6_addr(const char *ip6_str, void *ip6addr);
char *strNcpy(char *dest, const char *src, int n);
void rad_lowercase(char *str);
void rad_rmspace(char *str);
+int rad_lockfd(int fd, int lock_len);
+int rad_lockfd_nonblock(int fd, int lock_len);
+int rad_unlockfd(int fd, int lock_len);
#ifdef ASCEND_BINARY
/* filters.c */
-int filterBinary(VALUE_PAIR *pair, const char *valstr);
+int ascend_parse_filter(VALUE_PAIR *pair);
void print_abinary(VALUE_PAIR *vp, u_char *buffer, int len);
#endif /*ASCEND_BINARY*/
+#ifndef HAVE_SNPRINTF
+#define HAVE_LOCAL_SNPRINTF
+#define snprintf lrad_snprintf
+#endif
+
+#ifndef HAVE_VSNPRINTF
+#define HAVE_LOCAL_SNPRINTF
+#define vsnprintf lrad_vsnprintf
+#endif
+
#ifdef HAVE_LOCAL_SNPRINTF
+#include <stdarg.h>
int snprintf(char *str, size_t count, const char *fmt, ...);
int vsnprintf(char *str, size_t count, const char *fmt, va_list arg);
#endif
+/* random numbers in isaac.c */
+/* context of random number generator */
+typedef struct lrad_randctx {
+ uint32_t randcnt;
+ uint32_t randrsl[256];
+ uint32_t randmem[256];
+ uint32_t randa;
+ uint32_t randb;
+ uint32_t randc;
+} lrad_randctx;
+
+void lrad_isaac(lrad_randctx *ctx);
+void lrad_randinit(lrad_randctx *ctx, int flag);
+uint32_t lrad_rand(void); /* like rand(), but better. */
+
+/* crypt wrapper from crypt.c */
+int lrad_crypt_check(const char *key, const char *salt);
+
+/* rbtree.c */
+typedef struct rbtree_t rbtree_t;
+typedef struct rbnode_t rbnode_t;
+
+rbtree_t *rbtree_create(int (*Compare)(const void *, const void *),
+ void (*freeNode)(void *),
+ int replace_flag);
+void rbtree_free(rbtree_t *tree);
+int rbtree_insert(rbtree_t *tree, const void *Data);
+void rbtree_delete(rbtree_t *tree, rbnode_t *Z);
+int rbtree_deletebydata(rbtree_t *tree, const void *data);
+rbnode_t *rbtree_find(rbtree_t *tree, const void *Data);
+void *rbtree_finddata(rbtree_t *tree, const void *Data);
+int rbtree_num_elements(rbtree_t *tree);
+void *rbtree_node2data(rbtree_t *tree, rbnode_t *node);
+
+/* callback order for walking */
+typedef enum { PreOrder, InOrder, PostOrder } RBTREE_ORDER;
+
+/*
+ * The callback should be declared as:
+ * int callback(void *context, void *data)
+ *
+ * The "context" is some user-defined context.
+ * The "data" is the pointer to the user data in the node,
+ * NOT the node itself.
+ *
+ * It should return 0 if all is OK, and !0 for any error.
+ * The walking will stop on any error.
+ */
+int rbtree_walk(rbtree_t *tree, RBTREE_ORDER order, int (*callback)(void *, void *), void *context);
+
#endif /*LIBRADIUS_H*/
projects / freeradius.git / blobdiff