agent.c

Go to the documentation of this file.

/*
 * Copyright (C) 2006 Voop as
 * Thorsten Lockert <[email protected]>
 *
 * This program is free software, distributed under the terms of
 * the GNU General Public License Version 2. See the LICENSE file
 * at the top of the source tree.
 */

/*! \file
 *
 * \brief SNMP Agent / SubAgent support for Asterisk
 *
 * \author Thorsten Lockert <[email protected]>
 */

/*** MODULEINFO
   <support_level>extended</support_level>
 ***/

/* Needed for net-snmp headers */
#define ASTMM_LIBC ASTMM_IGNORE
#include "asterisk.h"

/*
 * There is some collision collision between netsmp and asterisk names,
 * causing build under AST_DEVMODE to fail.
 *
 * The following PACKAGE_* macros are one place.
 * Also netsnmp has an improper check for HAVE_DMALLOC_H, using
 *    #if HAVE_DMALLOC_H   instead of #ifdef HAVE_DMALLOC_H
 * As a countermeasure we define it to 0, however this will fail
 * when the proper check is implemented.
 */
#ifdef PACKAGE_NAME
#undef PACKAGE_NAME
#endif
#ifdef PACKAGE_BUGREPORT
#undef PACKAGE_BUGREPORT
#endif
#ifdef PACKAGE_STRING
#undef PACKAGE_STRING
#endif
#ifdef PACKAGE_TARNAME
#undef PACKAGE_TARNAME
#endif
#ifdef PACKAGE_VERSION
#undef PACKAGE_VERSION
#endif
#ifndef HAVE_DMALLOC_H
#define HAVE_DMALLOC_H 0   /* XXX we shouldn't do this */
#endif

#if defined(__OpenBSD__)
/*
 * OpenBSD uses old "legacy" cc which has a rather pedantic builtin preprocessor.
 * Using a macro which is not #defined throws an error.
 */
#define __NetBSD_Version__ 0
#endif

#include <net-snmp/net-snmp-config.h>
#include <net-snmp/net-snmp-includes.h>
#include <net-snmp/agent/net-snmp-agent-includes.h>

#if !defined(RONLY) && defined(NETSNMP_OLDAPI_RONLY)
#define RONLY NETSNMP_OLDAPI_RONLY
#endif

#include "asterisk/paths.h"   /* need ast_config_AST_SOCKET */
#include "asterisk/channel.h"
#include "asterisk/logger.h"
#include "asterisk/options.h"
#include "asterisk/indications.h"
#include "asterisk/ast_version.h"
#include "asterisk/pbx.h"

/* Colission between Net-SNMP and Asterisk */
#define unload_module ast_unload_module
#include "asterisk/module.h"
#undef unload_module

#include "agent.h"

/* Helper functions in Net-SNMP, header file not installed by default */
int header_generic(struct variable *, oid *, size_t *, int, size_t *, WriteMethod **);
int header_simple_table(struct variable *, oid *, size_t *, int, size_t *, WriteMethod **, int);
int register_sysORTable(oid *, size_t, const char *);
int unregister_sysORTable(oid *, size_t);

/* Forward declaration */
static void init_asterisk_mib(void);

/*
 * Anchor for all the Asterisk MIB values
 */
static oid asterisk_oid[] = { 1, 3, 6, 1, 4, 1, 22736, 1 };

/*
 * MIB values -- these correspond to values in the Asterisk MIB,
 * and MUST be kept in sync with the MIB for things to work as
 * expected.
 */
#define ASTVERSION            1
#define     ASTVERSTRING         1
#define     ASTVERTAG            2

#define  ASTCONFIGURATION     2
#define     ASTCONFUPTIME        1
#define     ASTCONFRELOADTIME    2
#define     ASTCONFPID           3
#define     ASTCONFSOCKET        4
#define     ASTCONFACTIVECALLS   5
#define     ASTCONFPROCESSEDCALLS   6

#define  ASTMODULES           3
#define     ASTMODCOUNT          1

#define  ASTINDICATIONS       4
#define     ASTINDCOUNT          1
#define     ASTINDCURRENT        2

#define     ASTINDTABLE          3
#define        ASTINDINDEX          1
#define        ASTINDCOUNTRY        2
#define        ASTINDALIAS          3
#define        ASTINDDESCRIPTION    4

#define  ASTCHANNELS          5
#define     ASTCHANCOUNT         1

