← Back to branch summary

~ubuntu-branches/ubuntu/natty/freeradius/natty-updates

« back to all changes in this revision

Viewing changes to src/include/libradius.h

  • Committer: Bazaar Package Importer
  • Author(s): Paul Hampson
  • Date: 2006-01-15 13:34:13 UTC
  • mto: (3.1.3 dapper) (4.1.3 sid) (1.1.14 upstream)
  • mto: This revision was merged to the branch mainline in revision 4.
  • Revision ID: james.westby@ubuntu.com-20060115133413-zo1dslttvdoalqym
Tags: upstream-1.1.0
Import upstream version 1.1.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/include/libradius.h
5
5
 * libradius.h  Structures and prototypes
6
6
 *              for the radius library.
7
7
 *
8
 
 * Version:     $Id: libradius.h,v 1.76.2.2 2005/09/01 15:55:13 nbk Exp $
 
8
 * Version:     $Id: libradius.h,v 1.76.2.2.2.3 2005/12/12 23:28:29 aland Exp $
9
9
 *
10
10
 */
11
11
 
68
68
#ifdef _LIBRADIUS
69
69
#  define AUTH_HDR_LEN          20
70
70
#  define VENDORPEC_USR         429
 
71
#define VENDORPEC_LUCENT        4846
 
72
#define VENDORPEC_STARENT       8164
71
73
#  define VENDOR(x)             ((x >> 16) & 0xffff)
72
74
#  define DEBUG                 if (librad_debug) printf
73
75
#  define debug_pair(vp)        do { if (librad_debug) { \
119
121
} DICT_ATTR;
120
122
 
121
123
typedef struct dict_value {
122
 
        char                    name[40];
123
124
        int                     attr;
124
125
        int                     value;
 
126
        char                    name[1];
125
127
} DICT_VALUE;
126
128
 
127
129
typedef struct dict_vendor {
128
 
        char                    name[40];
129
130
        int                     vendorpec;
130
 
        struct dict_vendor      *next;
 
131
        int                     type; /* length of type data */
 
132
        int                     length; /* length of length data */
 
133
        char                    name[1];
131
134
} DICT_VENDOR;
132
135
 
133
136
typedef struct value_pair {
182
185
 */
183
186
int             dict_addvendor(const char *name, int value);
184
187
int             dict_addattr(const char *name, int vendor, int type, int value, ATTR_FLAGS flags);
185
 
int             dict_addvalue(const char *namestr, char *attrstr, int value);
 
188
int             dict_addvalue(const char *namestr, const char *attrstr, int value);
186
189
int             dict_init(const char *dir, const char *fn);
187
190
DICT_ATTR       *dict_attrbyvalue(int attr);
188
191
DICT_ATTR       *dict_attrbyname(const char *attr);
243
246
int             rad_tunnel_pwencode(char *encpw, int *len, const char *secret, const char *vector);
244
247
int             rad_tunnel_pwdecode(uint8_t *encpw, int *len, const char *secret, const char *vector);
245
248
int             rad_chap_encode(RADIUS_PACKET *packet, char *output, int id, VALUE_PAIR *password);
 
249
int             rad_vp2attr(const RADIUS_PACKET *packet,
 
250
                            const RADIUS_PACKET *original, const char *secret,
 
251
                            const VALUE_PAIR *vp, uint8_t *ptr);
 
252
int             rad_encode(RADIUS_PACKET *packet, const RADIUS_PACKET *original,
 
253
                           const char *secret);
 
254
int             rad_sign(RADIUS_PACKET *packet, const RADIUS_PACKET *original,
 
255
                         const char *secret);
246
256
 
247
257
/* valuepair.c */
248
258
VALUE_PAIR      *paircreate(int attr, int type);
299
309
int             rad_lockfd(int fd, int lock_len);
300
310
int             rad_lockfd_nonblock(int fd, int lock_len);
301
311
int             rad_unlockfd(int fd, int lock_len);
 
312
void            lrad_bin2hex(const uint8_t *bin, char *hex, int len);
 
313
int             lrad_hex2bin(const char *hex, uint8_t *bin, int len);
302
314
 
303
315
#ifdef ASCEND_BINARY
304
316
/* filters.c */
329
341
void lrad_isaac(lrad_randctx *ctx);
330
342
void lrad_randinit(lrad_randctx *ctx, int flag);
331
343
uint32_t lrad_rand(void);       /* like rand(), but better. */
 
344
void lrad_rand_seed(const void *, size_t ); /* seed the random pool */
332
345
 
333
346
/* crypt wrapper from crypt.c */
334
347
int lrad_crypt_check(const char *key, const char *salt);
341
354
                               void (*freeNode)(void *),
342
355
                               int replace_flag);
343
356
void            rbtree_free(rbtree_t *tree);
344
 
int             rbtree_insert(rbtree_t *tree, const void *Data);
 
357
int             rbtree_insert(rbtree_t *tree, void *Data);
345
358
void            rbtree_delete(rbtree_t *tree, rbnode_t *Z);
346
359
rbnode_t       *rbtree_find(rbtree_t *tree, const void *Data);
347
360
void           *rbtree_finddata(rbtree_t *tree, const void *Data);
348
361
int             rbtree_num_elements(rbtree_t *tree);
349
362
void           *rbtree_node2data(rbtree_t *tree, rbnode_t *node);
 
363
int             rbtree_deletebydata(rbtree_t *tree, const void *data);
350
364
 
351
365
/* callback order for walking  */
352
366
typedef enum { PreOrder, InOrder, PostOrder } RBTREE_ORDER;
353
 
int rbtree_walk(rbtree_t *tree, int (*callback)(void *), RBTREE_ORDER order);
354
 
 
 
367
int rbtree_walk(rbtree_t *tree, RBTREE_ORDER order, int (*callback)(void *, void *), void *context);
 
368
 
 
369
/*
 
370
 *      Fast hash, which isn't too bad.  Don't use for cryptography,
 
371
 *      just for hashing internal data.
 
372
 */
 
373
uint32_t lrad_hash(const void *, size_t);
 
374
uint32_t lrad_hash_update(const void *data, size_t size, uint32_t hash);
 
375
 
 
376
/*
 
377
 *      If you need fewer than 32-bits of hash, use this macro to get
 
378
 *      the number of bits in the hash you need.  The upper bits of the
 
379
 *      hash will be set to zero.
 
380
 */
 
381
uint32_t lrad_hash_fold(uint32_t hash, int bits);
 
382
 
 
383
typedef struct lrad_hash_table_t lrad_hash_table_t;
 
384
 
 
385
lrad_hash_table_t *lrad_hash_table_create(int size, void (*freeNode)(void *),
 
386
                                          int replace_flag);
 
387
void            lrad_hash_table_free(lrad_hash_table_t *ht);
 
388
int             lrad_hash_table_insert(lrad_hash_table_t *ht, uint32_t key,
 
389
                                       void *data);
 
390
int             lrad_hash_table_delete(lrad_hash_table_t *ht, uint32_t key);
 
391
void            *lrad_hash_table_finddata(lrad_hash_table_t *ht, uint32_t key);
 
392
int             lrad_hash_table_num_elements(lrad_hash_table_t *ht);
 
393
int             lrad_hash_table_walk(lrad_hash_table_t *ht,
 
394
                                     int (*callback)(void * /* ctx */,
 
395
                                                     void * /* data */),
 
396
                                     void *context);
 
397
int             lrad_hash_table_set_data_size(lrad_hash_table_t *ht,
 
398
                                              size_t data_size);
355
399
#endif /*LIBRADIUS_H*/