omapip/isclib.c

   1 /*
   2  * Copyright(c) 2009-2010,2013 by Internet Systems Consortium, Inc.("ISC")
   3  *
   4  * Permission to use, copy, modify, and distribute this software for any
   5  * purpose with or without fee is hereby granted, provided that the above
   6  * copyright notice and this permission notice appear in all copies.
   7  *
   8  * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES
   9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  10  * MERCHANTABILITY AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR
  11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
  14  * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  15  *
  16  *   Internet Systems Consortium, Inc.
  17  *   950 Charter Street
  18  *   Redwood City, CA 94063
  19  *   <info@isc.org>
  20  *   http://www.isc.org/
  21  *
  22  */
  23
  24 /*Trying to figure out what we need to define to get things to work.
  25   It looks like we want/need the export library but need the fdwatchcommand
  26   which may be a problem */
  27
  28 #include "dhcpd.h"
  29
  30 #include <sys/time.h>
  31 #include <signal.h>
  32
  33 dhcp_context_t dhcp_gbl_ctx;
  34 int shutdown_signal = 0;
  35
  36 #if defined (NSUPDATE)
  37
  38 /* This routine will open up the /etc/resolv.conf file and
  39  * send any nameservers it finds to the DNS client code.
  40  * It may be moved to be part of the dns client code instead
  41  * of being in the DHCP code
  42  */
  43 isc_result_t
  44 dhcp_dns_client_setservers(void)
  45 {
  46         isc_result_t result;
  47         irs_resconf_t *resconf = NULL;
  48         isc_sockaddrlist_t *nameservers;
  49         isc_sockaddr_t *sa;
  50
  51         result = irs_resconf_load(dhcp_gbl_ctx.mctx, _PATH_RESOLV_CONF,
  52                                   &resconf);
  53         if (result != ISC_R_SUCCESS) {
  54                 log_error("irs_resconf_load failed: %d.", result);
  55                 return (result);
  56         }
  57
  58         nameservers = irs_resconf_getnameservers(resconf);
  59
  60         /* Initialize port numbers */
  61         for (sa = ISC_LIST_HEAD(*nameservers);
  62              sa != NULL;
  63              sa = ISC_LIST_NEXT(sa, link)) {
  64                 switch (sa->type.sa.sa_family) {
  65                 case AF_INET:
  66                         sa->type.sin.sin_port = htons(NS_DEFAULTPORT);
  67                         break;
  68                 case AF_INET6:
  69                         sa->type.sin6.sin6_port = htons(NS_DEFAULTPORT);
  70                         break;
  71                 default:
  72                         break;
  73                 }
  74         }
  75
  76         result = dns_client_setservers(dhcp_gbl_ctx.dnsclient,
  77                                        dns_rdataclass_in,
  78                                        NULL, nameservers);
  79         if (result != ISC_R_SUCCESS) {
  80                 log_error("dns_client_setservers failed: %d.",
  81                           result);
  82         }
  83         return (result);
  84 }
  85 #endif
  86
  87 void
  88 isclib_cleanup(void)
  89 {
  90 #if defined (NSUPDATE)
  91         if (dhcp_gbl_ctx.dnsclient != NULL)
  92                 dns_client_destroy((dns_client_t **)&dhcp_gbl_ctx.dnsclient);
  93 #endif
  94
  95         if (dhcp_gbl_ctx.task != NULL) {
  96                 isc_task_shutdown(dhcp_gbl_ctx.task);
  97                 isc_task_detach(&dhcp_gbl_ctx.task);
  98         }
  99
 100         if (dhcp_gbl_ctx.timermgr != NULL)
 101                 isc_timermgr_destroy(&dhcp_gbl_ctx.timermgr);
 102
 103         if (dhcp_gbl_ctx.socketmgr != NULL)
 104                 isc_socketmgr_destroy(&dhcp_gbl_ctx.socketmgr);
 105
 106         if (dhcp_gbl_ctx.taskmgr != NULL)
 107                 isc_taskmgr_destroy(&dhcp_gbl_ctx.taskmgr);
 108
 109         if (dhcp_gbl_ctx.actx_started != ISC_FALSE) {
 110                 isc_app_ctxfinish(dhcp_gbl_ctx.actx);
 111                 dhcp_gbl_ctx.actx_started = ISC_FALSE;
 112         }
 113
 114         if (dhcp_gbl_ctx.actx != NULL)
 115                 isc_appctx_destroy(&dhcp_gbl_ctx.actx);
 116
 117         if (dhcp_gbl_ctx.mctx != NULL)
 118                 isc_mem_detach(&dhcp_gbl_ctx.mctx);
 119
 120         return;
 121 }
 122
 123 isc_result_t
 124 dhcp_context_create(void) {
 125         isc_result_t result;
 126
 127         /*
 128          * Set up the error messages, this isn't the right place
 129          * for this call but it is convienent for now.
 130          */
 131         result = dhcp_result_register();
 132         if (result != ISC_R_SUCCESS) {
 133                 log_fatal("register_table() %s: %u", "failed", result);
 134         }
 135
 136         memset(&dhcp_gbl_ctx, 0, sizeof (dhcp_gbl_ctx));
 137
 138         isc_lib_register();
 139
 140         /* get the current time for use as the random seed */
 141         gettimeofday(&cur_tv, (struct timezone *)0);
 142         isc_random_seed(cur_tv.tv_sec);
 143
 144 #if defined (NSUPDATE)
 145         result = dns_lib_init();
 146         if (result != ISC_R_SUCCESS)
 147                 goto cleanup;
 148 #endif
 149
 150         result = isc_mem_create(0, 0, &dhcp_gbl_ctx.mctx);
 151         if (result != ISC_R_SUCCESS)
 152                 goto cleanup;
 153
 154         result = isc_appctx_create(dhcp_gbl_ctx.mctx, &dhcp_gbl_ctx.actx);
 155         if (result != ISC_R_SUCCESS)
 156                 goto cleanup;
 157
 158         result = isc_app_ctxstart(dhcp_gbl_ctx.actx);
 159         if (result != ISC_R_SUCCESS)
 160                 return (result);
 161         dhcp_gbl_ctx.actx_started = ISC_TRUE;
 162
 163         result = isc_taskmgr_createinctx(dhcp_gbl_ctx.mctx,
 164                                          dhcp_gbl_ctx.actx,
 165                                          1, 0,
 166                                          &dhcp_gbl_ctx.taskmgr);
 167         if (result != ISC_R_SUCCESS)
 168                 goto cleanup;
 169
 170         result = isc_socketmgr_createinctx(dhcp_gbl_ctx.mctx,
 171                                            dhcp_gbl_ctx.actx,
 172                                            &dhcp_gbl_ctx.socketmgr);
 173         if (result != ISC_R_SUCCESS)
 174                 goto cleanup;
 175
 176         result = isc_timermgr_createinctx(dhcp_gbl_ctx.mctx,
 177                                           dhcp_gbl_ctx.actx,
 178                                           &dhcp_gbl_ctx.timermgr);
 179         if (result != ISC_R_SUCCESS)
 180                 goto cleanup;
 181
 182         result = isc_task_create(dhcp_gbl_ctx.taskmgr, 0, &dhcp_gbl_ctx.task);
 183         if (result != ISC_R_SUCCESS)
 184                 goto cleanup;
 185
 186 #if defined (NSUPDATE)
 187         result = dns_client_createx(dhcp_gbl_ctx.mctx,
 188                                     dhcp_gbl_ctx.actx,
 189                                     dhcp_gbl_ctx.taskmgr,
 190                                     dhcp_gbl_ctx.socketmgr,
 191                                     dhcp_gbl_ctx.timermgr,
 192                                     0,
 193                                     &dhcp_gbl_ctx.dnsclient);
 194         if (result != ISC_R_SUCCESS)
 195                 goto cleanup;
 196
 197         result = dhcp_dns_client_setservers();
 198         if (result != ISC_R_SUCCESS)
 199                 goto cleanup;
 200
 201 #else
 202         /* The dst library is inited as part of dns_lib_init, we don't
 203          * need it if NSUPDATE is enabled */
 204         result = dst_lib_init(dhcp_gbl_ctx.mctx, NULL, 0);
 205         if (result != ISC_R_SUCCESS)
 206                 goto cleanup;
 207
 208 #endif
 209         return(ISC_R_SUCCESS);
 210
 211  cleanup:
 212         /*
 213          * Currently we don't try and cleanup, just return an error
 214          * expecting that our caller will log the error and exit.
 215          */
 216
 217         return(result);
 218 }
 219
 220 /*
 221  * Convert a string name into the proper structure for the isc routines
 222  *
 223  * Previously we allowed names without a trailing '.' however the current
 224  * dns and dst code requires the names to end in a period.  If the
 225  * name doesn't have a trailing period add one as part of creating
 226  * the dns name.
 227  */
 228
 229 isc_result_t
 230 dhcp_isc_name(unsigned char   *namestr,
 231               dns_fixedname_t *namefix,
 232               dns_name_t     **name)
 233 {
 234         size_t namelen;
 235         isc_buffer_t b;
 236         isc_result_t result;
 237
 238         namelen = strlen((char *)namestr);
 239         isc_buffer_init(&b, namestr, namelen);
 240         isc_buffer_add(&b, namelen);
 241         dns_fixedname_init(namefix);
 242         *name = dns_fixedname_name(namefix);
 243         result = dns_name_fromtext(*name, &b, dns_rootname, 0, NULL);
 244         isc_buffer_invalidate(&b);
 245         return(result);
 246 }
 247
 248 isc_result_t
 249 isclib_make_dst_key(char          *inname,
 250                     char          *algorithm,
 251                     unsigned char *secret,
 252                     int            length,
 253                     dst_key_t    **dstkey)
 254 {
 255         isc_result_t result;
 256         dns_name_t *name;
 257         dns_fixedname_t name0;
 258         isc_buffer_t b;
 259
 260         isc_buffer_init(&b, secret, length);
 261         isc_buffer_add(&b, length);
 262
 263         /* We only support HMAC_MD5 currently */
 264         if (strcasecmp(algorithm, DHCP_HMAC_MD5_NAME) != 0) {
 265                 return(DHCP_R_INVALIDARG);
 266         }
 267
 268         result = dhcp_isc_name((unsigned char *)inname, &name0, &name);
 269         if (result != ISC_R_SUCCESS) {
 270                 return(result);
 271         }
 272
 273         return(dst_key_frombuffer(name, DST_ALG_HMACMD5, DNS_KEYOWNER_ENTITY,
 274                                   DNS_KEYPROTO_DNSSEC, dns_rdataclass_in,
 275                                   &b, dhcp_gbl_ctx.mctx, dstkey));
 276 }
 277
 278 /**
 279  * signal handler that initiates server shutdown
 280  *
 281  * @param signal signal code that we received
 282  */
 283 void dhcp_signal_handler(int signal) {
 284         isc_appctx_t *ctx = dhcp_gbl_ctx.actx;
 285         int prev = shutdown_signal;
 286
 287         if (prev != 0) {
 288                 /* Already in shutdown. */
 289                 return;
 290         }
 291         /* Possible race but does it matter? */
 292         shutdown_signal = signal;
 293
 294         /* Use reload (aka suspend) for easier dispatch() reenter. */
 295         if (ctx && ctx->methods && ctx->methods->ctxsuspend) {
 296                 (void) isc_app_ctxsuspend(ctx);
 297         }
 298 }