#define     ASTCHANTABLE         2
#define        ASTCHANINDEX         1
#define        ASTCHANNAME          2
#define        ASTCHANLANGUAGE         3
#define        ASTCHANTYPE          4
#define        ASTCHANMUSICCLASS    5
#define        ASTCHANBRIDGE        6
#define        ASTCHANMASQ          7
#define        ASTCHANMASQR         8
#define        ASTCHANWHENHANGUP    9
#define        ASTCHANAPP           10
#define        ASTCHANDATA          11
#define        ASTCHANCONTEXT       12
#define        ASTCHANMACROCONTEXT     13
#define        ASTCHANMACROEXTEN    14
#define        ASTCHANMACROPRI         15
#define        ASTCHANEXTEN         16
#define        ASTCHANPRI           17
#define        ASTCHANACCOUNTCODE      18
#define        ASTCHANFORWARDTO     19
#define        ASTCHANUNIQUEID         20
#define        ASTCHANCALLGROUP     21
#define        ASTCHANPICKUPGROUP      22
#define        ASTCHANSTATE         23
#define        ASTCHANMUTED         24
#define        ASTCHANRINGS         25
#define        ASTCHANCIDDNID       26
#define        ASTCHANCIDNUM        27
#define        ASTCHANCIDNAME       28
#define        ASTCHANCIDANI        29
#define        ASTCHANCIDRDNIS         30
#define        ASTCHANCIDPRES       31
#define        ASTCHANCIDANI2       32
#define        ASTCHANCIDTON        33
#define        ASTCHANCIDTNS        34
#define        ASTCHANAMAFLAGS         35
#define        ASTCHANADSI          36
#define        ASTCHANTONEZONE         37
#define        ASTCHANHANGUPCAUSE      38
#define        ASTCHANVARIABLES     39
#define        ASTCHANFLAGS         40
#define        ASTCHANTRANSFERCAP      41

#define     ASTCHANTYPECOUNT     3

#define     ASTCHANTYPETABLE     4
#define        ASTCHANTYPEINDEX     1
#define        ASTCHANTYPENAME         2
#define        ASTCHANTYPEDESC         3
#define        ASTCHANTYPEDEVSTATE     4
#define        ASTCHANTYPEINDICATIONS  5
#define        ASTCHANTYPETRANSFER     6
#define        ASTCHANTYPECHANNELS     7

#define     ASTCHANSCALARS       5
#define        ASTCHANBRIDGECOUNT      1

void *agent_thread(void *arg)
{
   ast_verb(2, "Starting %sAgent\n", res_snmp_agentx_subagent ? "Sub" : "");

   snmp_enable_stderrlog();

   if (res_snmp_agentx_subagent)
      netsnmp_ds_set_boolean(NETSNMP_DS_APPLICATION_ID,
                        NETSNMP_DS_AGENT_ROLE,
                        1);

   init_agent("asterisk");

   init_asterisk_mib();

   init_snmp("asterisk");

   if (!res_snmp_agentx_subagent)
      init_master_agent();

   while (res_snmp_dont_stop)
      agent_check_and_process(1);

   snmp_shutdown("asterisk");

   ast_verb(2, "Terminating %sAgent\n", res_snmp_agentx_subagent ? "Sub" : "");

   return NULL;
}

static u_char *
ast_var_channels(struct variable *vp, oid *name, size_t *length,
             int exact, size_t *var_len, WriteMethod **write_method)
{
   static unsigned long long_ret;

   if (header_generic(vp, name, length, exact, var_len, write_method))
      return NULL;

   if (vp->magic != ASTCHANCOUNT)
      return NULL;

   long_ret = ast_active_channels();

   return (u_char *)&long_ret;
}

