lib/include/radsec/radsec.h

   1 /** \file radsec.h
   2     \brief Public interface for libradsec.  */
   3
   4 /* See LICENSE for licensing information.  */
   5
   6 #ifndef _RADSEC_RADSEC_H_
   7 #define _RADSEC_RADSEC_H_ 1
   8
   9 #ifdef HAVE_CONFIG_H
  10 #include <config.h>
  11 #endif
  12 #ifdef HAVE_SYS_TIME_H
  13 #include <sys/time.h>
  14 #endif
  15 #ifdef HAVE_ARPA_INET_H
  16 #include <arpa/inet.h>
  17 #endif
  18 #ifdef HAVE_UNISTD_H
  19 #include <unistd.h>
  20 #endif
  21 #ifdef HAVE_STDINT_H
  22 #include <stdint.h>
  23 #endif
  24
  25 enum rs_error_code {
  26     RSE_OK = 0,
  27     RSE_NOMEM = 1,
  28     RSE_NOSYS = 2,
  29     RSE_INVALID_CTX = 3,
  30     RSE_INVALID_CONN = 4,
  31     RSE_CONN_TYPE_MISMATCH = 5,
  32     RSE_BADADDR = 7,
  33     RSE_NOPEER = 8,
  34     RSE_EVENT = 9,              /* libevent error.  */
  35     RSE_SOCKERR = 10,
  36     RSE_CONFIG = 11,
  37     RSE_BADAUTH = 12,
  38     RSE_INTERNAL = 13,
  39     RSE_SSLERR = 14,            /* OpenSSL error.  */
  40     RSE_INVALID_PKT = 15,
  41     RSE_TIMEOUT_CONN = 16,      /* Connection timeout.  */
  42     RSE_INVAL = 17,             /* Invalid argument.  */
  43     RSE_TIMEOUT_IO = 18,        /* I/O timeout.  */
  44     RSE_TIMEOUT = 19,           /* High level timeout.  */
  45     RSE_DISCO = 20,
  46     RSE_INUSE = 21,
  47     RSE_PACKET_TOO_SMALL = 22,
  48     RSE_PACKET_TOO_LARGE = 23,
  49     RSE_ATTR_OVERFLOW = 24,
  50     RSE_ATTR_TOO_SMALL = 25,
  51     RSE_ATTR_TOO_LARGE = 26,
  52     RSE_ATTR_UNKNOWN = 27,
  53     RSE_ATTR_BAD_NAME = 28,
  54     RSE_ATTR_VALUE_MALFORMED = 29,
  55     RSE_ATTR_INVALID = 30,
  56     RSE_TOO_MANY_ATTRS = 31,
  57     RSE_ATTR_TYPE_UNKNOWN = 32,
  58     RSE_MSG_AUTH_LEN = 33,
  59     RSE_MSG_AUTH_WRONG = 34,
  60     RSE_REQUEST_REQUIRED = 35,
  61     RSE_INVALID_REQUEST_CODE = 36,
  62     RSE_AUTH_VECTOR_WRONG = 37,
  63     RSE_INVALID_RESPONSE_CODE = 38,
  64     RSE_INVALID_RESPONSE_ID = 39,
  65     RSE_INVALID_RESPONSE_SRC = 40,
  66     RSE_NO_PACKET_DATA = 41,
  67     RSE_VENDOR_UNKNOWN = 42,
  68     RSE_CRED = 43,
  69     RSE_CERT = 44,
  70 };
  71
  72 enum rs_conn_type {
  73     RS_CONN_TYPE_NONE = 0,
  74     RS_CONN_TYPE_UDP,
  75     RS_CONN_TYPE_TCP,
  76     RS_CONN_TYPE_TLS,
  77     RS_CONN_TYPE_DTLS,
  78 };
  79 typedef unsigned int rs_conn_type_t;
  80
  81 typedef enum rs_attr_type_t {
  82     RS_TYPE_INVALID = 0,                /**< Invalid data type */
  83     RS_TYPE_STRING,                     /**< printable-text */
  84     RS_TYPE_INTEGER,                    /**< a 32-bit unsigned integer */
  85     RS_TYPE_IPADDR,                     /**< an IPv4 address */
  86     RS_TYPE_DATE,                       /**< a 32-bit date, of seconds since January 1, 1970 */
  87     RS_TYPE_OCTETS,                     /**< a sequence of binary octets */
  88     RS_TYPE_IFID,                       /**< an Interface Id */
  89     RS_TYPE_IPV6ADDR,                   /**< an IPv6 address */
  90     RS_TYPE_IPV6PREFIX,                 /**< an IPv6 prefix */
  91     RS_TYPE_BYTE,                       /**< an 8-bit integer */
  92     RS_TYPE_SHORT,                      /**< a 16-bit integer */
  93 } rs_attr_type_t;
  94
  95 #define PW_ACCESS_REQUEST               1
  96 #define PW_ACCESS_ACCEPT                2
  97 #define PW_ACCESS_REJECT                3
  98 #define PW_ACCOUNTING_REQUEST           4
  99 #define PW_ACCOUNTING_RESPONSE          5
 100 #define PW_ACCOUNTING_STATUS            6
 101 #define PW_PASSWORD_REQUEST             7
 102 #define PW_PASSWORD_ACK                 8
 103 #define PW_PASSWORD_REJECT              9
 104 #define PW_ACCOUNTING_MESSAGE           10
 105 #define PW_ACCESS_CHALLENGE             11
 106 #define PW_STATUS_SERVER                12
 107 #define PW_STATUS_CLIENT                13
 108 #define PW_DISCONNECT_REQUEST           40
 109 #define PW_DISCONNECT_ACK               41
 110 #define PW_DISCONNECT_NAK               42
 111 #define PW_COA_REQUEST                  43
 112 #define PW_COA_ACK                      44
 113 #define PW_COA_NAK                      45
 114
 115 #if defined (__cplusplus)
 116 extern "C" {
 117 #endif
 118
 119 /* Data types.  */
 120 struct rs_context;              /* radsec-impl.h */
 121 struct rs_connection;           /* radsec-impl.h */
 122 struct rs_packet;               /* radsec-impl.h */
 123 struct rs_conn;                 /* radsec-impl.h */
 124 struct rs_error;                /* radsec-impl.h */
 125 struct rs_peer;                 /* radsec-impl.h */
 126 struct radius_packet;           /* <radius/client.h> */
 127 struct value_pair;              /* <radius/client.h> */
 128 struct event_base;              /* <event2/event-internal.h> */
 129
 130 typedef void *(*rs_calloc_fp) (size_t nmemb, size_t size);
 131 typedef void *(*rs_malloc_fp) (size_t size);
 132 typedef void (*rs_free_fp) (void *ptr);
 133 typedef void *(*rs_realloc_fp) (void *ptr, size_t size);
 134 struct rs_alloc_scheme {
 135     rs_calloc_fp calloc;
 136     rs_malloc_fp malloc;
 137     rs_free_fp free;
 138     rs_realloc_fp realloc;
 139 };
 140
 141 typedef void (*rs_conn_connected_cb) (void *user_data /* FIXME: peer? */ );
 142 typedef void (*rs_conn_disconnected_cb) (void *user_data /* FIXME: reason? */ );
 143 typedef void (*rs_conn_packet_received_cb) (struct rs_packet *packet,
 144                                             void *user_data);
 145 typedef void (*rs_conn_packet_sent_cb) (void *user_data);
 146 struct rs_conn_callbacks {
 147     /** Callback invoked when the connection has been established.  */
 148     rs_conn_connected_cb connected_cb;
 149     /** Callback invoked when the connection has been torn down.  */
 150     rs_conn_disconnected_cb disconnected_cb;
 151     /** Callback invoked when a packet was received.  */
 152     rs_conn_packet_received_cb received_cb;
 153     /** Callback invoked when a packet was successfully sent.  */
 154     rs_conn_packet_sent_cb sent_cb;
 155 };
 156
 157 typedef struct value_pair rs_avp;
 158 typedef const struct value_pair rs_const_avp;
 159
 160 /* Function prototypes.  */
 161
 162 /*************/
 163 /* Context.  */
 164 /*************/
 165 /** Create a context.  Freed by calling \a rs_context_destroy.  Note
 166     that the context must not be freed before all other libradsec
 167     objects have been freed.
 168
 169     \a ctx Address of pointer to a struct rs_context.  This is the
 170     output of this function.
 171
 172     \return RSE_OK (0) on success or RSE_NOMEM on out of memory.  */
 173 int rs_context_create(struct rs_context **ctx);
 174
 175 /** Free a context.  Note that the context must not be freed before
 176     all other libradsec objects have been freed.  */
 177 void rs_context_destroy(struct rs_context *ctx);
 178
 179 /** Set allocation scheme to use.  \a scheme is the allocation scheme
 180     to use, see \a rs_alloc_scheme.  \return On success, RSE_OK (0) is
 181     returned.  On error, !0 is returned and a struct \a rs_error is
 182     pushed on the error stack for the context.  The error can be
 183     accessed using \a rs_err_ctx_pop.  */
 184 int rs_context_set_alloc_scheme(struct rs_context *ctx,
 185                                 struct rs_alloc_scheme *scheme);
 186
 187 /** Read configuration file. \a config_file is the path of the
 188     configuration file to read.  \return On success, RSE_OK (0) is
 189     returned.  On error, !0 is returned and a struct \a rs_error is
 190     pushed on the error stack for the context.  The error can be
 191     accessed using \a rs_err_ctx_pop.  */
 192 int rs_context_read_config(struct rs_context *ctx, const char *config_file);
 193
 194 /****************/
 195 /* Connection.  */
 196 /****************/
 197 /** Create a connection.  \a conn is the address of a pointer to an \a
 198     rs_connection, the output.  Free the connection using \a
 199     rs_conn_destroy.  Note that a connection must not be freed before
 200     all packets associated with the connection have been freed.  A
 201     packet is associated with a connection when it's created (\a
 202     rs_packet_create) or received (\a rs_conn_receive_packet).
 203
 204     If \a config is not NULL it should be the name of a configuration
 205     found in the config file read in using \a rs_context_read_config.
 206     \return On success, RSE_OK (0) is returned.  On error, !0 is
 207     returned and a struct \a rs_error is pushed on the error stack for
 208     the context.  The error can be accessed using \a
 209     rs_err_ctx_pop.  */
 210 int rs_conn_create(struct rs_context *ctx,
 211                    struct rs_connection **conn,
 212                    const char *config);
 213
 214 /** Not implemented.  */
 215 int rs_conn_add_listener(struct rs_connection *conn,
 216                          rs_conn_type_t type,
 217                          const char *hostname,
 218                          int port);
 219 /** Disconnect connection \a conn.  \return RSE_OK (0) on success, !0
 220  * on error.  On error, errno is set appropriately.  */
 221 int rs_conn_disconnect (struct rs_connection *conn);
 222
 223 /** Disconnect and free memory allocated for connection \a conn.  Note
 224     that a connection must not be freed before all packets associated
 225     with the connection have been freed.  A packet is associated with
 226     a connection when it's created (\a rs_packet_create) or received
 227     (\a rs_conn_receive_packet).  \return RSE_OK (0) on success, !0 *
 228     on error.  On error, errno is set appropriately. */
 229 int rs_conn_destroy(struct rs_connection *conn);
 230
 231 /** Set connection type for \a conn.  */
 232 void rs_conn_set_type(struct rs_connection *conn, rs_conn_type_t type);
 233
 234 /** Not implemented.  */
 235 int rs_conn_set_eventbase(struct rs_connection *conn, struct event_base *eb);
 236
 237 /** Register callbacks \a cb for connection \a conn.  */
 238 void rs_conn_set_callbacks(struct rs_connection *conn,
 239                            struct rs_conn_callbacks *cb);
 240
 241 /** Remove callbacks for connection \a conn.  */
 242 void rs_conn_del_callbacks(struct rs_connection *conn);
 243
 244 /** Return callbacks registered for connection \a conn.  \return
 245     Installed callbacks are returned.  */
 246 struct rs_conn_callbacks *rs_conn_get_callbacks(struct rs_connection *conn);
 247
 248 /** Not implemented.  */
 249 int rs_conn_select_peer(struct rs_connection *conn, const char *name);
 250
 251 /** Not implemented.  */
 252 int rs_conn_get_current_peer(struct rs_connection *conn,
 253                              const char *name,
 254                              size_t buflen);
 255
 256 /** Special function used in blocking mode, i.e. with no callbacks
 257     registered.  For any other use of libradsec, a \a received_cb
 258     callback should be registered using \a rs_conn_set_callbacks.
 259
 260     If \a req_msg is not NULL, a successfully received RADIUS message
 261     is verified against it.  If \a pkt_out is not NULL it will upon
 262     return contain a pointer to an \a rs_packet containing the new
 263     message.
 264
 265     \return On error or if the connect (TCP only) or read times out,
 266     \a pkt_out will not be changed and one or more errors are pushed
 267     on \a conn (available through \a rs_err_conn_pop).  */
 268 int rs_conn_receive_packet(struct rs_connection *conn,
 269                            struct rs_packet *request,
 270                            struct rs_packet **pkt_out);
 271
 272 /** Get the file descriptor associated with connection \a conn.
 273  * \return File descriptor.  */
 274 int rs_conn_fd(struct rs_connection *conn);
 275
 276 /** Set the timeout value for connection \a conn.  */
 277 void rs_conn_set_timeout(struct rs_connection *conn, struct timeval *tv);
 278
 279 /* Peer -- client and server.  */
 280 int rs_peer_create(struct rs_connection *conn, struct rs_peer **peer_out);
 281 int rs_peer_set_address(struct rs_peer *peer,
 282                         const char *hostname,
 283                         const char *service);
 284 int rs_peer_set_secret(struct rs_peer *peer, const char *secret);
 285 void rs_peer_set_timeout(struct rs_peer *peer, int timeout);
 286 void rs_peer_set_retries(struct rs_peer *peer, int retries);
 287
 288 /************/
 289 /* Packet.  */
 290 /************/
 291 /** Create a packet associated with connection \a conn.  */
 292 int rs_packet_create(struct rs_connection *conn, struct rs_packet **pkt_out);
 293
 294 /** Free all memory allocated for packet \a pkt.  */
 295 void rs_packet_destroy(struct rs_packet *pkt);
 296
 297 /** Send packet \a pkt on the connection associated with \a pkt.
 298     \a user_data is passed to the \a rs_conn_packet_received_cb callback
 299     registered with the connection. If no callback is registered with
 300     the connection, the event loop is run by \a rs_packet_send and it
 301     blocks until the full packet has been sent. Note that sending can
 302     fail in several ways, f.ex. if the transmission protocol in use
 303     is connection oriented (\a RS_CONN_TYPE_TCP and \a RS_CONN_TYPE_TLS)
 304     and the connection can not be established. Also note that no
 305     retransmission is done, something that is required for connectionless
 306     transport protocols (\a RS_CONN_TYPE_UDP and \a RS_CONN_TYPE_DTLS).
 307     The "request" API with \a rs_request_send can help with this.
 308
 309     \return On success, RSE_OK (0) is returned. On error, !0 is
 310     returned and a struct \a rs_error is pushed on the error stack for
 311     the connection. The error can be accessed using \a rs_err_conn_pop. */
 312 int rs_packet_send(struct rs_packet *pkt, void *user_data);
 313
 314 /** Create a RADIUS authentication request packet associated with
 315     connection \a conn.  Optionally, User-Name and User-Password
 316     attributes are added to the packet using the data in \a user_name
 317     and \a user_pw.  */
 318 int rs_packet_create_authn_request(struct rs_connection *conn,
 319                                    struct rs_packet **pkt,
 320                                    const char *user_name,
 321                                    const char *user_pw);
 322
 323 /*** Append \a tail to packet \a pkt.  */
 324 int
 325 rs_packet_append_avp(struct rs_packet *pkt,
 326                      unsigned int attribute, unsigned int vendor,
 327                      const void *data, size_t data_len);
 328
 329 /*** Get pointer to \a pkt attribute value pairs. */
 330 void
 331 rs_packet_avps(struct rs_packet *pkt, rs_avp ***vps);
 332
 333 /*** Get RADIUS packet type of \a pkt. */
 334 unsigned int
 335 rs_packet_code(struct rs_packet *pkt);
 336
 337 /*** Get RADIUS AVP from \a pkt. */
 338 rs_const_avp *
 339 rs_packet_find_avp(struct rs_packet *pkt, unsigned int attr, unsigned int vendor);
 340
 341 /*** Set packet identifier in \a pkt; returns old identifier */
 342 int
 343 rs_packet_set_id (struct rs_packet *pkt, int id);
 344
 345 /************/
 346 /* Config.  */
 347 /************/
 348 /** Find the realm named \a name in the configuration file previoiusly
 349     read in using \a rs_context_read_config.  */
 350 struct rs_realm *rs_conf_find_realm(struct rs_context *ctx, const char *name);
 351
 352 /***********/
 353 /* Error.  */
 354 /***********/
 355 /** Create a struct \a rs_error and push it on a FIFO associated with
 356     context \a ctx.  Note: The depth of the error stack is one (1) at
 357     the moment.  This will change in a future release.  */
 358 int rs_err_ctx_push(struct rs_context *ctx, int code, const char *fmt, ...);
 359 int rs_err_ctx_push_fl(struct rs_context *ctx,
 360                        int code,
 361                        const char *file,
 362                        int line,
 363                        const char *fmt,
 364                        ...);
 365 /** Pop the first error from the error FIFO associated with context \a
 366     ctx or NULL if there are no errors in the FIFO.  */
 367 struct rs_error *rs_err_ctx_pop(struct rs_context *ctx);
 368
 369 /** Create a struct \a rs_error and push it on a FIFO associated with
 370     connection \a conn.  Note: The depth of the error stack is one (1)
 371     at the moment.  This will change in a future release.  */
 372 int rs_err_conn_push(struct rs_connection *conn,
 373                      int code,
 374                      const char *fmt,
 375                      ...);
 376 int rs_err_conn_push_fl(struct rs_connection *conn,
 377                         int code,
 378                         const char *file,
 379                         int line,
 380                         const char *fmt,
 381                         ...);
 382 /** Pop the first error from the error FIFO associated with connection
 383     \a conn or NULL if there are no errors in the FIFO.  */
 384 struct rs_error *rs_err_conn_pop(struct rs_connection *conn);
 385
 386 int rs_err_conn_peek_code (struct rs_connection *conn);
 387 void rs_err_free(struct rs_error *err);
 388 char *rs_err_msg(struct rs_error *err);
 389 int rs_err_code(struct rs_error *err, int dofree_flag);
 390
 391 /************/
 392 /* AVPs.    */
 393 /************/
 394 #define rs_avp_is_string(vp)      (rs_avp_typeof(vp) == RS_TYPE_STRING)
 395 #define rs_avp_is_integer(vp)     (rs_avp_typeof(vp) == RS_TYPE_INTEGER)
 396 #define rs_avp_is_ipaddr(vp)      (rs_avp_typeof(vp) == RS_TYPE_IPADDR)
 397 #define rs_avp_is_date(vp)        (rs_avp_typeof(vp) == RS_TYPE_DATE)
 398 #define rs_avp_is_octets(vp)      (rs_avp_typeof(vp) == RS_TYPE_OCTETS)
 399 #define rs_avp_is_ifid(vp)        (rs_avp_typeof(vp) == RS_TYPE_IFID)
 400 #define rs_avp_is_ipv6addr(vp)    (rs_avp_typeof(vp) == RS_TYPE_IPV6ADDR)
 401 #define rs_avp_is_ipv6prefix(vp)  (rs_avp_typeof(vp) == RS_TYPE_IPV6PREFIX)
 402 #define rs_avp_is_byte(vp)        (rs_avp_typeof(vp) == RS_TYPE_BYTE)
 403 #define rs_avp_is_short(vp)       (rs_avp_typeof(vp) == RS_TYPE_SHORT)
 404 #define rs_avp_is_tlv(vp)         (rs_avp_typeof(vp) == RS_TYPE_TLV)
 405
 406 /**  The maximum length of a RADIUS attribute.
 407  *
 408  *  The RFCs require that a RADIUS attribute transport no more than
 409  *  253 octets of data.  We add an extra byte for a trailing NUL, so
 410  *  that the VALUE_PAIR::vp_strvalue field can be handled as a C
 411  *  string.
 412  */
 413 #define RS_MAX_STRING_LEN         254
 414
 415 /** Free the AVP list \a vps */
 416 void
 417 rs_avp_free(rs_avp **vps);
 418
 419 /** Return the length of AVP \a vp in bytes */
 420 size_t
 421 rs_avp_length(rs_const_avp *vp);
 422
 423 /** Return the type of \a vp */
 424 rs_attr_type_t
 425 rs_avp_typeof(rs_const_avp *vp);
 426
 427 /** Retrieve the attribute and vendor ID of \a vp */
 428 void
 429 rs_avp_attrid(rs_const_avp *vp, unsigned int *attr, unsigned int *vendor);
 430
 431 /** Add \a vp to the list pointed to by \a head */
 432 void
 433 rs_avp_append(rs_avp **head, rs_avp *vp);
 434
 435 /** Find an AVP in \a vp that matches \a attr and \a vendor */
 436 rs_avp *
 437 rs_avp_find(rs_avp *vp, unsigned int attr, unsigned int vendor);
 438
 439 /** Find an AVP in \a vp that matches \a attr and \a vendor */
 440 rs_const_avp *
 441 rs_avp_find_const(rs_const_avp *vp, unsigned int attr, unsigned int vendor);
 442
 443 /** Alloc a new AVP for \a attr and \a vendor */
 444 rs_avp *
 445 rs_avp_alloc(unsigned int attr, unsigned int vendor);
 446
 447 /** Duplicate existing AVP \a vp */
 448 rs_avp *
 449 rs_avp_dup(rs_const_avp *vp);
 450
 451 /** Remove matching AVP from list \a vps */
 452 int
 453 rs_avp_delete(rs_avp **vps, unsigned int attr, unsigned int vendor);
 454
 455 /** Return next AVP in list */
 456 rs_avp *
 457 rs_avp_next(rs_avp *vp);
 458
 459 /** Return next AVP in list */
 460 rs_const_avp *
 461 rs_avp_next_const(rs_const_avp *avp);
 462
 463 /** Return string value of \a vp */
 464 const char *
 465 rs_avp_string_value(rs_const_avp *vp);
 466
 467 /** Set AVP \a vp to string \a str */
 468 int
 469 rs_avp_string_set(rs_avp *vp, const char *str);
 470
 471 /** Return integer value of \a vp */
 472 uint32_t
 473 rs_avp_integer_value(rs_const_avp *vp);
 474
 475 /** Set AVP \a vp to integer \a val */
 476 int
 477 rs_avp_integer_set(rs_avp *vp, uint32_t val);
 478
 479 /** Return IPv4 value of \a vp */
 480 uint32_t
 481 rs_avp_ipaddr_value(rs_const_avp *vp);
 482
 483 /** Set AVP \a vp to IPv4 address \a in */
 484 int
 485 rs_avp_ipaddr_set(rs_avp *vp, struct in_addr in);
 486
 487 /** Return POSIX time value of \a vp */
 488 time_t
 489 rs_avp_date_value(rs_const_avp *vp);
 490
 491 /** Set AVP \a vp to POSIX time \a date */
 492 int
 493 rs_avp_date_set(rs_avp *vp, time_t date);
 494
 495 /** Return constant pointer to octets in \a vp */
 496 const unsigned char *
 497 rs_avp_octets_value_const_ptr(rs_const_avp *vp);
 498
 499 /** Return pointer to octets in \a vp */
 500 unsigned char *
 501 rs_avp_octets_value_ptr(rs_avp *vp);
 502
 503 /** Retrieve octet pointer \a p and length \a len from \a vp */
 504 int
 505 rs_avp_octets_value_byref(rs_avp *vp,
 506                           unsigned char **p,
 507                           size_t *len);
 508
 509 /** Copy octets from \a vp into \a buf and \a len */
 510 int
 511 rs_avp_octets_value(rs_const_avp *vp,
 512                     unsigned char *buf,
 513                     size_t *len);
 514
 515 /**
 516  * Copy octets possibly fragmented across multiple VPs
 517  * into \a buf and \a len
 518  */
 519 int
 520 rs_avp_fragmented_value(rs_const_avp *vps,
 521                         unsigned char *buf,
 522                         size_t *len);
 523
 524 /** Copy \a len octets in \a buf to AVP \a vp */
 525 int
 526 rs_avp_octets_set(rs_avp *vp,
 527                   const unsigned char *buf,
 528                   size_t len);
 529
 530 /** Return IFID value of \a vp */
 531 int
 532 rs_avp_ifid_value(rs_const_avp *vp, uint8_t val[8]);
 533
 534 int
 535 rs_avp_ifid_set(rs_avp *vp, const uint8_t val[8]);
 536
 537 /** Return byte value of \a vp */
 538 uint8_t
 539 rs_avp_byte_value(rs_const_avp *vp);
 540
 541 /** Set AVP \a vp to byte \a val */
 542 int
 543 rs_avp_byte_set(rs_avp *vp, uint8_t val);
 544
 545 /** Return short value of \a vp */
 546 uint16_t
 547 rs_avp_short_value(rs_const_avp *vp);
 548
 549 /** Set AVP \a vp to short integer \a val */
 550 int
 551 rs_avp_short_set(rs_avp *vp, uint16_t val);
 552
 553 /** Display possibly \a canonical attribute name into \a buffer */
 554 int
 555 rs_attr_display_name (unsigned int attr,
 556                       unsigned int vendor,
 557                       char *buffer,
 558                       size_t bufsize,
 559                       int canonical);
 560
 561 /** Display AVP \a vp into \a buffer */
 562 size_t
 563 rs_avp_display_value(rs_const_avp *vp,
 564                      char *buffer,
 565                      size_t buflen);
 566
 567 int
 568 rs_attr_parse_name (const char *name,
 569                     unsigned int *attr,
 570                     unsigned int *vendor);
 571
 572 /** Lookup attribute \a name */
 573 int
 574 rs_attr_find(const char *name,
 575              unsigned int *attr,
 576              unsigned int *vendor);
 577
 578 /** Return dictionary name for AVP \a vp */
 579 const char *
 580 rs_avp_name(rs_const_avp *vp);
 581
 582 #if defined (__cplusplus)
 583 }
 584 #endif
 585
 586 #endif /* _RADSEC_RADSEC_H_ */
 587
 588 /* Local Variables: */
 589 /* c-file-style: "stroustrup" */
 590 /* End: */