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,
254
int rad_sign(RADIUS_PACKET *packet, const RADIUS_PACKET *original,
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);
303
315
#ifdef ASCEND_BINARY
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 */
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);
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);
367
int rbtree_walk(rbtree_t *tree, RBTREE_ORDER order, int (*callback)(void *, void *), void *context);
370
* Fast hash, which isn't too bad. Don't use for cryptography,
371
* just for hashing internal data.
373
uint32_t lrad_hash(const void *, size_t);
374
uint32_t lrad_hash_update(const void *data, size_t size, uint32_t hash);
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.
381
uint32_t lrad_hash_fold(uint32_t hash, int bits);
383
typedef struct lrad_hash_table_t lrad_hash_table_t;
385
lrad_hash_table_t *lrad_hash_table_create(int size, void (*freeNode)(void *),
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,
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 */,
397
int lrad_hash_table_set_data_size(lrad_hash_table_t *ht,
355
399
#endif /*LIBRADIUS_H*/