static u_char *ast_var_channels_table(struct variable *vp, oid *name, size_t *length,
                           int exact, size_t *var_len, WriteMethod **write_method)
{
   static unsigned long long_ret;
   static u_char bits_ret[2];
   static char string_ret[256];
   struct ast_channel *chan, *bridge;
   struct timeval tval;
   u_char *ret = NULL;
   int i, bit;
   struct ast_str *out = ast_str_alloca(2048);
   struct ast_channel_iterator *iter;

   if (header_simple_table(vp, name, length, exact, var_len, write_method, ast_active_channels()))
      return NULL;

   i = name[*length - 1] - 1;

   if (!(iter = ast_channel_iterator_all_new())) {
      return NULL;
   }

   while ((chan = ast_channel_iterator_next(iter)) && i) {
      ast_channel_unref(chan);
      i--;
   }

   iter = ast_channel_iterator_destroy(iter);

   if (chan == NULL) {
      return NULL;
   }

   *var_len = sizeof(long_ret);

   ast_channel_lock(chan);

   switch (vp->magic) {
   case ASTCHANINDEX:
      long_ret = name[*length - 1];
      ret = (u_char *)&long_ret;
      break;
   case ASTCHANNAME:
      if (!ast_strlen_zero(ast_channel_name(chan))) {
         ast_copy_string(string_ret, ast_channel_name(chan), sizeof(string_ret));
         *var_len = strlen(string_ret);
         ret = (u_char *)string_ret;
      }
      break;
   case ASTCHANLANGUAGE:
      if (!ast_strlen_zero(ast_channel_language(chan))) {
         ast_copy_string(string_ret, ast_channel_language(chan), sizeof(string_ret));
         *var_len = strlen(string_ret);
         ret = (u_char *)string_ret;
      }
      break;
   case ASTCHANTYPE:
      ast_copy_string(string_ret, ast_channel_tech(chan)->type, sizeof(string_ret));
      *var_len = strlen(string_ret);
      ret = (u_char *)string_ret;
      break;
   case ASTCHANMUSICCLASS:
      if (!ast_strlen_zero(ast_channel_musicclass(chan))) {
         ast_copy_string(string_ret, ast_channel_musicclass(chan), sizeof(string_ret));
         *var_len = strlen(string_ret);
         ret = (u_char *)string_ret;
      }
      break;
   case ASTCHANBRIDGE:
      ast_channel_unlock(chan);
      bridge = ast_channel_bridge_peer(chan);
      if (bridge) {
         ast_channel_lock(bridge);
         ast_copy_string(string_ret, ast_channel_name(bridge), sizeof(string_ret));
         ast_channel_unlock(bridge);
         ast_channel_unref(bridge);

         *var_len = strlen(string_ret);
         ret = (u_char *)string_ret;
      }
      ast_channel_lock(chan);
      break;
   case ASTCHANMASQ:
      if (ast_channel_masq(chan) && !ast_strlen_zero(ast_channel_name(ast_channel_masq(chan)))) {
         ast_copy_string(string_ret, ast_channel_name(ast_channel_masq(chan)), sizeof(string_ret));
         *var_len = strlen(string_ret);
         ret = (u_char *)string_ret;
      }
      break;
   case ASTCHANMASQR:
      if (ast_channel_masqr(chan) && !ast_strlen_zero(ast_channel_name(ast_channel_masqr(chan)))) {
         ast_copy_string(string_ret, ast_channel_name(ast_channel_masqr(chan)), sizeof(string_ret));
         *var_len = strlen(string_ret);
         ret = (u_char *)string_ret;
      }
      break;
   case ASTCHANWHENHANGUP:
      if (!ast_tvzero(*ast_channel_whentohangup(chan))) {
         gettimeofday(&tval, NULL);
         long_ret = difftime(ast_channel_whentohangup(chan)->tv_sec, tval.tv_sec) * 100 - tval.tv_usec / 10000;
         ret= (u_char *)&long_ret;
      }
      break;
   case ASTCHANAPP:
      if (ast_channel_appl(chan)) {
         ast_copy_string(string_ret, ast_channel_appl(chan), sizeof(string_ret));
         *var_len = strlen(string_ret);
         ret = (u_char *)string_ret;
      }
      break;
   case ASTCHANDATA:
      if (ast_channel_data(chan)) {
         ast_copy_string(string_ret, ast_channel_data(chan), sizeof(string_ret));
         *var_len = strlen(string_ret);
         ret = (u_char *)string_ret;
      }
      break;
   case ASTCHANCONTEXT:
      ast_copy_string(string_ret, ast_channel_context(chan), sizeof(string_ret));
      *var_len = strlen(string_ret);
      ret = (u_char *)string_ret;
      break;
   case ASTCHANMACROCONTEXT:
      ast_copy_string(string_ret, ast_channel_macrocontext(chan), sizeof(string_ret));
      *var_len = strlen(string_ret);
      ret = (u_char *)string_ret;
      break;
   case ASTCHANMACROEXTEN:
      ast_copy_string(string_ret, ast_channel_macroexten(chan), sizeof(string_ret));
      *var_len = strlen(string_ret);
      ret = (u_char *)string_ret;
      break;
   case ASTCHANMACROPRI:
      long_ret = ast_channel_macropriority(chan);
      ret = (u_char *)&long_ret;
      break;
   case ASTCHANEXTEN:
      ast_copy_string(string_ret, ast_channel_exten(chan), sizeof(string_ret));
      *var_len = strlen(string_ret);
      ret = (u_char *)string_ret;
      break;
   case ASTCHANPRI:
      long_ret = ast_channel_priority(chan);
      ret = (u_char *)&long_ret;
      break;
   case ASTCHANACCOUNTCODE:
      if (!ast_strlen_zero(ast_channel_accountcode(chan))) {
         ast_copy_string(string_ret, ast_channel_accountcode(chan), sizeof(string_ret));
         *var_len = strlen(string_ret);
         ret = (u_char *)string_ret;
      }
      break;
   case ASTCHANFORWARDTO:
      if (!ast_strlen_zero(ast_channel_call_forward(chan))) {
         ast_copy_string(string_ret, ast_channel_call_forward(chan), sizeof(string_ret));
         *var_len = strlen(string_ret);
         ret = (u_char *)string_ret;
      }
      break;
   case ASTCHANUNIQUEID:
      ast_copy_string(string_ret, ast_channel_uniqueid(chan), sizeof(string_ret));
      *var_len = strlen(string_ret);
      ret = (u_char *)string_ret;
      break;
   case ASTCHANCALLGROUP:
      long_ret = ast_channel_callgroup(chan);
      ret = (u_char *)&long_ret;
      break;
   case ASTCHANPICKUPGROUP:
      long_ret = ast_channel_pickupgroup(chan);
      ret = (u_char *)&long_ret;
      break;
   case ASTCHANSTATE:
      long_ret = ast_channel_state(chan) & 0xffff;
      ret = (u_char *)&long_ret;
      break;
   case ASTCHANMUTED:
      long_ret = ast_channel_state(chan) & AST_STATE_MUTE ? 1 : 2;
      ret = (u_char *)&long_ret;
      break;
   case ASTCHANRINGS:
      long_ret = ast_channel_rings(chan);
      ret = (u_char *)&long_ret;
      break;
   case ASTCHANCIDDNID:
      if (ast_channel_dialed(chan)->number.str) {
         ast_copy_string(string_ret, ast_channel_dialed(chan)->number.str, sizeof(string_ret));
         *var_len = strlen(string_ret);
         ret = (u_char *)string_ret;
      }
      break;
   case ASTCHANCIDNUM:
      if (ast_channel_caller(chan)->id.number.valid && ast_channel_caller(chan)->id.number.str) {
         ast_copy_string(string_ret, ast_channel_caller(chan)->id.number.str, sizeof(string_ret));
         *var_len = strlen(string_ret);
         ret = (u_char *)string_ret;
      }
      break;
   case ASTCHANCIDNAME:
      if (ast_channel_caller(chan)->id.name.valid && ast_channel_caller(chan)->id.name.str) {
         ast_copy_string(string_ret, ast_channel_caller(chan)->id.name.str, sizeof(string_ret));
         *var_len = strlen(string_ret);
         ret = (u_char *)string_ret;
      }
      break;
   case ASTCHANCIDANI:
      if (ast_channel_caller(chan)->ani.number.valid && ast_channel_caller(chan)->ani.number.str) {
         ast_copy_string(string_ret, ast_channel_caller(chan)->ani.number.str, sizeof(string_ret));
         *var_len = strlen(string_ret);
         ret = (u_char *)string_ret;
      }
      break;
   case ASTCHANCIDRDNIS:
      if (ast_channel_redirecting(chan)->from.number.valid && ast_channel_redirecting(chan)->from.number.str) {
         ast_copy_string(string_ret, ast_channel_redirecting(chan)->from.number.str, sizeof(string_ret));
         *var_len = strlen(string_ret);
         ret = (u_char *)string_ret;
      }
      break;
   case ASTCHANCIDPRES:
      long_ret = ast_party_id_presentation(&ast_channel_caller(chan)->id);
      ret = (u_char *)&long_ret;
      break;
   case ASTCHANCIDANI2:
      long_ret = ast_channel_caller(chan)->ani2;
      ret = (u_char *)&long_ret;
      break;
   case ASTCHANCIDTON:
      long_ret = ast_channel_caller(chan)->id.number.plan;
      ret = (u_char *)&long_ret;
      break;
   case ASTCHANCIDTNS:
      long_ret = ast_channel_dialed(chan)->transit_network_select;
      ret = (u_char *)&long_ret;
      break;
   case ASTCHANAMAFLAGS:
      long_ret = ast_channel_amaflags(chan);
      ret = (u_char *)&long_ret;
      break;
   case ASTCHANADSI:
      long_ret = ast_channel_adsicpe(chan);
      ret = (u_char *)&long_ret;
      break;
   case ASTCHANTONEZONE:
      if (ast_channel_zone(chan)) {
         ast_copy_string(string_ret, ast_channel_zone(chan)->country, sizeof(string_ret));
         *var_len = strlen(string_ret);
         ret = (u_char *)string_ret;
      }
      break;
   case ASTCHANHANGUPCAUSE:
      long_ret = ast_channel_hangupcause(chan);
      ret = (u_char *)&long_ret;
      break;
   case ASTCHANVARIABLES:
      if (pbx_builtin_serialize_variables(chan, &out)) {
         *var_len = ast_str_strlen(out);
         ret = (u_char *)ast_str_buffer(out);
      }
      break;
   case ASTCHANFLAGS:
      bits_ret[0] = 0;
      for (bit = 0; bit < 8; bit++)
         bits_ret[0] |= ((ast_channel_flags(chan)->flags & (1 << bit)) >> bit) << (7 - bit);
      bits_ret[1] = 0;
      for (bit = 0; bit < 8; bit++)
         bits_ret[1] |= (((ast_channel_flags(chan)->flags >> 8) & (1 << bit)) >> bit) << (7 - bit);
      *var_len = 2;
      ret = bits_ret;
      break;
   case ASTCHANTRANSFERCAP:
      long_ret = ast_channel_transfercapability(chan);
      ret = (u_char *)&long_ret;
   default:
      break;
   }

   ast_channel_unlock(chan);
   chan = ast_channel_unref(chan);

   return ret;
}

