lib/radsec.c

   1 /* See the file COPYING for licensing information.  */
   2
   3 #if defined HAVE_CONFIG_H
   4 #include <config.h>
   5 #endif
   6
   7 #include <stdio.h>
   8 #include <stdlib.h>
   9 #include <stdint.h>
  10 #include <string.h>
  11 #include <libgen.h>
  12 #include <assert.h>
  13
  14 #include <freeradius/libradius.h>
  15 #include <event2/event.h>
  16 #include <event2/util.h>
  17 #include <radsec/radsec.h>
  18 #include <radsec/radsec-impl.h>
  19 #if defined RS_ENABLE_TLS
  20 #include <regex.h>
  21 #include "rsp_list.h"
  22 #include "../radsecproxy.h"
  23 #endif
  24 #include "rsp_debug.h"
  25
  26 int
  27 rs_context_create(struct rs_context **ctx, const char *dict)
  28 {
  29   struct rs_context *h;
  30
  31   if (ctx)
  32     *ctx = NULL;
  33   h = (struct rs_context *) malloc (sizeof(struct rs_context));
  34   if (h)
  35     {
  36       char *buf1 = NULL, *buf2 = NULL;
  37       char *dir, *fn;
  38
  39       buf1 = malloc (strlen (dict) + 1);
  40       buf2 = malloc (strlen (dict) + 1);
  41       if (!buf1 || !buf2)
  42         {
  43           free (h);
  44           if (buf1)
  45             free (buf1);
  46           if (buf2)
  47             free (buf2);
  48           return RSE_NOMEM;
  49         }
  50       strcpy (buf1, dict);
  51       dir = dirname (buf1);
  52       strcpy (buf2, dict);
  53       fn = basename (buf2);
  54       if (dict_init (dir, fn) < 0)
  55         {
  56           free (h);
  57           return RSE_SOME_ERROR;
  58         }
  59       free (buf1);
  60       free (buf2);
  61 #if defined RS_ENABLE_TLS
  62       ssl_init ();
  63 #endif
  64 #if defined (DEBUG)
  65       fr_log_fp = stderr;
  66       fr_debug_flag = 1;
  67 #endif
  68       debug_init ("libradsec"); /* radsecproxy compat, FIXME: remove */
  69
  70       memset (h, 0, sizeof(struct rs_context));
  71       fr_randinit (&h->fr_randctx, 0);
  72       fr_rand_seed (NULL, 0);
  73
  74       if (ctx)
  75         *ctx = h;
  76     }
  77   return h ? RSE_OK : RSE_NOMEM;
  78 }
  79
  80 void rs_context_destroy(struct rs_context *ctx)
  81 {
  82   free (ctx);
  83 }
  84
  85 int rs_context_set_alloc_scheme(struct rs_context *ctx,
  86                                 struct rs_alloc_scheme *scheme)
  87 {
  88   return rs_err_ctx_push_fl (ctx, RSE_NOSYS, __FILE__, __LINE__,
  89                              "%s: NYI", __func__);
  90 }
  91
  92
  93 struct rs_peer *
  94 _rs_peer_create (struct rs_context *ctx, struct rs_peer **rootp)
  95 {
  96   struct rs_peer *p;
  97
  98   p = (struct rs_peer *) rs_malloc (ctx, sizeof(*p));
  99   if (p)
 100     {
 101       memset (p, 0, sizeof(struct rs_peer));
 102       p->fd = -1;
 103       if (*rootp)
 104         (*rootp)->next = p;
 105       else
 106         *rootp = p;
 107     }
 108   return p;
 109 }
 110
 111 int
 112 rs_server_create (struct rs_connection *conn, struct rs_peer **server)
 113 {
 114   struct rs_peer *srv;
 115
 116   srv = _rs_peer_create (conn->ctx, &conn->peers);
 117   if (srv)
 118     {
 119       srv->conn = conn;
 120       srv->timeout = 1;
 121       srv->tries = 3;
 122     }
 123   else
 124     return rs_err_conn_push_fl (conn, RSE_NOMEM, __FILE__, __LINE__, NULL);
 125   if (*server)
 126     *server = srv;
 127   return RSE_OK;
 128 }
 129
 130 int
 131 rs_server_set_address (struct rs_peer *server, const char *hostname,
 132                        const char *service)
 133 {
 134   struct rs_error *err;
 135
 136   err = _rs_resolv (&server->addr, server->conn->type, hostname, service);
 137   if (err)
 138     return _rs_err_conn_push_err (server->conn, err);
 139   return RSE_OK;
 140 }
 141
 142 void
 143 rs_server_set_timeout (struct rs_peer *server, int timeout)
 144 {
 145   server->timeout = timeout;
 146 }
 147 void
 148 rs_server_set_tries (struct rs_peer *server, int tries)
 149 {
 150   server->tries = tries;
 151 }
 152
 153 int
 154 rs_server_set_secret (struct rs_peer *server, const char *secret)
 155 {
 156   if (server->secret)
 157     free (server->secret);
 158   server->secret = (char *) malloc (strlen(secret) + 1);
 159   if (!server->secret)
 160     return rs_err_conn_push (server->conn, RSE_NOMEM, NULL);
 161   strcpy (server->secret, secret);
 162   return RSE_OK;
 163 }
 164