grpc 1.74.1 → 1.75.0.pre1

data/third_party/cares/cares/src/lib/event/ares_event_configchg.c

@@ -0,0 +1,743 @@
+/* MIT License
+ *
+ * Copyright (c) 2024 Brad House
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * SPDX-License-Identifier: MIT
+ */
+#include "ares_private.h"
+#include "ares_event.h"
+
+#if defined(__ANDROID__) && defined(CARES_THREADS)
+
+ares_status_t ares_event_configchg_init(ares_event_configchg_t **configchg,
+                                        ares_event_thread_t     *e)
+{
+  (void)configchg;
+  (void)e;
+  /* No ability */
+  return ARES_ENOTIMP;
+}
+
+void ares_event_configchg_destroy(ares_event_configchg_t *configchg)
+{
+  /* No-op */
+  (void)configchg;
+}
+
+#elif defined(__linux__) && defined(CARES_THREADS)
+
+#  include <sys/inotify.h>
+
+struct ares_event_configchg {
+  int                  inotify_fd;
+  ares_event_thread_t *e;
+};
+
+void ares_event_configchg_destroy(ares_event_configchg_t *configchg)
+{
+  if (configchg == NULL) {
+    return; /* LCOV_EXCL_LINE: DefensiveCoding */
+  }
+
+  /* Tell event system to stop monitoring for changes.  This will cause the
+   * cleanup to be called */
+  ares_event_update(NULL, configchg->e, ARES_EVENT_FLAG_NONE, NULL,
+                    configchg->inotify_fd, NULL, NULL, NULL);
+}
+
+static void ares_event_configchg_free(void *data)
+{
+  ares_event_configchg_t *configchg = data;
+  if (configchg == NULL) {
+    return; /* LCOV_EXCL_LINE: DefensiveCoding */
+  }
+
+  if (configchg->inotify_fd >= 0) {
+    close(configchg->inotify_fd);
+    configchg->inotify_fd = -1;
+  }
+
+  ares_free(configchg);
+}
+
+static void ares_event_configchg_cb(ares_event_thread_t *e, ares_socket_t fd,
+                                    void *data, ares_event_flags_t flags)
+{
+  const ares_event_configchg_t *configchg = data;
+
+  /* Some systems cannot read integer variables if they are not
+   * properly aligned. On other systems, incorrect alignment may
+   * decrease performance. Hence, the buffer used for reading from
+   * the inotify file descriptor should have the same alignment as
+   * struct inotify_event. */
+  unsigned char                 buf[4096]
+    __attribute__((aligned(__alignof__(struct inotify_event))));
+  const struct inotify_event *event;
+  ssize_t                     len;
+  ares_bool_t                 triggered = ARES_FALSE;
+
+  (void)fd;
+  (void)flags;
+
+  while (1) {
+    const unsigned char *ptr;
+
+    len = read(configchg->inotify_fd, buf, sizeof(buf));
+    if (len <= 0) {
+      break;
+    }
+
+    /* Loop over all events in the buffer. Says kernel will check the buffer
+     * size provided, so I assume it won't ever return partial events. */
+    for (ptr  = buf; ptr < buf + len;
+         ptr += sizeof(struct inotify_event) + event->len) {
+      event = (const struct inotify_event *)((const void *)ptr);
+
+      if (event->len == 0 || ares_strlen(event->name) == 0) {
+        continue;
+      }
+
+      if (ares_strcaseeq(event->name, "resolv.conf") ||
+          ares_strcaseeq(event->name, "nsswitch.conf")) {
+        triggered = ARES_TRUE;
+      }
+    }
+  }
+
+  /* Only process after all events are read.  No need to process more often as
+   * we don't want to reload the config back to back */
+  if (triggered) {
+    ares_reinit(e->channel);
+  }
+}
+
+ares_status_t ares_event_configchg_init(ares_event_configchg_t **configchg,
+                                        ares_event_thread_t     *e)
+{
+  ares_status_t           status = ARES_SUCCESS;
+  ares_event_configchg_t *c;
+
+  (void)e;
+
+  /* Not used by this implementation */
+  *configchg = NULL;
+
+  c = ares_malloc_zero(sizeof(*c));
+  if (c == NULL) {
+    return ARES_ENOMEM; /* LCOV_EXCL_LINE: OutOfMemory */
+  }
+
+  c->e          = e;
+  c->inotify_fd = inotify_init1(IN_NONBLOCK | IN_CLOEXEC);
+  if (c->inotify_fd == -1) {
+    status = ARES_ESERVFAIL; /* LCOV_EXCL_LINE: UntestablePath */
+    goto done;               /* LCOV_EXCL_LINE: UntestablePath */
+  }
+
+  /* We need to monitor /etc/resolv.conf, /etc/nsswitch.conf */
+  if (inotify_add_watch(c->inotify_fd, "/etc",
+                        IN_CREATE | IN_MODIFY | IN_MOVED_TO | IN_ONLYDIR) ==
+      -1) {
+    status = ARES_ESERVFAIL; /* LCOV_EXCL_LINE: UntestablePath */
+    goto done;               /* LCOV_EXCL_LINE: UntestablePath */
+  }
+
+  status =
+    ares_event_update(NULL, e, ARES_EVENT_FLAG_READ, ares_event_configchg_cb,
+                      c->inotify_fd, c, ares_event_configchg_free, NULL);
+
+done:
+  if (status != ARES_SUCCESS) {
+    ares_event_configchg_free(c);
+  } else {
+    *configchg = c;
+  }
+  return status;
+}
+
+#elif defined(USE_WINSOCK) && defined(CARES_THREADS)
+
+#  include <winsock2.h>
+#  include <iphlpapi.h>
+#  include <stdio.h>
+#  include <windows.h>
+
+struct ares_event_configchg {
+  HANDLE               ifchg_hnd;
+  HKEY                 regip4;
+  HANDLE               regip4_event;
+  HANDLE               regip4_wait;
+  HKEY                 regip6;
+  HANDLE               regip6_event;
+  HANDLE               regip6_wait;
+  ares_event_thread_t *e;
+};
+
+void ares_event_configchg_destroy(ares_event_configchg_t *configchg)
+{
+  if (configchg == NULL) {
+    return;
+  }
+
+#  ifdef HAVE_NOTIFYIPINTERFACECHANGE
+  if (configchg->ifchg_hnd != NULL) {
+    CancelMibChangeNotify2(configchg->ifchg_hnd);
+    configchg->ifchg_hnd = NULL;
+  }
+#  endif
+
+#  ifdef HAVE_REGISTERWAITFORSINGLEOBJECT
+  if (configchg->regip4_wait != NULL) {
+    UnregisterWait(configchg->regip4_wait);
+    configchg->regip4_wait = NULL;
+  }
+
+  if (configchg->regip6_wait != NULL) {
+    UnregisterWait(configchg->regip6_wait);
+    configchg->regip6_wait = NULL;
+  }
+
+  if (configchg->regip4 != NULL) {
+    RegCloseKey(configchg->regip4);
+    configchg->regip4 = NULL;
+  }
+
+  if (configchg->regip6 != NULL) {
+    RegCloseKey(configchg->regip6);
+    configchg->regip6 = NULL;
+  }
+
+  if (configchg->regip4_event != NULL) {
+    CloseHandle(configchg->regip4_event);
+    configchg->regip4_event = NULL;
+  }
+
+  if (configchg->regip6_event != NULL) {
+    CloseHandle(configchg->regip6_event);
+    configchg->regip6_event = NULL;
+  }
+#  endif
+
+  ares_free(configchg);
+}
+
+
+#  ifdef HAVE_NOTIFYIPINTERFACECHANGE
+static void NETIOAPI_API_
+  ares_event_configchg_ip_cb(PVOID CallerContext, PMIB_IPINTERFACE_ROW Row,
+                             MIB_NOTIFICATION_TYPE NotificationType)
+{
+  ares_event_configchg_t *configchg = CallerContext;
+  (void)Row;
+  (void)NotificationType;
+  ares_reinit(configchg->e->channel);
+}
+#  endif
+
+static ares_bool_t
+  ares_event_configchg_regnotify(ares_event_configchg_t *configchg)
+{
+#  ifdef HAVE_REGISTERWAITFORSINGLEOBJECT
+#    if defined(__WATCOMC__) && !defined(REG_NOTIFY_THREAD_AGNOSTIC)
+#      define REG_NOTIFY_THREAD_AGNOSTIC 0x10000000L
+#    endif
+  DWORD flags = REG_NOTIFY_CHANGE_NAME | REG_NOTIFY_CHANGE_LAST_SET |
+                REG_NOTIFY_THREAD_AGNOSTIC;
+
+  if (RegNotifyChangeKeyValue(configchg->regip4, TRUE, flags,
+                              configchg->regip4_event, TRUE) != ERROR_SUCCESS) {
+    return ARES_FALSE;
+  }
+
+  if (RegNotifyChangeKeyValue(configchg->regip6, TRUE, flags,
+                              configchg->regip6_event, TRUE) != ERROR_SUCCESS) {
+    return ARES_FALSE;
+  }
+#  else
+  (void)configchg;
+#  endif
+  return ARES_TRUE;
+}
+
+static VOID CALLBACK ares_event_configchg_reg_cb(PVOID   lpParameter,
+                                                 BOOLEAN TimerOrWaitFired)
+{
+  ares_event_configchg_t *configchg = lpParameter;
+  (void)TimerOrWaitFired;
+
+  ares_reinit(configchg->e->channel);
+
+  /* Re-arm, as its single-shot.  However, we don't know which one needs to
+   * be re-armed, so we just do both */
+  ares_event_configchg_regnotify(configchg);
+}
+
+ares_status_t ares_event_configchg_init(ares_event_configchg_t **configchg,
+                                        ares_event_thread_t     *e)
+{
+  ares_status_t           status = ARES_SUCCESS;
+  ares_event_configchg_t *c      = NULL;
+
+  c = ares_malloc_zero(sizeof(**configchg));
+  if (c == NULL) {
+    return ARES_ENOMEM;
+  }
+
+  c->e = e;
+
+#  ifdef HAVE_NOTIFYIPINTERFACECHANGE
+  /* NOTE: If a user goes into the control panel and changes the network
+   *       adapter DNS addresses manually, this will NOT trigger a notification.
+   *       We've also tried listening on NotifyUnicastIpAddressChange(), but
+   *       that didn't get triggered either.
+   */
+  if (NotifyIpInterfaceChange(AF_UNSPEC, ares_event_configchg_ip_cb, c, FALSE,
+                              &c->ifchg_hnd) != NO_ERROR) {
+    status = ARES_ESERVFAIL;
+    goto done;
+  }
+#  endif
+
+#  ifdef HAVE_REGISTERWAITFORSINGLEOBJECT
+  /* Monitor HKLM\SYSTEM\CurrentControlSet\Services\Tcpip6\Parameters\Interfaces
+   * and HKLM\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters\Interfaces
+   * for changes via RegNotifyChangeKeyValue() */
+  if (RegOpenKeyExW(
+        HKEY_LOCAL_MACHINE,
+        L"SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters\\Interfaces",
+        0, KEY_NOTIFY, &c->regip4) != ERROR_SUCCESS) {
+    status = ARES_ESERVFAIL;
+    goto done;
+  }
+
+  if (RegOpenKeyExW(
+        HKEY_LOCAL_MACHINE,
+        L"SYSTEM\\CurrentControlSet\\Services\\Tcpip6\\Parameters\\Interfaces",
+        0, KEY_NOTIFY, &c->regip6) != ERROR_SUCCESS) {
+    status = ARES_ESERVFAIL;
+    goto done;
+  }
+
+  c->regip4_event = CreateEvent(NULL, TRUE, FALSE, NULL);
+  if (c->regip4_event == NULL) {
+    status = ARES_ESERVFAIL;
+    goto done;
+  }
+
+  c->regip6_event = CreateEvent(NULL, TRUE, FALSE, NULL);
+  if (c->regip6_event == NULL) {
+    status = ARES_ESERVFAIL;
+    goto done;
+  }
+
+  if (!RegisterWaitForSingleObject(&c->regip4_wait, c->regip4_event,
+                                   ares_event_configchg_reg_cb, c, INFINITE,
+                                   WT_EXECUTEDEFAULT)) {
+    status = ARES_ESERVFAIL;
+    goto done;
+  }
+
+  if (!RegisterWaitForSingleObject(&c->regip6_wait, c->regip6_event,
+                                   ares_event_configchg_reg_cb, c, INFINITE,
+                                   WT_EXECUTEDEFAULT)) {
+    status = ARES_ESERVFAIL;
+    goto done;
+  }
+#  endif
+
+  if (!ares_event_configchg_regnotify(c)) {
+    status = ARES_ESERVFAIL;
+    goto done;
+  }
+
+done:
+  if (status != ARES_SUCCESS) {
+    ares_event_configchg_destroy(c);
+  } else {
+    *configchg = c;
+  }
+
+  return status;
+}
+
+#elif defined(__APPLE__) && defined(CARES_THREADS)
+
+#  include <sys/types.h>
+#  include <unistd.h>
+#  include <notify.h>
+#  include <dlfcn.h>
+#  include <fcntl.h>
+
+struct ares_event_configchg {
+  int fd;
+  int token;
+};
+
+void ares_event_configchg_destroy(ares_event_configchg_t *configchg)
+{
+  (void)configchg;
+
+  /* Cleanup happens automatically */
+}
+
+static void ares_event_configchg_free(void *data)
+{
+  ares_event_configchg_t *configchg = data;
+  if (configchg == NULL) {
+    return;
+  }
+
+  if (configchg->fd >= 0) {
+    notify_cancel(configchg->token);
+    /* automatically closes fd */
+    configchg->fd = -1;
+  }
+
+  ares_free(configchg);
+}
+
+static void ares_event_configchg_cb(ares_event_thread_t *e, ares_socket_t fd,
+                                    void *data, ares_event_flags_t flags)
+{
+  ares_event_configchg_t *configchg = data;
+  ares_bool_t             triggered = ARES_FALSE;
+
+  (void)fd;
+  (void)flags;
+
+  while (1) {
+    int     t = 0;
+    ssize_t len;
+
+    len = read(configchg->fd, &t, sizeof(t));
+
+    if (len < (ssize_t)sizeof(t)) {
+      break;
+    }
+
+    /* Token is read in network byte order (yeah, docs don't mention this) */
+    t = (int)ntohl(t);
+
+    if (t != configchg->token) {
+      continue;
+    }
+
+    triggered = ARES_TRUE;
+  }
+
+  /* Only process after all events are read.  No need to process more often as
+   * we don't want to reload the config back to back */
+  if (triggered) {
+    ares_reinit(e->channel);
+  }
+}
+
+ares_status_t ares_event_configchg_init(ares_event_configchg_t **configchg,
+                                        ares_event_thread_t     *e)
+{
+  ares_status_t status                               = ARES_SUCCESS;
+  void         *handle                               = NULL;
+  const char *(*pdns_configuration_notify_key)(void) = NULL;
+  const char *notify_key                             = NULL;
+  int         flags;
+  size_t      i;
+  const char *searchlibs[] = {
+    "/usr/lib/libSystem.dylib",
+    "/System/Library/Frameworks/SystemConfiguration.framework/"
+    "SystemConfiguration",
+    NULL
+  };
+
+  *configchg = ares_malloc_zero(sizeof(**configchg));
+  if (*configchg == NULL) {
+    return ARES_ENOMEM;
+  }
+
+  /* Load symbol as it isn't normally public */
+  for (i = 0; searchlibs[i] != NULL; i++) {
+    handle = dlopen(searchlibs[i], RTLD_LAZY);
+    if (handle == NULL) {
+      /* Fail, loop! */
+      continue;
+    }
+
+    pdns_configuration_notify_key =
+      (const char *(*)(void))dlsym(handle, "dns_configuration_notify_key");
+    if (pdns_configuration_notify_key != NULL) {
+      break;
+    }
+
+    /* Fail, loop! */
+    dlclose(handle);
+    handle = NULL;
+  }
+
+  if (pdns_configuration_notify_key == NULL) {
+    status = ARES_ESERVFAIL;
+    goto done;
+  }
+
+  notify_key = pdns_configuration_notify_key();
+  if (notify_key == NULL) {
+    status = ARES_ESERVFAIL;
+    goto done;
+  }
+
+  if (notify_register_file_descriptor(notify_key, &(*configchg)->fd, 0,
+                                      &(*configchg)->token) !=
+      NOTIFY_STATUS_OK) {
+    status = ARES_ESERVFAIL;
+    goto done;
+  }
+
+  /* Set file descriptor to non-blocking */
+  flags = fcntl((*configchg)->fd, F_GETFL, 0);
+  fcntl((*configchg)->fd, F_SETFL, flags | O_NONBLOCK);
+
+  /* Register file descriptor with event subsystem */
+  status = ares_event_update(NULL, e, ARES_EVENT_FLAG_READ,
+                             ares_event_configchg_cb, (*configchg)->fd,
+                             *configchg, ares_event_configchg_free, NULL);
+
+done:
+  if (status != ARES_SUCCESS) {
+    ares_event_configchg_free(*configchg);
+    *configchg = NULL;
+  }
+
+  if (handle) {
+    dlclose(handle);
+  }
+
+  return status;
+}
+
+#elif defined(HAVE_STAT) && !defined(_WIN32) && defined(CARES_THREADS)
+#  ifdef HAVE_SYS_TYPES_H
+#    include <sys/types.h>
+#  endif
+#  ifdef HAVE_SYS_STAT_H
+#    include <sys/stat.h>
+#  endif
+
+typedef struct {
+  size_t size;
+  time_t mtime;
+} fileinfo_t;
+
+struct ares_event_configchg {
+  ares_bool_t          isup;
+  ares_thread_t       *thread;
+  ares_htable_strvp_t *filestat;
+  ares_thread_mutex_t *lock;
+  ares_thread_cond_t  *wake;
+  const char          *resolvconf_path;
+  ares_event_thread_t *e;
+};
+
+static ares_status_t config_change_check(ares_htable_strvp_t *filestat,
+                                         const char          *resolvconf_path)
+{
+  size_t      i;
+  const char *configfiles[16];
+  ares_bool_t changed = ARES_FALSE;
+  size_t      cnt = 0;
+
+  memset(configfiles, 0, sizeof(configfiles));
+
+  configfiles[cnt++] = resolvconf_path;
+  configfiles[cnt++] = "/etc/nsswitch.conf";
+#ifdef _AIX
+  configfiles[cnt++] = "/etc/netsvc.conf";
+#endif
+#ifdef __osf /* Tru64 */
+  configfiles[cnt++] = "/etc/svc.conf";
+#endif
+#ifdef __QNX__
+  configfiles[cnt++] = "/etc/net.cfg";
+#endif
+  configfiles[cnt++] = NULL;
+
+  for (i = 0; configfiles[i] != NULL; i++) {
+    fileinfo_t *fi = ares_htable_strvp_get_direct(filestat, configfiles[i]);
+    struct stat st;
+
+    if (stat(configfiles[i], &st) == 0) {
+      if (fi == NULL) {
+        fi = ares_malloc_zero(sizeof(*fi));
+        if (fi == NULL) {
+          return ARES_ENOMEM;
+        }
+        if (!ares_htable_strvp_insert(filestat, configfiles[i], fi)) {
+          ares_free(fi);
+          return ARES_ENOMEM;
+        }
+      }
+      if (fi->size != (size_t)st.st_size || fi->mtime != (time_t)st.st_mtime) {
+        changed = ARES_TRUE;
+      }
+      fi->size  = (size_t)st.st_size;
+      fi->mtime = (time_t)st.st_mtime;
+    } else if (fi != NULL) {
+      /* File no longer exists, remove */
+      ares_htable_strvp_remove(filestat, configfiles[i]);
+      changed = ARES_TRUE;
+    }
+  }
+
+  if (changed) {
+    return ARES_SUCCESS;
+  }
+  return ARES_ENOTFOUND;
+}
+
+static void *ares_event_configchg_thread(void *arg)
+{
+  ares_event_configchg_t *c = arg;
+
+  ares_thread_mutex_lock(c->lock);
+  while (c->isup) {
+    ares_status_t status;
+
+    if (ares_thread_cond_timedwait(c->wake, c->lock, 30000) != ARES_ETIMEOUT) {
+      continue;
+    }
+
+    /* make sure status didn't change even though we got a timeout */
+    if (!c->isup) {
+      break;
+    }
+
+    status = config_change_check(c->filestat, c->resolvconf_path);
+    if (status == ARES_SUCCESS) {
+      ares_reinit(c->e->channel);
+    }
+  }
+
+  ares_thread_mutex_unlock(c->lock);
+  return NULL;
+}
+
+ares_status_t ares_event_configchg_init(ares_event_configchg_t **configchg,
+                                        ares_event_thread_t     *e)
+{
+  ares_status_t           status = ARES_SUCCESS;
+  ares_event_configchg_t *c      = NULL;
+
+  *configchg = NULL;
+
+  c = ares_malloc_zero(sizeof(*c));
+  if (c == NULL) {
+    status = ARES_ENOMEM;
+    goto done;
+  }
+
+  c->e = e;
+
+  c->filestat = ares_htable_strvp_create(ares_free);
+  if (c->filestat == NULL) {
+    status = ARES_ENOMEM;
+    goto done;
+  }
+
+  c->wake = ares_thread_cond_create();
+  if (c->wake == NULL) {
+    status = ARES_ENOMEM;
+    goto done;
+  }
+
+  c->lock = ares_thread_mutex_create();
+  if (c->lock == NULL) {
+    status = ARES_ENOMEM;
+    goto done;
+  }
+
+  c->resolvconf_path = c->e->channel->resolvconf_path;
+  if (c->resolvconf_path == NULL) {
+    c->resolvconf_path = PATH_RESOLV_CONF;
+  }
+
+  status = config_change_check(c->filestat, c->resolvconf_path);
+  if (status == ARES_ENOMEM) {
+    goto done;
+  }
+
+  c->isup = ARES_TRUE;
+  status  = ares_thread_create(&c->thread, ares_event_configchg_thread, c);
+
+done:
+  if (status != ARES_SUCCESS) {
+    ares_event_configchg_destroy(c);
+  } else {
+    *configchg = c;
+  }
+  return status;
+}
+
+void ares_event_configchg_destroy(ares_event_configchg_t *configchg)
+{
+  if (configchg == NULL) {
+    return;
+  }
+
+  if (configchg->lock) {
+    ares_thread_mutex_lock(configchg->lock);
+  }
+
+  configchg->isup = ARES_FALSE;
+  if (configchg->wake) {
+    ares_thread_cond_signal(configchg->wake);
+  }
+
+  if (configchg->lock) {
+    ares_thread_mutex_unlock(configchg->lock);
+  }
+
+  if (configchg->thread) {
+    void *rv = NULL;
+    ares_thread_join(configchg->thread, &rv);
+  }
+
+  ares_thread_mutex_destroy(configchg->lock);
+  ares_thread_cond_destroy(configchg->wake);
+  ares_htable_strvp_destroy(configchg->filestat);
+  ares_free(configchg);
+}
+
+#else
+
+ares_status_t ares_event_configchg_init(ares_event_configchg_t **configchg,
+                                        ares_event_thread_t     *e)
+{
+  (void)configchg;
+  (void)e;
+  /* No ability */
+  return ARES_ENOTIMP;
+}
+
+void ares_event_configchg_destroy(ares_event_configchg_t *configchg)
+{
+  /* No-op */
+  (void)configchg;
+}
+
+#endif