static u_char *ast_var_channel_types(struct variable *vp, oid *name, size_t *length,
                           int exact, size_t *var_len, WriteMethod **write_method)
{
   static unsigned long long_ret;
   struct ast_variable *channel_types, *next;

   if (header_generic(vp, name, length, exact, var_len, write_method))
      return NULL;

   if (vp->magic != ASTCHANTYPECOUNT)
      return NULL;

   for (long_ret = 0, channel_types = next = ast_channeltype_list(); next; next = next->next)
      long_ret++;
   ast_variables_destroy(channel_types);

   return (u_char *)&long_ret;
}

static u_char *ast_var_channel_types_table(struct variable *vp, oid *name, size_t *length,
                              int exact, size_t *var_len, WriteMethod **write_method)
{
   const struct ast_channel_tech *tech = NULL;
   struct ast_variable *channel_types, *next;
   static unsigned long long_ret;
   struct ast_channel *chan;
   u_long i;

   if (header_simple_table(vp, name, length, exact, var_len, write_method, -1))
      return NULL;

   channel_types = ast_channeltype_list();
   for (i = 1, next = channel_types; next && i != name[*length - 1]; next = next->next, i++)
      ;
   if (next != NULL)
      tech = ast_get_channel_tech(next->name);
   ast_variables_destroy(channel_types);
   if (next == NULL || tech == NULL)
      return NULL;

   switch (vp->magic) {
   case ASTCHANTYPEINDEX:
      long_ret = name[*length - 1];
      return (u_char *)&long_ret;
   case ASTCHANTYPENAME:
      *var_len = strlen(tech->type);
      return (u_char *)tech->type;
   case ASTCHANTYPEDESC:
      *var_len = strlen(tech->description);
      return (u_char *)tech->description;
   case ASTCHANTYPEDEVSTATE:
      long_ret = tech->devicestate ? 1 : 2;
      return (u_char *)&long_ret;
   case ASTCHANTYPEINDICATIONS:
      long_ret = tech->indicate ? 1 : 2;
      return (u_char *)&long_ret;
   case ASTCHANTYPETRANSFER:
      long_ret = tech->transfer ? 1 : 2;
      return (u_char *)&long_ret;
   case ASTCHANTYPECHANNELS:
   {
      struct ast_channel_iterator *iter;

      long_ret = 0;

      if (!(iter = ast_channel_iterator_all_new())) {
         return NULL;
      }

      while ((chan = ast_channel_iterator_next(iter))) {
         if (ast_channel_tech(chan) == tech) {
            long_ret++;
         }
         chan = ast_channel_unref(chan);
      }

      ast_channel_iterator_destroy(iter);

      return (u_char *)&long_ret;
   }
   default:
      break;
   }
   return NULL;
}

static u_char *ast_var_channel_bridge(struct variable *vp, oid *name, size_t *length,
   int exact, size_t *var_len, WriteMethod **write_method)
{
   static unsigned long long_ret;
   struct ast_channel *chan = NULL;
   struct ast_channel_iterator *iter;

   long_ret = 0;

   if (header_generic(vp, name, length, exact, var_len, write_method)) {
      return NULL;
   }

   if (!(iter = ast_channel_iterator_all_new())) {
      return NULL;
   }

   while ((chan = ast_channel_iterator_next(iter))) {
      ast_channel_lock(chan);
      if (ast_channel_is_bridged(chan)) {
         long_ret++;
      }
      ast_channel_unlock(chan);
      chan = ast_channel_unref(chan);
   }

   ast_channel_iterator_destroy(iter);

   *var_len = sizeof(long_ret);

   return (vp->magic == ASTCHANBRIDGECOUNT) ? (u_char *) &long_ret : NULL;
}

static u_char *ast_var_Config(struct variable *vp, oid *name, size_t *length,
                      int exact, size_t *var_len, WriteMethod **write_method)
{
   static unsigned long long_ret;
   struct timeval tval;

   if (header_generic(vp, name, length, exact, var_len, write_method))
      return NULL;

   switch (vp->magic) {
   case ASTCONFUPTIME:
      gettimeofday(&tval, NULL);
      long_ret = difftime(tval.tv_sec, ast_startuptime.tv_sec) * 100 + tval.tv_usec / 10000 - ast_startuptime.tv_usec / 10000;
      return (u_char *)&long_ret;
   case ASTCONFRELOADTIME:
      gettimeofday(&tval, NULL);
      if (ast_lastreloadtime.tv_sec)
         long_ret = difftime(tval.tv_sec, ast_lastreloadtime.tv_sec) * 100 + tval.tv_usec / 10000 - ast_lastreloadtime.tv_usec / 10000;
      else
         long_ret = difftime(tval.tv_sec, ast_startuptime.tv_sec) * 100 + tval.tv_usec / 10000 - ast_startuptime.tv_usec / 10000;
      return (u_char *)&long_ret;
   case ASTCONFPID:
      long_ret = getpid();
      return (u_char *)&long_ret;
   case ASTCONFSOCKET:
      *var_len = strlen(ast_config_AST_SOCKET);
      return (u_char *)ast_config_AST_SOCKET;
   case ASTCONFACTIVECALLS:
      long_ret = ast_active_calls();
      return (u_char *)&long_ret;
   case ASTCONFPROCESSEDCALLS:
      long_ret = ast_processed_calls();
      return (u_char *)&long_ret;
   default:
      break;
   }
   return NULL;
}

static u_char *ast_var_indications(struct variable *vp, oid *name, size_t *length,
                          int exact, size_t *var_len, WriteMethod **write_method)
{
   static unsigned long long_ret;
   static char ret_buf[128];
   struct ast_tone_zone *tz = NULL;

   if (header_generic(vp, name, length, exact, var_len, write_method))
      return NULL;

   switch (vp->magic) {
   case ASTINDCOUNT:
   {
      struct ao2_iterator i;

      long_ret = 0;

      i = ast_tone_zone_iterator_init();
      while ((tz = ao2_iterator_next(&i))) {
         tz = ast_tone_zone_unref(tz);
         long_ret++;
      }
      ao2_iterator_destroy(&i);

      return (u_char *) &long_ret;
   }
   case ASTINDCURRENT:
      tz = ast_get_indication_zone(NULL);
      if (tz) {
         ast_copy_string(ret_buf, tz->country, sizeof(ret_buf));
         *var_len = strlen(ret_buf);
         tz = ast_tone_zone_unref(tz);
         return (u_char *) ret_buf;
      }
      *var_len = 0;
      return NULL;
   default:
      break;
   }
   return NULL;
}

static u_char *ast_var_indications_table(struct variable *vp, oid *name, size_t *length,
                              int exact, size_t *var_len, WriteMethod **write_method)
{
   static unsigned long long_ret;
   static char ret_buf[256];
   struct ast_tone_zone *tz = NULL;
   int i;
   struct ao2_iterator iter;

   if (header_simple_table(vp, name, length, exact, var_len, write_method, -1)) {
      return NULL;
   }

   i = name[*length - 1] - 1;

   iter = ast_tone_zone_iterator_init();

   while ((tz = ao2_iterator_next(&iter)) && i) {
      tz = ast_tone_zone_unref(tz);
      i--;
   }
   ao2_iterator_destroy(&iter);

   if (tz == NULL) {
      return NULL;
   }

   switch (vp->magic) {
   case ASTINDINDEX:
      ast_tone_zone_unref(tz);
      long_ret = name[*length - 1];
      return (u_char *)&long_ret;
   case ASTINDCOUNTRY:
      ast_copy_string(ret_buf, tz->country, sizeof(ret_buf));
      ast_tone_zone_unref(tz);
      *var_len = strlen(ret_buf);
      return (u_char *) ret_buf;
   case ASTINDALIAS:
      /* No longer exists */
      ast_tone_zone_unref(tz);
      return NULL;
   case ASTINDDESCRIPTION:
      ast_tone_zone_lock(tz);
      ast_copy_string(ret_buf, tz->description, sizeof(ret_buf));
      ast_tone_zone_unlock(tz);
      ast_tone_zone_unref(tz);
      *var_len = strlen(ret_buf);
      return (u_char *) ret_buf;
   default:
      ast_tone_zone_unref(tz);
      break;
   }
   return NULL;
}

static int countmodule(const char *mod, const char *desc, int use, const char *status,
      const char *like, enum ast_module_support_level support_level)
{
   return 1;
}

static u_char *ast_var_Modules(struct variable *vp, oid *name, size_t *length,
                       int exact, size_t *var_len, WriteMethod **write_method)
{
   static unsigned long long_ret;

   if (header_generic(vp, name, length, exact, var_len, write_method))
      return NULL;

   if (vp->magic != ASTMODCOUNT)
      return NULL;

   long_ret = ast_update_module_list(countmodule, NULL);

   return (u_char *)&long_ret;
}

static u_char *ast_var_Version(struct variable *vp, oid *name, size_t *length,
                       int exact, size_t *var_len, WriteMethod **write_method)
{
   static unsigned long long_ret;

   if (header_generic(vp, name, length, exact, var_len, write_method))
      return NULL;

   switch (vp->magic) {
   case ASTVERSTRING:
   {
      const char *version = ast_get_version();
      *var_len = strlen(version);
      return (u_char *)version;
   }
   case ASTVERTAG:
      sscanf(ast_get_version_num(), "%30lu", &long_ret);
      return (u_char *)&long_ret;
   default:
      break;
   }
   return NULL;
}

static int term_asterisk_mib(int majorID, int minorID, void *serverarg, void *clientarg)
{
   unregister_sysORTable(asterisk_oid, OID_LENGTH(asterisk_oid));
   return 0;
}

static void init_asterisk_mib(void)
{
   static struct variable4 asterisk_vars[] = {
      {ASTVERSTRING,           ASN_OCTET_STR, RONLY, ast_var_Version,             2, {ASTVERSION, ASTVERSTRING}},
      {ASTVERTAG,              ASN_UNSIGNED,  RONLY, ast_var_Version,             2, {ASTVERSION, ASTVERTAG}},
      {ASTCONFUPTIME,          ASN_TIMETICKS, RONLY, ast_var_Config,              2, {ASTCONFIGURATION, ASTCONFUPTIME}},
      {ASTCONFRELOADTIME,      ASN_TIMETICKS, RONLY, ast_var_Config,              2, {ASTCONFIGURATION, ASTCONFRELOADTIME}},
      {ASTCONFPID,             ASN_INTEGER,   RONLY, ast_var_Config,              2, {ASTCONFIGURATION, ASTCONFPID}},
      {ASTCONFSOCKET,          ASN_OCTET_STR, RONLY, ast_var_Config,              2, {ASTCONFIGURATION, ASTCONFSOCKET}},
      {ASTCONFACTIVECALLS,     ASN_GAUGE,    RONLY, ast_var_Config,              2, {ASTCONFIGURATION, ASTCONFACTIVECALLS}},
      {ASTCONFPROCESSEDCALLS,  ASN_COUNTER,   RONLY, ast_var_Config,              2, {ASTCONFIGURATION, ASTCONFPROCESSEDCALLS}},
      {ASTMODCOUNT,            ASN_INTEGER,   RONLY, ast_var_Modules ,            2, {ASTMODULES, ASTMODCOUNT}},
      {ASTINDCOUNT,            ASN_INTEGER,   RONLY, ast_var_indications,         2, {ASTINDICATIONS, ASTINDCOUNT}},
      {ASTINDCURRENT,          ASN_OCTET_STR, RONLY, ast_var_indications,         2, {ASTINDICATIONS, ASTINDCURRENT}},
      {ASTINDINDEX,            ASN_INTEGER,   RONLY, ast_var_indications_table,   4, {ASTINDICATIONS, ASTINDTABLE, 1, ASTINDINDEX}},
      {ASTINDCOUNTRY,          ASN_OCTET_STR, RONLY, ast_var_indications_table,   4, {ASTINDICATIONS, ASTINDTABLE, 1, ASTINDCOUNTRY}},
      {ASTINDALIAS,            ASN_OCTET_STR, RONLY, ast_var_indications_table,   4, {ASTINDICATIONS, ASTINDTABLE, 1, ASTINDALIAS}},
      {ASTINDDESCRIPTION,      ASN_OCTET_STR, RONLY, ast_var_indications_table,   4, {ASTINDICATIONS, ASTINDTABLE, 1, ASTINDDESCRIPTION}},
      {ASTCHANCOUNT,           ASN_GAUGE,     RONLY, ast_var_channels,            2, {ASTCHANNELS, ASTCHANCOUNT}},
      {ASTCHANINDEX,           ASN_INTEGER,   RONLY, ast_var_channels_table,      4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANINDEX}},
      {ASTCHANNAME,            ASN_OCTET_STR, RONLY, ast_var_channels_table,      4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANNAME}},
      {ASTCHANLANGUAGE,        ASN_OCTET_STR, RONLY, ast_var_channels_table,      4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANLANGUAGE}},
      {ASTCHANTYPE,            ASN_OCTET_STR, RONLY, ast_var_channels_table,      4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANTYPE}},
      {ASTCHANMUSICCLASS,      ASN_OCTET_STR, RONLY, ast_var_channels_table,      4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANMUSICCLASS}},
      {ASTCHANBRIDGE,          ASN_OCTET_STR, RONLY, ast_var_channels_table,      4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANBRIDGE}},
      {ASTCHANMASQ,            ASN_OCTET_STR, RONLY, ast_var_channels_table,      4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANMASQ}},
      {ASTCHANMASQR,           ASN_OCTET_STR, RONLY, ast_var_channels_table,      4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANMASQR}},
      {ASTCHANWHENHANGUP,      ASN_TIMETICKS, RONLY, ast_var_channels_table,      4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANWHENHANGUP}},
      {ASTCHANAPP,             ASN_OCTET_STR, RONLY, ast_var_channels_table,      4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANAPP}},
      {ASTCHANDATA,            ASN_OCTET_STR, RONLY, ast_var_channels_table,      4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANDATA}},
      {ASTCHANCONTEXT,         ASN_OCTET_STR, RONLY, ast_var_channels_table,      4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANCONTEXT}},
      {ASTCHANMACROCONTEXT,    ASN_OCTET_STR, RONLY, ast_var_channels_table,      4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANMACROCONTEXT}},
      {ASTCHANMACROEXTEN,      ASN_OCTET_STR, RONLY, ast_var_channels_table,      4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANMACROEXTEN}},
      {ASTCHANMACROPRI,        ASN_INTEGER,   RONLY, ast_var_channels_table,      4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANMACROPRI}},
      {ASTCHANEXTEN,           ASN_OCTET_STR, RONLY, ast_var_channels_table,      4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANEXTEN}},
      {ASTCHANPRI,             ASN_INTEGER,   RONLY, ast_var_channels_table,      4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANPRI}},
      {ASTCHANACCOUNTCODE,     ASN_OCTET_STR, RONLY, ast_var_channels_table,      4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANACCOUNTCODE}},
      {ASTCHANFORWARDTO,       ASN_OCTET_STR, RONLY, ast_var_channels_table,      4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANFORWARDTO}},
      {ASTCHANUNIQUEID,        ASN_OCTET_STR, RONLY, ast_var_channels_table,      4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANUNIQUEID}},
      {ASTCHANCALLGROUP,       ASN_UNSIGNED,  RONLY, ast_var_channels_table,      4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANCALLGROUP}},
      {ASTCHANPICKUPGROUP,     ASN_UNSIGNED,  RONLY, ast_var_channels_table,      4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANPICKUPGROUP}},
      {ASTCHANSTATE,           ASN_INTEGER,   RONLY, ast_var_channels_table,      4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANSTATE}},
      {ASTCHANMUTED,           ASN_INTEGER,   RONLY, ast_var_channels_table,      4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANMUTED}},
      {ASTCHANRINGS,           ASN_INTEGER,   RONLY, ast_var_channels_table,      4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANRINGS}},
      {ASTCHANCIDDNID,         ASN_OCTET_STR, RONLY, ast_var_channels_table,      4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANCIDDNID}},
      {ASTCHANCIDNUM,          ASN_OCTET_STR, RONLY, ast_var_channels_table,      4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANCIDNUM}},
      {ASTCHANCIDNAME,         ASN_OCTET_STR, RONLY, ast_var_channels_table,      4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANCIDNAME}},
      {ASTCHANCIDANI,          ASN_OCTET_STR, RONLY, ast_var_channels_table,      4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANCIDANI}},
      {ASTCHANCIDRDNIS,        ASN_OCTET_STR, RONLY, ast_var_channels_table,      4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANCIDRDNIS}},
      {ASTCHANCIDPRES,         ASN_OCTET_STR, RONLY, ast_var_channels_table,      4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANCIDPRES}},
      {ASTCHANCIDANI2,         ASN_INTEGER,   RONLY, ast_var_channels_table,      4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANCIDANI2}},
      {ASTCHANCIDTON,          ASN_INTEGER,   RONLY, ast_var_channels_table,      4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANCIDTON}},
      {ASTCHANCIDTNS,          ASN_INTEGER,   RONLY, ast_var_channels_table,      4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANCIDTNS}},
      {ASTCHANAMAFLAGS,        ASN_INTEGER,   RONLY, ast_var_channels_table,      4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANAMAFLAGS}},
      {ASTCHANADSI,            ASN_INTEGER,   RONLY, ast_var_channels_table,      4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANADSI}},
      {ASTCHANTONEZONE,        ASN_OCTET_STR, RONLY, ast_var_channels_table,      4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANTONEZONE}},
      {ASTCHANHANGUPCAUSE,     ASN_INTEGER,   RONLY, ast_var_channels_table,      4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANHANGUPCAUSE}},
      {ASTCHANVARIABLES,       ASN_OCTET_STR, RONLY, ast_var_channels_table,      4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANVARIABLES}},
      {ASTCHANFLAGS,           ASN_OCTET_STR, RONLY, ast_var_channels_table,      4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANFLAGS}},
      {ASTCHANTRANSFERCAP,     ASN_INTEGER,   RONLY, ast_var_channels_table,      4, {ASTCHANNELS, ASTCHANTABLE, 1, ASTCHANTRANSFERCAP}},
      {ASTCHANTYPECOUNT,       ASN_INTEGER,   RONLY, ast_var_channel_types,       2, {ASTCHANNELS, ASTCHANTYPECOUNT}},
      {ASTCHANTYPEINDEX,       ASN_INTEGER,   RONLY, ast_var_channel_types_table, 4, {ASTCHANNELS, ASTCHANTYPETABLE, 1, ASTCHANTYPEINDEX}},
      {ASTCHANTYPENAME,        ASN_OCTET_STR, RONLY, ast_var_channel_types_table, 4, {ASTCHANNELS, ASTCHANTYPETABLE, 1, ASTCHANTYPENAME}},
      {ASTCHANTYPEDESC,        ASN_OCTET_STR, RONLY, ast_var_channel_types_table, 4, {ASTCHANNELS, ASTCHANTYPETABLE, 1, ASTCHANTYPEDESC}},
      {ASTCHANTYPEDEVSTATE,    ASN_INTEGER,   RONLY, ast_var_channel_types_table, 4, {ASTCHANNELS, ASTCHANTYPETABLE, 1, ASTCHANTYPEDEVSTATE}},
      {ASTCHANTYPEINDICATIONS, ASN_INTEGER,   RONLY, ast_var_channel_types_table, 4, {ASTCHANNELS, ASTCHANTYPETABLE, 1, ASTCHANTYPEINDICATIONS}},
      {ASTCHANTYPETRANSFER,    ASN_INTEGER,   RONLY, ast_var_channel_types_table, 4, {ASTCHANNELS, ASTCHANTYPETABLE, 1, ASTCHANTYPETRANSFER}},
      {ASTCHANTYPECHANNELS,    ASN_GAUGE,     RONLY, ast_var_channel_types_table, 4, {ASTCHANNELS, ASTCHANTYPETABLE, 1, ASTCHANTYPECHANNELS}},
      {ASTCHANBRIDGECOUNT,     ASN_GAUGE,     RONLY, ast_var_channel_bridge,      3, {ASTCHANNELS, ASTCHANSCALARS, ASTCHANBRIDGECOUNT}},
   };

   register_sysORTable(asterisk_oid, OID_LENGTH(asterisk_oid),
         "ASTERISK-MIB implementation for Asterisk.");

   REGISTER_MIB("res_snmp", asterisk_vars, variable4, asterisk_oid);

   snmp_register_callback(SNMP_CALLBACK_LIBRARY,
            SNMP_CALLBACK_SHUTDOWN,
            term_asterisk_mib, NULL);
}

/*
 * Local Variables:
 * c-basic-offset: 4
 * c-file-offsets: ((case-label . 0))
 * tab-width: 4
 * indent-tabs-mode: t
 * End:
 */