snmpagent/netsnmp_bridge.c

   1 /*
   2  * Note: this file originally auto-generated by mib2c using
   3  *        : mib2c.scalar.conf,v 1.9 2005/01/07 09:37:18 dts12 Exp $
   4  *        : mib2c.create-dataset.conf,v 5.4 2004/02/02 19:06:53 rstory Exp $
   5  *        : mib2c.notify.conf,v 5.3 2004/04/15 12:29:19 dts12 Exp $
   6  */
   7
   8 #include "netsnmp_bridge.h"
   9
  10 static oid      snmptrap_oid[] = { 1, 3, 6, 1, 6, 3, 1, 1, 4, 1, 0 };
  11 static unsigned int callback_id = 0;
  12
  13 static netsnmp_table_data_set *vs_table_set = NULL;
  14 static netsnmp_table_data_set *rs_table_set = NULL;
  15
  16 /** Initializes the ultramonkey-l7 module */
  17 void
  18 init_netsnmp_bridge(void *clientarg)
  19 {
  20         static oid      um7LogVsdNetwork_oid[] =
  21         { 1, 3, 6, 1, 4, 1, 60000, 1, 1, 3, 1, 1 };
  22         static oid      um7LogVsdNetworkBandwidth_oid[] =
  23         { 1, 3, 6, 1, 4, 1, 60000, 1, 1, 3, 1, 2 };
  24         static oid      um7LogVsdNetworkNumConnection_oid[] =
  25         { 1, 3, 6, 1, 4, 1, 60000, 1, 1, 3, 1, 3 };
  26         static oid      um7LogVsdNetworkQoS_oid[] =
  27         { 1, 3, 6, 1, 4, 1, 60000, 1, 1, 3, 1, 4 };
  28         static oid      um7LogVsdVirtualService_oid[] =
  29         { 1, 3, 6, 1, 4, 1, 60000, 1, 1, 3, 1, 5 };
  30         static oid      um7LogVsdRealServer_oid[] =
  31         { 1, 3, 6, 1, 4, 1, 60000, 1, 1, 3, 1, 6 };
  32         static oid      um7LogVsdRealServerBalancing_oid[] =
  33         { 1, 3, 6, 1, 4, 1, 60000, 1, 1, 3, 1, 7 };
  34         static oid      um7LogVsdSorryServer_oid[] =
  35         { 1, 3, 6, 1, 4, 1, 60000, 1, 1, 3, 1, 8 };
  36         static oid      um7LogVsdReplication_oid[] =
  37         { 1, 3, 6, 1, 4, 1, 60000, 1, 1, 3, 1, 9 };
  38         static oid      um7LogVsdStartStop_oid[] =
  39         { 1, 3, 6, 1, 4, 1, 60000, 1, 1, 3, 1, 10 };
  40         static oid      um7LogVsdSystem_oid[] =
  41         { 1, 3, 6, 1, 4, 1, 60000, 1, 1, 3, 1, 11 };
  42         static oid      um7LogVsdSystemMemory_oid[] =
  43         { 1, 3, 6, 1, 4, 1, 60000, 1, 1, 3, 1, 12 };
  44         static oid      um7LogVsdSystemSocket_oid[] =
  45         { 1, 3, 6, 1, 4, 1, 60000, 1, 1, 3, 1, 13 };
  46         static oid      um7LogVsdSystemSignal_oid[] =
  47         { 1, 3, 6, 1, 4, 1, 60000, 1, 1, 3, 1, 14 };
  48         static oid      um7LogVsdEnvironment_oid[] =
  49         { 1, 3, 6, 1, 4, 1, 60000, 1, 1, 3, 1, 15 };
  50         static oid      um7LogVsdEnvironmentParameter_oid[] =
  51         { 1, 3, 6, 1, 4, 1, 60000, 1, 1, 3, 1, 16 };
  52         static oid      um7LogVsdLogger_oid[] =
  53         { 1, 3, 6, 1, 4, 1, 60000, 1, 1, 3, 1, 17 };
  54         static oid      um7LogVsdParameter_oid[] =
  55         { 1, 3, 6, 1, 4, 1, 60000, 1, 1, 3, 1, 18 };
  56         static oid      um7LogVsdEvent_oid[] =
  57         { 1, 3, 6, 1, 4, 1, 60000, 1, 1, 3, 1, 19 };
  58         static oid      um7LogVsdSchedule_oid[] =
  59         { 1, 3, 6, 1, 4, 1, 60000, 1, 1, 3, 1, 20 };
  60         static oid      um7LogVsdProgram_oid[] =
  61         { 1, 3, 6, 1, 4, 1, 60000, 1, 1, 3, 1, 21 };
  62         static oid      um7LogVsdProtocol_oid[] =
  63         { 1, 3, 6, 1, 4, 1, 60000, 1, 1, 3, 1, 22 };
  64         static oid      um7LogVsdModule_oid[] =
  65         { 1, 3, 6, 1, 4, 1, 60000, 1, 1, 3, 1, 23 };
  66         static oid      um7LogVsadmParse_oid[] =
  67         { 1, 3, 6, 1, 4, 1, 60000, 1, 1, 3, 2, 1 };
  68         static oid      um7LogVsadmOperate_oid[] =
  69         { 1, 3, 6, 1, 4, 1, 60000, 1, 1, 3, 2, 2 };
  70         static oid      um7LogVsadmCommunicate_oid[] =
  71         { 1, 3, 6, 1, 4, 1, 60000, 1, 1, 3, 2, 3 };
  72         static oid      um7LogVsadmConfigResult_oid[] =
  73         { 1, 3, 6, 1, 4, 1, 60000, 1, 1, 3, 2, 4 };
  74         static oid      um7LogVsadmCommon_oid[] =
  75         { 1, 3, 6, 1, 4, 1, 60000, 1, 1, 3, 2, 5 };
  76         static oid      um7LogVsadmLogger_oid[] =
  77         { 1, 3, 6, 1, 4, 1, 60000, 1, 1, 3, 2, 6 };
  78         static oid      um7LogVsadmParameter_oid[] =
  79         { 1, 3, 6, 1, 4, 1, 60000, 1, 1, 3, 2, 7 };
  80         static oid      um7LogVsadmProtocol_oid[] =
  81         { 1, 3, 6, 1, 4, 1, 60000, 1, 1, 3, 2, 8 };
  82         static oid      um7LogVsadmModule_oid[] =
  83         { 1, 3, 6, 1, 4, 1, 60000, 1, 1, 3, 2, 9 };
  84         static oid      um7LogSnmpStartStop_oid[] =
  85         { 1, 3, 6, 1, 4, 1, 60000, 1, 1, 3, 3, 1 };
  86         static oid      um7LogSnmpManagerReceive_oid[] =
  87         { 1, 3, 6, 1, 4, 1, 60000, 1, 1, 3, 3, 2 };
  88         static oid      um7LogSnmpManagerSend_oid[] =
  89         { 1, 3, 6, 1, 4, 1, 60000, 1, 1, 3, 3, 3 };
  90         static oid      um7LogSnmpL7vsdReceive_oid[] =
  91         { 1, 3, 6, 1, 4, 1, 60000, 1, 1, 3, 3, 4 };
  92         static oid      um7LogSnmpL7vsdSend_oid[] =
  93         { 1, 3, 6, 1, 4, 1, 60000, 1, 1, 3, 3, 5 };
  94         static oid      um7LogSnmpLogger_oid[] =
  95         { 1, 3, 6, 1, 4, 1, 60000, 1, 1, 3, 3, 6 };
  96         static oid      um7LogSnmpParameter_oid[] =
  97         { 1, 3, 6, 1, 4, 1, 60000, 1, 1, 3, 3, 7 };
  98         static oid      um7StatMessage_oid[] =
  99         { 1, 3, 6, 1, 4, 1, 60000, 1, 1, 4, 1 };
 100         static oid      um7StatReplication_oid[] =
 101         { 1, 3, 6, 1, 4, 1, 60000, 1, 1, 4, 2 };
 102         static oid      um7StatSnmpAgent_oid[] =
 103         { 1, 3, 6, 1, 4, 1, 60000, 1, 1, 4, 3 };
 104
 105         DEBUGMSGTL(("ultramonkey-l7", "Initializing\n"));
 106
 107         netsnmp_register_scalar(netsnmp_create_handler_registration
 108         ("um7LogVsdNetwork", handle_um7LogVsdNetwork,
 109         um7LogVsdNetwork_oid,
 110         OID_LENGTH(um7LogVsdNetwork_oid),
 111         HANDLER_CAN_RONLY));
 112         netsnmp_register_scalar(netsnmp_create_handler_registration
 113         ("um7LogVsdNetworkBandwidth",
 114         handle_um7LogVsdNetworkBandwidth,
 115         um7LogVsdNetworkBandwidth_oid,
 116         OID_LENGTH(um7LogVsdNetworkBandwidth_oid),
 117         HANDLER_CAN_RONLY));
 118         netsnmp_register_scalar(netsnmp_create_handler_registration
 119         ("um7LogVsdNetworkNumConnection",
 120         handle_um7LogVsdNetworkNumConnection,
 121         um7LogVsdNetworkNumConnection_oid,
 122         OID_LENGTH(um7LogVsdNetworkNumConnection_oid),
 123         HANDLER_CAN_RONLY));
 124         netsnmp_register_scalar(netsnmp_create_handler_registration
 125         ("um7LogVsdNetworkQoS",
 126         handle_um7LogVsdNetworkQoS,
 127         um7LogVsdNetworkQoS_oid,
 128         OID_LENGTH(um7LogVsdNetworkQoS_oid),
 129         HANDLER_CAN_RONLY));
 130         netsnmp_register_scalar(netsnmp_create_handler_registration
 131         ("um7LogVsdVirtualService",
 132         handle_um7LogVsdVirtualService,
 133         um7LogVsdVirtualService_oid,
 134         OID_LENGTH(um7LogVsdVirtualService_oid),
 135         HANDLER_CAN_RONLY));
 136         netsnmp_register_scalar(netsnmp_create_handler_registration
 137         ("um7LogVsdRealServer",
 138         handle_um7LogVsdRealServer,
 139         um7LogVsdRealServer_oid,
 140         OID_LENGTH(um7LogVsdRealServer_oid),
 141         HANDLER_CAN_RONLY));
 142         netsnmp_register_scalar(netsnmp_create_handler_registration
 143         ("um7LogVsdRealServerBalancing",
 144         handle_um7LogVsdRealServerBalancing,
 145         um7LogVsdRealServerBalancing_oid,
 146         OID_LENGTH(um7LogVsdRealServerBalancing_oid),
 147         HANDLER_CAN_RONLY));
 148         netsnmp_register_scalar(netsnmp_create_handler_registration
 149         ("um7LogVsdSorryServer",
 150         handle_um7LogVsdSorryServer,
 151         um7LogVsdSorryServer_oid,
 152         OID_LENGTH(um7LogVsdSorryServer_oid),
 153         HANDLER_CAN_RONLY));
 154         netsnmp_register_scalar(netsnmp_create_handler_registration
 155         ("um7LogVsdReplication",
 156         handle_um7LogVsdReplication,
 157         um7LogVsdReplication_oid,
 158         OID_LENGTH(um7LogVsdReplication_oid),
 159         HANDLER_CAN_RONLY));
 160         netsnmp_register_scalar(netsnmp_create_handler_registration
 161         ("um7LogVsdStartStop",
 162         handle_um7LogVsdStartStop,
 163         um7LogVsdStartStop_oid,
 164         OID_LENGTH(um7LogVsdStartStop_oid),
 165         HANDLER_CAN_RONLY));
 166         netsnmp_register_scalar(netsnmp_create_handler_registration
 167         ("um7LogVsdSystem", handle_um7LogVsdSystem,
 168         um7LogVsdSystem_oid,
 169         OID_LENGTH(um7LogVsdSystem_oid),
 170         HANDLER_CAN_RONLY));
 171         netsnmp_register_scalar(netsnmp_create_handler_registration
 172         ("um7LogVsdSystemMemory",
 173         handle_um7LogVsdSystemMemory,
 174         um7LogVsdSystemMemory_oid,
 175         OID_LENGTH(um7LogVsdSystemMemory_oid),
 176         HANDLER_CAN_RONLY));
 177         netsnmp_register_scalar(netsnmp_create_handler_registration
 178         ("um7LogVsdSystemSocket",
 179         handle_um7LogVsdSystemSocket,
 180         um7LogVsdSystemSocket_oid,
 181         OID_LENGTH(um7LogVsdSystemSocket_oid),
 182         HANDLER_CAN_RONLY));
 183         netsnmp_register_scalar(netsnmp_create_handler_registration
 184         ("um7LogVsdSystemSignal",
 185         handle_um7LogVsdSystemSignal,
 186         um7LogVsdSystemSignal_oid,
 187         OID_LENGTH(um7LogVsdSystemSignal_oid),
 188         HANDLER_CAN_RONLY));
 189         netsnmp_register_scalar(netsnmp_create_handler_registration
 190         ("um7LogVsdEnvironment",
 191         handle_um7LogVsdEnvironment,
 192         um7LogVsdEnvironment_oid,
 193         OID_LENGTH(um7LogVsdEnvironment_oid),
 194         HANDLER_CAN_RONLY));
 195         netsnmp_register_scalar(netsnmp_create_handler_registration
 196         ("um7LogVsdEnvironmentParameter",
 197         handle_um7LogVsdEnvironmentParameter,
 198         um7LogVsdEnvironmentParameter_oid,
 199         OID_LENGTH(um7LogVsdEnvironmentParameter_oid),
 200         HANDLER_CAN_RONLY));
 201         netsnmp_register_scalar(netsnmp_create_handler_registration
 202         ("um7LogVsdLogger", handle_um7LogVsdLogger,
 203         um7LogVsdLogger_oid,
 204         OID_LENGTH(um7LogVsdLogger_oid),
 205         HANDLER_CAN_RONLY));
 206         netsnmp_register_scalar(netsnmp_create_handler_registration
 207         ("um7LogVsdParameter",
 208         handle_um7LogVsdParameter,
 209         um7LogVsdParameter_oid,
 210         OID_LENGTH(um7LogVsdParameter_oid),
 211         HANDLER_CAN_RONLY));
 212         netsnmp_register_scalar(netsnmp_create_handler_registration
 213         ("um7LogVsdEvent", handle_um7LogVsdEvent,
 214         um7LogVsdEvent_oid,
 215         OID_LENGTH(um7LogVsdEvent_oid),
 216         HANDLER_CAN_RONLY));
 217         netsnmp_register_scalar(netsnmp_create_handler_registration
 218         ("um7LogVsdSchedule", handle_um7LogVsdSchedule,
 219         um7LogVsdSchedule_oid,
 220         OID_LENGTH(um7LogVsdSchedule_oid),
 221         HANDLER_CAN_RONLY));
 222         netsnmp_register_scalar(netsnmp_create_handler_registration
 223         ("um7LogVsdProgram", handle_um7LogVsdProgram,
 224         um7LogVsdProgram_oid,
 225         OID_LENGTH(um7LogVsdProgram_oid),
 226         HANDLER_CAN_RONLY));
 227         netsnmp_register_scalar(netsnmp_create_handler_registration
 228         ("um7LogVsdProtocol", handle_um7LogVsdProtocol,
 229         um7LogVsdProtocol_oid,
 230         OID_LENGTH(um7LogVsdProtocol_oid),
 231         HANDLER_CAN_RONLY));
 232         netsnmp_register_scalar(netsnmp_create_handler_registration
 233         ("um7LogVsdModule", handle_um7LogVsdModule,
 234         um7LogVsdModule_oid,
 235         OID_LENGTH(um7LogVsdModule_oid),
 236         HANDLER_CAN_RONLY));
 237         netsnmp_register_scalar(netsnmp_create_handler_registration
 238         ("um7LogVsadmParse", handle_um7LogVsadmParse,
 239         um7LogVsadmParse_oid,
 240         OID_LENGTH(um7LogVsadmParse_oid),
 241         HANDLER_CAN_RONLY));
 242         netsnmp_register_scalar(netsnmp_create_handler_registration
 243         ("um7LogVsadmOperate",
 244         handle_um7LogVsadmOperate,
 245         um7LogVsadmOperate_oid,
 246         OID_LENGTH(um7LogVsadmOperate_oid),
 247         HANDLER_CAN_RONLY));
 248         netsnmp_register_scalar(netsnmp_create_handler_registration
 249         ("um7LogVsadmCommunicate",
 250         handle_um7LogVsadmCommunicate,
 251         um7LogVsadmCommunicate_oid,
 252         OID_LENGTH(um7LogVsadmCommunicate_oid),
 253         HANDLER_CAN_RONLY));
 254         netsnmp_register_scalar(netsnmp_create_handler_registration
 255         ("um7LogVsadmConfigResult",
 256         handle_um7LogVsadmConfigResult,
 257         um7LogVsadmConfigResult_oid,
 258         OID_LENGTH(um7LogVsadmConfigResult_oid),
 259         HANDLER_CAN_RONLY));
 260         netsnmp_register_scalar(netsnmp_create_handler_registration
 261         ("um7LogVsadmCommon", handle_um7LogVsadmCommon,
 262         um7LogVsadmCommon_oid,
 263         OID_LENGTH(um7LogVsadmCommon_oid),
 264         HANDLER_CAN_RONLY));
 265         netsnmp_register_scalar(netsnmp_create_handler_registration
 266         ("um7LogVsadmLogger", handle_um7LogVsadmLogger,
 267         um7LogVsadmLogger_oid,
 268         OID_LENGTH(um7LogVsadmLogger_oid),
 269         HANDLER_CAN_RONLY));
 270         netsnmp_register_scalar(netsnmp_create_handler_registration
 271         ("um7LogVsadmParameter",
 272         handle_um7LogVsadmParameter,
 273         um7LogVsadmParameter_oid,
 274         OID_LENGTH(um7LogVsadmParameter_oid),
 275         HANDLER_CAN_RONLY));
 276         netsnmp_register_scalar(netsnmp_create_handler_registration
 277         ("um7LogVsadmProtocol",
 278         handle_um7LogVsadmProtocol,
 279         um7LogVsadmProtocol_oid,
 280         OID_LENGTH(um7LogVsadmProtocol_oid),
 281         HANDLER_CAN_RONLY));
 282         netsnmp_register_scalar(netsnmp_create_handler_registration
 283         ("um7LogVsadmModule", handle_um7LogVsadmModule,
 284         um7LogVsadmModule_oid,
 285         OID_LENGTH(um7LogVsadmModule_oid),
 286         HANDLER_CAN_RONLY));
 287         netsnmp_register_scalar(netsnmp_create_handler_registration
 288         ("um7LogSnmpStartStop",
 289         handle_um7LogSnmpStartStop,
 290         um7LogSnmpStartStop_oid,
 291         OID_LENGTH(um7LogSnmpStartStop_oid),
 292         HANDLER_CAN_RONLY));
 293         netsnmp_register_scalar(netsnmp_create_handler_registration
 294         ("um7LogSnmpManagerReceive",
 295         handle_um7LogSnmpManagerReceive,
 296         um7LogSnmpManagerReceive_oid,
 297         OID_LENGTH(um7LogSnmpManagerReceive_oid),
 298         HANDLER_CAN_RONLY));
 299         netsnmp_register_scalar(netsnmp_create_handler_registration
 300         ("um7LogSnmpManagerSend",
 301         handle_um7LogSnmpManagerSend,
 302         um7LogSnmpManagerSend_oid,
 303         OID_LENGTH(um7LogSnmpManagerSend_oid),
 304         HANDLER_CAN_RONLY));
 305         netsnmp_register_scalar(netsnmp_create_handler_registration
 306         ("um7LogSnmpL7vsdReceive",
 307         handle_um7LogSnmpL7vsdReceive,
 308         um7LogSnmpL7vsdReceive_oid,
 309         OID_LENGTH(um7LogSnmpL7vsdReceive_oid),
 310         HANDLER_CAN_RONLY));
 311         netsnmp_register_scalar(netsnmp_create_handler_registration
 312         ("um7LogSnmpL7vsdSend",
 313         handle_um7LogSnmpL7vsdSend,
 314         um7LogSnmpL7vsdSend_oid,
 315         OID_LENGTH(um7LogSnmpL7vsdSend_oid),
 316         HANDLER_CAN_RONLY));
 317         netsnmp_register_scalar(netsnmp_create_handler_registration
 318         ("um7LogSnmpLogger", handle_um7LogSnmpLogger,
 319         um7LogSnmpLogger_oid,
 320         OID_LENGTH(um7LogSnmpLogger_oid),
 321         HANDLER_CAN_RONLY));
 322         netsnmp_register_scalar(netsnmp_create_handler_registration
 323         ("um7LogSnmpParameter",
 324         handle_um7LogSnmpParameter,
 325         um7LogSnmpParameter_oid,
 326         OID_LENGTH(um7LogSnmpParameter_oid),
 327         HANDLER_CAN_RONLY));
 328         netsnmp_register_scalar(netsnmp_create_handler_registration
 329         ("um7StatMessage", handle_um7StatMessage,
 330         um7StatMessage_oid,
 331         OID_LENGTH(um7StatMessage_oid),
 332         HANDLER_CAN_RONLY));
 333         netsnmp_register_scalar(netsnmp_create_handler_registration
 334         ("um7StatReplication",
 335         handle_um7StatReplication,
 336         um7StatReplication_oid,
 337         OID_LENGTH(um7StatReplication_oid),
 338         HANDLER_CAN_RONLY));
 339         netsnmp_register_scalar(netsnmp_create_handler_registration
 340         ("um7StatSnmpAgent", handle_um7StatSnmpAgent,
 341         um7StatSnmpAgent_oid,
 342         OID_LENGTH(um7StatSnmpAgent_oid),
 343         HANDLER_CAN_RONLY));
 344
 345         /*
 346          * here we initialize all the tables we're planning on supporting
 347          */
 348         initialize_table_um7VirtualServiceTable();
 349         initialize_table_um7RealServerTable();
 350
 351         // request mib collection every 1 sec.
 352         callback_id = snmp_alarm_register(REPEAT_SEC, SA_REPEAT, getL7vsdData, clientarg);
 353         if (callback_id == 0) {
 354                 // TODO error
 355         }
 356 }
 357
 358 int
 359 handle_um7LogVsdNetwork(netsnmp_mib_handler *handler,
 360 netsnmp_handler_registration *reginfo,
 361 netsnmp_agent_request_info *reqinfo,
 362 netsnmp_request_info *requests)
 363 {
 364         struct l7vsd_log_level *log = l7ag_store_mibdata::getInstance().getVsdLogmibdata();
 365
 366         switch (reqinfo->mode) {
 367         case MODE_GET:
 368                 snmp_set_var_typed_value(requests->requestvb, ASN_INTEGER,
 369                 (u_char *) &log->network,
 370                 sizeof(l7vs::LOG_LEVEL_TAG));
 371                 break;
 372
 373         default:
 374                 snmp_log(LOG_ERR, "unknown mode (%d) in handle_um7LogVsdNetwork\n",
 375                 reqinfo->mode);
 376                 return SNMP_ERR_GENERR;
 377         }
 378
 379         return SNMP_ERR_NOERROR;
 380 }
 381
 382 int
 383 handle_um7LogVsdNetworkBandwidth(netsnmp_mib_handler *handler,
 384 netsnmp_handler_registration *reginfo,
 385 netsnmp_agent_request_info *reqinfo,
 386 netsnmp_request_info *requests)
 387 {
 388         struct l7vsd_log_level *log = l7ag_store_mibdata::getInstance().getVsdLogmibdata();
 389
 390         switch (reqinfo->mode) {
 391         case MODE_GET:
 392                 snmp_set_var_typed_value(requests->requestvb, ASN_INTEGER,
 393                 (u_char *) &log->networkBandwidth,
 394                 sizeof(l7vs::LOG_LEVEL_TAG));
 395                 break;
 396
 397         default:
 398                 snmp_log(LOG_ERR,
 399                 "unknown mode (%d) in handle_um7LogVsdNetworkBandwidth\n",
 400                 reqinfo->mode);
 401                 return SNMP_ERR_GENERR;
 402         }
 403
 404         return SNMP_ERR_NOERROR;
 405 }
 406
 407 int
 408 handle_um7LogVsdNetworkNumConnection(netsnmp_mib_handler *handler,
 409 netsnmp_handler_registration *reginfo,
 410 netsnmp_agent_request_info *reqinfo,
 411 netsnmp_request_info *requests)
 412 {
 413         struct l7vsd_log_level *log = l7ag_store_mibdata::getInstance().getVsdLogmibdata();
 414
 415         switch (reqinfo->mode) {
 416         case MODE_GET:
 417                 snmp_set_var_typed_value(requests->requestvb, ASN_INTEGER,
 418                 (u_char *) &log->networkNumConnection,
 419                 sizeof(l7vs::LOG_LEVEL_TAG));
 420                 break;
 421
 422         default:
 423                 snmp_log(LOG_ERR,
 424                 "unknown mode (%d) in handle_um7LogVsdNetworkNumConnection\n",
 425                 reqinfo->mode);
 426                 return SNMP_ERR_GENERR;
 427         }
 428
 429         return SNMP_ERR_NOERROR;
 430 }
 431
 432 int
 433 handle_um7LogVsdNetworkQoS(netsnmp_mib_handler *handler,
 434 netsnmp_handler_registration *reginfo,
 435 netsnmp_agent_request_info *reqinfo,
 436 netsnmp_request_info *requests)
 437 {
 438         struct l7vsd_log_level *log = l7ag_store_mibdata::getInstance().getVsdLogmibdata();
 439
 440         switch (reqinfo->mode) {
 441         case MODE_GET:
 442                 snmp_set_var_typed_value(requests->requestvb, ASN_INTEGER,
 443                 (u_char *) &log->networkQoS,
 444                 sizeof(l7vs::LOG_LEVEL_TAG));
 445                 break;
 446
 447         default:
 448                 snmp_log(LOG_ERR,
 449                 "unknown mode (%d) in handle_um7LogVsdNetworkQoS\n",
 450                 reqinfo->mode);
 451                 return SNMP_ERR_GENERR;
 452         }
 453
 454         return SNMP_ERR_NOERROR;
 455 }
 456
 457 int
 458 handle_um7LogVsdVirtualService(netsnmp_mib_handler *handler,
 459 netsnmp_handler_registration *reginfo,
 460 netsnmp_agent_request_info *reqinfo,
 461 netsnmp_request_info *requests)
 462 {
 463         struct l7vsd_log_level *log = l7ag_store_mibdata::getInstance().getVsdLogmibdata();
 464
 465         switch (reqinfo->mode) {
 466         case MODE_GET:
 467                 snmp_set_var_typed_value(requests->requestvb, ASN_INTEGER,
 468                 (u_char *) &log->virtualService,
 469                 sizeof(l7vs::LOG_LEVEL_TAG));
 470                 break;
 471
 472         default:
 473                 snmp_log(LOG_ERR,
 474                 "unknown mode (%d) in handle_um7LogVsdVirtualService\n",
 475                 reqinfo->mode);
 476                 return SNMP_ERR_GENERR;
 477         }
 478
 479         return SNMP_ERR_NOERROR;
 480 }
 481
 482 int
 483 handle_um7LogVsdRealServer(netsnmp_mib_handler *handler,
 484 netsnmp_handler_registration *reginfo,
 485 netsnmp_agent_request_info *reqinfo,
 486 netsnmp_request_info *requests)
 487 {
 488         struct l7vsd_log_level *log = l7ag_store_mibdata::getInstance().getVsdLogmibdata();
 489
 490         switch (reqinfo->mode) {
 491         case MODE_GET:
 492                 snmp_set_var_typed_value(requests->requestvb, ASN_INTEGER,
 493                 (u_char *) &log->realServer,
 494                 sizeof(l7vs::LOG_LEVEL_TAG));
 495                 break;
 496
 497         default:
 498                 snmp_log(LOG_ERR,
 499                 "unknown mode (%d) in handle_um7LogVsdRealServer\n",
 500                 reqinfo->mode);
 501                 return SNMP_ERR_GENERR;
 502         }
 503
 504         return SNMP_ERR_NOERROR;
 505 }
 506
 507 int
 508 handle_um7LogVsdRealServerBalancing(netsnmp_mib_handler *handler,
 509 netsnmp_handler_registration *reginfo,
 510 netsnmp_agent_request_info *reqinfo,
 511 netsnmp_request_info *requests)
 512 {
 513         struct l7vsd_log_level *log = l7ag_store_mibdata::getInstance().getVsdLogmibdata();
 514
 515         switch (reqinfo->mode) {
 516         case MODE_GET:
 517                 snmp_set_var_typed_value(requests->requestvb, ASN_INTEGER,
 518                 (u_char *) &log->realServerBalancing,
 519                 sizeof(l7vs::LOG_LEVEL_TAG));
 520                 break;
 521
 522         default:
 523                 snmp_log(LOG_ERR,
 524                 "unknown mode (%d) in handle_um7LogVsdRealServerBalancing\n",
 525                 reqinfo->mode);
 526                 return SNMP_ERR_GENERR;
 527         }
 528
 529         return SNMP_ERR_NOERROR;
 530 }
 531
 532 int
 533 handle_um7LogVsdSorryServer(netsnmp_mib_handler *handler,
 534 netsnmp_handler_registration *reginfo,
 535 netsnmp_agent_request_info *reqinfo,
 536 netsnmp_request_info *requests)
 537 {
 538         struct l7vsd_log_level *log = l7ag_store_mibdata::getInstance().getVsdLogmibdata();
 539
 540         switch (reqinfo->mode) {
 541         case MODE_GET:
 542                 snmp_set_var_typed_value(requests->requestvb, ASN_INTEGER,
 543                 (u_char *) &log->sorryServer,
 544                 sizeof(l7vs::LOG_LEVEL_TAG));
 545                 break;
 546
 547         default:
 548                 snmp_log(LOG_ERR,
 549                 "unknown mode (%d) in handle_um7LogVsdSorryServer\n",
 550                 reqinfo->mode);
 551                 return SNMP_ERR_GENERR;
 552         }
 553
 554         return SNMP_ERR_NOERROR;
 555 }
 556
 557 int
 558 handle_um7LogVsdReplication(netsnmp_mib_handler *handler,
 559 netsnmp_handler_registration *reginfo,
 560 netsnmp_agent_request_info *reqinfo,
 561 netsnmp_request_info *requests)
 562 {
 563         struct l7vsd_log_level *log = l7ag_store_mibdata::getInstance().getVsdLogmibdata();
 564
 565         switch (reqinfo->mode) {
 566         case MODE_GET:
 567                 snmp_set_var_typed_value(requests->requestvb, ASN_INTEGER,
 568                 (u_char *) &log->replication,
 569                 sizeof(l7vs::LOG_LEVEL_TAG));
 570                 break;
 571
 572         default:
 573                 snmp_log(LOG_ERR,
 574                 "unknown mode (%d) in handle_um7LogVsdReplication\n",
 575                 reqinfo->mode);
 576                 return SNMP_ERR_GENERR;
 577         }
 578
 579         return SNMP_ERR_NOERROR;
 580 }
 581
 582 int
 583 handle_um7LogVsdStartStop(netsnmp_mib_handler *handler,
 584 netsnmp_handler_registration *reginfo,
 585 netsnmp_agent_request_info *reqinfo,
 586 netsnmp_request_info *requests)
 587 {
 588         struct l7vsd_log_level *log = l7ag_store_mibdata::getInstance().getVsdLogmibdata();
 589
 590         switch (reqinfo->mode) {
 591         case MODE_GET:
 592                 snmp_set_var_typed_value(requests->requestvb, ASN_INTEGER,
 593                 (u_char *) &log->startStop,
 594                 sizeof(l7vs::LOG_LEVEL_TAG));
 595                 break;
 596
 597         default:
 598                 snmp_log(LOG_ERR,
 599                 "unknown mode (%d) in handle_um7LogVsdStartStop\n",
 600                 reqinfo->mode);
 601                 return SNMP_ERR_GENERR;
 602         }
 603
 604         return SNMP_ERR_NOERROR;
 605 }
 606
 607 int
 608 handle_um7LogVsdSystem(netsnmp_mib_handler *handler,
 609 netsnmp_handler_registration *reginfo,
 610 netsnmp_agent_request_info *reqinfo,
 611 netsnmp_request_info *requests)
 612 {
 613         struct l7vsd_log_level *log = l7ag_store_mibdata::getInstance().getVsdLogmibdata();
 614
 615         switch (reqinfo->mode) {
 616         case MODE_GET:
 617                 snmp_set_var_typed_value(requests->requestvb, ASN_INTEGER,
 618                 (u_char *) &log->system,
 619                 sizeof(l7vs::LOG_LEVEL_TAG));
 620                 break;
 621
 622         default:
 623                 snmp_log(LOG_ERR, "unknown mode (%d) in handle_um7LogVsdSystem\n",
 624                 reqinfo->mode);
 625                 return SNMP_ERR_GENERR;
 626         }
 627
 628         return SNMP_ERR_NOERROR;
 629 }
 630
 631 int
 632 handle_um7LogVsdSystemMemory(netsnmp_mib_handler *handler,
 633 netsnmp_handler_registration *reginfo,
 634 netsnmp_agent_request_info *reqinfo,
 635 netsnmp_request_info *requests)
 636 {
 637         struct l7vsd_log_level *log = l7ag_store_mibdata::getInstance().getVsdLogmibdata();
 638
 639         switch (reqinfo->mode) {
 640         case MODE_GET:
 641                 snmp_set_var_typed_value(requests->requestvb, ASN_INTEGER,
 642                 (u_char *) &log->systemMemory,
 643                 sizeof(l7vs::LOG_LEVEL_TAG));
 644                 break;
 645
 646         default:
 647                 snmp_log(LOG_ERR,
 648                 "unknown mode (%d) in handle_um7LogVsdSystemMemory\n",
 649                 reqinfo->mode);
 650                 return SNMP_ERR_GENERR;
 651         }
 652
 653         return SNMP_ERR_NOERROR;
 654 }
 655
 656 int
 657 handle_um7LogVsdSystemSocket(netsnmp_mib_handler *handler,
 658 netsnmp_handler_registration *reginfo,
 659 netsnmp_agent_request_info *reqinfo,
 660 netsnmp_request_info *requests)
 661 {
 662         struct l7vsd_log_level *log = l7ag_store_mibdata::getInstance().getVsdLogmibdata();
 663
 664         switch (reqinfo->mode) {
 665         case MODE_GET:
 666                 snmp_set_var_typed_value(requests->requestvb, ASN_INTEGER,
 667                 (u_char *) &log->systemSocket,
 668                 sizeof(l7vs::LOG_LEVEL_TAG));
 669                 break;
 670
 671         default:
 672                 snmp_log(LOG_ERR,
 673                 "unknown mode (%d) in handle_um7LogVsdSystemSocket\n",
 674                 reqinfo->mode);
 675                 return SNMP_ERR_GENERR;
 676         }
 677
 678         return SNMP_ERR_NOERROR;
 679 }
 680
 681 int
 682 handle_um7LogVsdSystemSignal(netsnmp_mib_handler *handler,
 683 netsnmp_handler_registration *reginfo,
 684 netsnmp_agent_request_info *reqinfo,
 685 netsnmp_request_info *requests)
 686 {
 687         struct l7vsd_log_level *log = l7ag_store_mibdata::getInstance().getVsdLogmibdata();
 688
 689         switch (reqinfo->mode) {
 690         case MODE_GET:
 691                 snmp_set_var_typed_value(requests->requestvb, ASN_INTEGER,
 692                 (u_char *) &log->systemSignal,
 693                 sizeof(l7vs::LOG_LEVEL_TAG));
 694                 break;
 695
 696         default:
 697                 snmp_log(LOG_ERR,
 698                 "unknown mode (%d) in handle_um7LogVsdSystemSignal\n",
 699                 reqinfo->mode);
 700                 return SNMP_ERR_GENERR;
 701         }
 702
 703         return SNMP_ERR_NOERROR;
 704 }
 705
 706 int
 707 handle_um7LogVsdEnvironment(netsnmp_mib_handler *handler,
 708 netsnmp_handler_registration *reginfo,
 709 netsnmp_agent_request_info *reqinfo,
 710 netsnmp_request_info *requests)
 711 {
 712         struct l7vsd_log_level *log = l7ag_store_mibdata::getInstance().getVsdLogmibdata();
 713
 714         switch (reqinfo->mode) {
 715         case MODE_GET:
 716                 snmp_set_var_typed_value(requests->requestvb, ASN_INTEGER,
 717                 (u_char *) &log->environment,
 718                 sizeof(l7vs::LOG_LEVEL_TAG));
 719                 break;
 720
 721         default:
 722                 snmp_log(LOG_ERR,
 723                 "unknown mode (%d) in handle_um7LogVsdEnvironment\n",
 724                 reqinfo->mode);
 725                 return SNMP_ERR_GENERR;
 726         }
 727
 728         return SNMP_ERR_NOERROR;
 729 }
 730
 731 int
 732 handle_um7LogVsdEnvironmentParameter(netsnmp_mib_handler *handler,
 733 netsnmp_handler_registration *reginfo,
 734 netsnmp_agent_request_info *reqinfo,
 735 netsnmp_request_info *requests)
 736 {
 737         struct l7vsd_log_level *log = l7ag_store_mibdata::getInstance().getVsdLogmibdata();
 738
 739         switch (reqinfo->mode) {
 740         case MODE_GET:
 741                 snmp_set_var_typed_value(requests->requestvb, ASN_INTEGER,
 742                 (u_char *) &log->environmentParameter,
 743                 sizeof(l7vs::LOG_LEVEL_TAG));
 744                 break;
 745
 746         default:
 747                 snmp_log(LOG_ERR,
 748                 "unknown mode (%d) in handle_um7LogVsdEnvironmentParameter\n",
 749                 reqinfo->mode);
 750                 return SNMP_ERR_GENERR;
 751         }
 752
 753         return SNMP_ERR_NOERROR;
 754 }
 755
 756 int
 757 handle_um7LogVsdLogger(netsnmp_mib_handler *handler,
 758 netsnmp_handler_registration *reginfo,
 759 netsnmp_agent_request_info *reqinfo,
 760 netsnmp_request_info *requests)
 761 {
 762         struct l7vsd_log_level *log = l7ag_store_mibdata::getInstance().getVsdLogmibdata();
 763
 764         switch (reqinfo->mode) {
 765         case MODE_GET:
 766                 snmp_set_var_typed_value(requests->requestvb, ASN_INTEGER,
 767                 (u_char *) &log->logger,
 768                 sizeof(l7vs::LOG_LEVEL_TAG));
 769                 break;
 770
 771         default:
 772                 snmp_log(LOG_ERR, "unknown mode (%d) in handle_um7LogVsdLogger\n",
 773                 reqinfo->mode);
 774                 return SNMP_ERR_GENERR;
 775         }
 776
 777         return SNMP_ERR_NOERROR;
 778 }
 779
 780 int
 781 handle_um7LogVsdParameter(netsnmp_mib_handler *handler,
 782 netsnmp_handler_registration *reginfo,
 783 netsnmp_agent_request_info *reqinfo,
 784 netsnmp_request_info *requests)
 785 {
 786         struct l7vsd_log_level *log = l7ag_store_mibdata::getInstance().getVsdLogmibdata();
 787
 788         switch (reqinfo->mode) {
 789         case MODE_GET:
 790                 snmp_set_var_typed_value(requests->requestvb, ASN_INTEGER,
 791                 (u_char *) &log->parameter,
 792                 sizeof(l7vs::LOG_LEVEL_TAG));
 793                 break;
 794
 795         default:
 796                 snmp_log(LOG_ERR,
 797                 "unknown mode (%d) in handle_um7LogVsdParameter\n",
 798                 reqinfo->mode);
 799                 return SNMP_ERR_GENERR;
 800         }
 801
 802         return SNMP_ERR_NOERROR;
 803 }
 804
 805 int
 806 handle_um7LogVsdEvent(netsnmp_mib_handler *handler,
 807 netsnmp_handler_registration *reginfo,
 808 netsnmp_agent_request_info *reqinfo,
 809 netsnmp_request_info *requests)
 810 {
 811         struct l7vsd_log_level *log = l7ag_store_mibdata::getInstance().getVsdLogmibdata();
 812
 813         switch (reqinfo->mode) {
 814         case MODE_GET:
 815                 snmp_set_var_typed_value(requests->requestvb, ASN_INTEGER,
 816                 (u_char *) &log->event,
 817                 sizeof(l7vs::LOG_LEVEL_TAG));
 818                 break;
 819
 820         default:
 821                 snmp_log(LOG_ERR, "unknown mode (%d) in handle_um7LogVsdEvent\n",
 822                 reqinfo->mode);
 823                 return SNMP_ERR_GENERR;
 824         }
 825
 826         return SNMP_ERR_NOERROR;
 827 }
 828
 829 int
 830 handle_um7LogVsdSchedule(netsnmp_mib_handler *handler,
 831 netsnmp_handler_registration *reginfo,
 832 netsnmp_agent_request_info *reqinfo,
 833 netsnmp_request_info *requests)
 834 {
 835         struct l7vsd_log_level *log = l7ag_store_mibdata::getInstance().getVsdLogmibdata();
 836
 837         switch (reqinfo->mode) {
 838         case MODE_GET:
 839                 snmp_set_var_typed_value(requests->requestvb, ASN_INTEGER,
 840                 (u_char *) &log->schedule,
 841                 sizeof(l7vs::LOG_LEVEL_TAG));
 842                 break;
 843
 844         default:
 845                 snmp_log(LOG_ERR,
 846                 "unknown mode (%d) in handle_um7LogVsdSchedule\n",
 847                 reqinfo->mode);
 848                 return SNMP_ERR_GENERR;
 849         }
 850
 851         return SNMP_ERR_NOERROR;
 852 }
 853
 854 int
 855 handle_um7LogVsdProgram(netsnmp_mib_handler *handler,
 856 netsnmp_handler_registration *reginfo,
 857 netsnmp_agent_request_info *reqinfo,
 858 netsnmp_request_info *requests)
 859 {
 860         struct l7vsd_log_level *log = l7ag_store_mibdata::getInstance().getVsdLogmibdata();
 861
 862         switch (reqinfo->mode) {
 863         case MODE_GET:
 864                 snmp_set_var_typed_value(requests->requestvb, ASN_INTEGER,
 865                 (u_char *) &log->program,
 866                 sizeof(l7vs::LOG_LEVEL_TAG));
 867                 break;
 868
 869         default:
 870                 snmp_log(LOG_ERR, "unknown mode (%d) in handle_um7LogVsdProgram\n",
 871                 reqinfo->mode);
 872                 return SNMP_ERR_GENERR;
 873         }
 874
 875         return SNMP_ERR_NOERROR;
 876 }
 877
 878 int
 879 handle_um7LogVsdProtocol(netsnmp_mib_handler *handler,
 880 netsnmp_handler_registration *reginfo,
 881 netsnmp_agent_request_info *reqinfo,
 882 netsnmp_request_info *requests)
 883 {
 884         struct l7vsd_log_level *log = l7ag_store_mibdata::getInstance().getVsdLogmibdata();
 885
 886         switch (reqinfo->mode) {
 887         case MODE_GET:
 888                 snmp_set_var_typed_value(requests->requestvb, ASN_INTEGER,
 889                 (u_char *) &log->protocol,
 890                 sizeof(l7vs::LOG_LEVEL_TAG));
 891                 break;
 892
 893         default:
 894                 snmp_log(LOG_ERR,
 895                 "unknown mode (%d) in handle_um7LogVsdProtocol\n",
 896                 reqinfo->mode);
 897                 return SNMP_ERR_GENERR;
 898         }
 899
 900         return SNMP_ERR_NOERROR;
 901 }
 902
 903 int
 904 handle_um7LogVsdModule(netsnmp_mib_handler *handler,
 905 netsnmp_handler_registration *reginfo,
 906 netsnmp_agent_request_info *reqinfo,
 907 netsnmp_request_info *requests)
 908 {
 909         struct l7vsd_log_level *log = l7ag_store_mibdata::getInstance().getVsdLogmibdata();
 910
 911         switch (reqinfo->mode) {
 912         case MODE_GET:
 913                 snmp_set_var_typed_value(requests->requestvb, ASN_INTEGER,
 914                 (u_char *) &log->module,
 915                 sizeof(l7vs::LOG_LEVEL_TAG));
 916                 break;
 917
 918         default:
 919                 snmp_log(LOG_ERR, "unknown mode (%d) in handle_um7LogVsdModule\n",
 920                 reqinfo->mode);
 921                 return SNMP_ERR_GENERR;
 922         }
 923
 924         return SNMP_ERR_NOERROR;
 925 }
 926
 927 int
 928 handle_um7LogVsadmParse(netsnmp_mib_handler *handler,
 929 netsnmp_handler_registration *reginfo,
 930 netsnmp_agent_request_info *reqinfo,
 931 netsnmp_request_info *requests)
 932 {
 933         struct l7vsadm_log_level *log = l7ag_store_mibdata::getInstance().getVsadmLogmibdata();
 934
 935         switch (reqinfo->mode) {
 936         case MODE_GET:
 937                 snmp_set_var_typed_value(requests->requestvb, ASN_INTEGER,
 938                 (u_char *) &log->parse,
 939                 sizeof(l7vs::LOG_LEVEL_TAG));
 940                 break;
 941
 942         default:
 943                 snmp_log(LOG_ERR, "unknown mode (%d) in handle_um7LogVsadmParse\n",
 944                 reqinfo->mode);
 945                 return SNMP_ERR_GENERR;
 946         }
 947
 948         return SNMP_ERR_NOERROR;
 949 }
 950
 951 int
 952 handle_um7LogVsadmOperate(netsnmp_mib_handler *handler,
 953 netsnmp_handler_registration *reginfo,
 954 netsnmp_agent_request_info *reqinfo,
 955 netsnmp_request_info *requests)
 956 {
 957         struct l7vsadm_log_level *log = l7ag_store_mibdata::getInstance().getVsadmLogmibdata();
 958
 959         switch (reqinfo->mode) {
 960         case MODE_GET:
 961                 snmp_set_var_typed_value(requests->requestvb, ASN_INTEGER,
 962                 (u_char *) &log->operate,
 963                 sizeof(l7vs::LOG_LEVEL_TAG));
 964                 break;
 965
 966         default:
 967                 snmp_log(LOG_ERR,
 968                 "unknown mode (%d) in handle_um7LogVsadmOperate\n",
 969                 reqinfo->mode);
 970                 return SNMP_ERR_GENERR;
 971         }
 972
 973         return SNMP_ERR_NOERROR;
 974 }
 975
 976 int
 977 handle_um7LogVsadmCommunicate(netsnmp_mib_handler *handler,
 978 netsnmp_handler_registration *reginfo,
 979 netsnmp_agent_request_info *reqinfo,
 980 netsnmp_request_info *requests)
 981 {
 982         struct l7vsadm_log_level *log = l7ag_store_mibdata::getInstance().getVsadmLogmibdata();
 983
 984         switch (reqinfo->mode) {
 985         case MODE_GET:
 986                 snmp_set_var_typed_value(requests->requestvb, ASN_INTEGER,
 987                 (u_char *) &log->communicate,
 988                 sizeof(l7vs::LOG_LEVEL_TAG));
 989                 break;
 990
 991         default:
 992                 snmp_log(LOG_ERR,
 993                 "unknown mode (%d) in handle_um7LogVsadmCommunicate\n",
 994                 reqinfo->mode);
 995                 return SNMP_ERR_GENERR;
 996         }
 997
 998         return SNMP_ERR_NOERROR;
 999 }
1000
1001 int
1002 handle_um7LogVsadmConfigResult(netsnmp_mib_handler *handler,
1003 netsnmp_handler_registration *reginfo,
1004 netsnmp_agent_request_info *reqinfo,
1005 netsnmp_request_info *requests)
1006 {
1007         struct l7vsadm_log_level *log = l7ag_store_mibdata::getInstance().getVsadmLogmibdata();
1008
1009         switch (reqinfo->mode) {
1010         case MODE_GET:
1011                 snmp_set_var_typed_value(requests->requestvb, ASN_INTEGER,
1012                 (u_char *) &log->configResult,
1013                 sizeof(l7vs::LOG_LEVEL_TAG));
1014                 break;
1015
1016         default:
1017                 snmp_log(LOG_ERR,
1018                 "unknown mode (%d) in handle_um7LogVsadmConfigResult\n",
1019                 reqinfo->mode);
1020                 return SNMP_ERR_GENERR;
1021         }
1022
1023         return SNMP_ERR_NOERROR;
1024 }
1025
1026 int
1027 handle_um7LogVsadmCommon(netsnmp_mib_handler *handler,
1028 netsnmp_handler_registration *reginfo,
1029 netsnmp_agent_request_info *reqinfo,
1030 netsnmp_request_info *requests)
1031 {
1032         struct l7vsadm_log_level *log = l7ag_store_mibdata::getInstance().getVsadmLogmibdata();
1033
1034         switch (reqinfo->mode) {
1035         case MODE_GET:
1036                 snmp_set_var_typed_value(requests->requestvb, ASN_INTEGER,
1037                 (u_char *) &log->common,
1038                 sizeof(l7vs::LOG_LEVEL_TAG));
1039                 break;
1040
1041         default:
1042                 snmp_log(LOG_ERR,
1043                 "unknown mode (%d) in handle_um7LogVsadmCommon\n",
1044                 reqinfo->mode);
1045                 return SNMP_ERR_GENERR;
1046         }
1047
1048         return SNMP_ERR_NOERROR;
1049 }
1050
1051 int
1052 handle_um7LogVsadmLogger(netsnmp_mib_handler *handler,
1053 netsnmp_handler_registration *reginfo,
1054 netsnmp_agent_request_info *reqinfo,
1055 netsnmp_request_info *requests)
1056 {
1057         struct l7vsadm_log_level *log = l7ag_store_mibdata::getInstance().getVsadmLogmibdata();
1058
1059         switch (reqinfo->mode) {
1060         case MODE_GET:
1061                 snmp_set_var_typed_value(requests->requestvb, ASN_INTEGER,
1062                 (u_char *) &log->logger,
1063                 sizeof(l7vs::LOG_LEVEL_TAG));
1064                 break;
1065
1066         default:
1067                 snmp_log(LOG_ERR,
1068                 "unknown mode (%d) in handle_um7LogVsadmLogger\n",
1069                 reqinfo->mode);
1070                 return SNMP_ERR_GENERR;
1071         }
1072
1073         return SNMP_ERR_NOERROR;
1074 }
1075
1076 int
1077 handle_um7LogVsadmParameter(netsnmp_mib_handler *handler,
1078 netsnmp_handler_registration *reginfo,
1079 netsnmp_agent_request_info *reqinfo,
1080 netsnmp_request_info *requests)
1081 {
1082         struct l7vsadm_log_level *log = l7ag_store_mibdata::getInstance().getVsadmLogmibdata();
1083
1084         switch (reqinfo->mode) {
1085         case MODE_GET:
1086                 snmp_set_var_typed_value(requests->requestvb, ASN_INTEGER,
1087                 (u_char *) &log->parameter,
1088                 sizeof(l7vs::LOG_LEVEL_TAG));
1089                 break;
1090
1091         default:
1092                 snmp_log(LOG_ERR,
1093                 "unknown mode (%d) in handle_um7LogVsadmParameter\n",
1094                 reqinfo->mode);
1095                 return SNMP_ERR_GENERR;
1096         }
1097
1098         return SNMP_ERR_NOERROR;
1099 }
1100
1101 int
1102 handle_um7LogVsadmProtocol(netsnmp_mib_handler *handler,
1103 netsnmp_handler_registration *reginfo,
1104 netsnmp_agent_request_info *reqinfo,
1105 netsnmp_request_info *requests)
1106 {
1107         struct l7vsadm_log_level *log = l7ag_store_mibdata::getInstance().getVsadmLogmibdata();
1108
1109         switch (reqinfo->mode) {
1110         case MODE_GET:
1111                 snmp_set_var_typed_value(requests->requestvb, ASN_INTEGER,
1112                 (u_char *) &log->protocol,
1113                 sizeof(l7vs::LOG_LEVEL_TAG));
1114                 break;
1115
1116         default:
1117                 snmp_log(LOG_ERR,
1118                 "unknown mode (%d) in handle_um7LogVsadmProtocol\n",
1119                 reqinfo->mode);
1120                 return SNMP_ERR_GENERR;
1121         }
1122
1123         return SNMP_ERR_NOERROR;
1124 }
1125
1126 int
1127 handle_um7LogVsadmModule(netsnmp_mib_handler *handler,
1128 netsnmp_handler_registration *reginfo,
1129 netsnmp_agent_request_info *reqinfo,
1130 netsnmp_request_info *requests)
1131 {
1132         struct l7vsadm_log_level *log = l7ag_store_mibdata::getInstance().getVsadmLogmibdata();
1133
1134         switch (reqinfo->mode) {
1135         case MODE_GET:
1136                 snmp_set_var_typed_value(requests->requestvb, ASN_INTEGER,
1137                 (u_char *) &log->module,
1138                 sizeof(l7vs::LOG_LEVEL_TAG));
1139                 break;
1140
1141         default:
1142                 snmp_log(LOG_ERR,
1143                 "unknown mode (%d) in handle_um7LogVsadmModule\n",
1144                 reqinfo->mode);
1145                 return SNMP_ERR_GENERR;
1146         }
1147
1148         return SNMP_ERR_NOERROR;
1149 }
1150
1151 int
1152 handle_um7LogSnmpStartStop(netsnmp_mib_handler *handler,
1153 netsnmp_handler_registration *reginfo,
1154 netsnmp_agent_request_info *reqinfo,
1155 netsnmp_request_info *requests)
1156 {
1157         struct l7snmpagent_log_level *log = l7ag_store_mibdata::getInstance().getAgentLogmibdata();
1158
1159         switch (reqinfo->mode) {
1160         case MODE_GET:
1161                 snmp_set_var_typed_value(requests->requestvb, ASN_INTEGER,
1162                 (u_char *) &log->startStop,
1163                 sizeof(l7vs::LOG_LEVEL_TAG));
1164                 break;
1165
1166         default:
1167                 snmp_log(LOG_ERR,
1168                 "unknown mode (%d) in handle_um7LogSnmpStartStop\n",
1169                 reqinfo->mode);
1170                 return SNMP_ERR_GENERR;
1171         }
1172
1173         return SNMP_ERR_NOERROR;
1174 }
1175
1176 int
1177 handle_um7LogSnmpManagerReceive(netsnmp_mib_handler *handler,
1178 netsnmp_handler_registration *reginfo,
1179 netsnmp_agent_request_info *reqinfo,
1180 netsnmp_request_info *requests)
1181 {
1182         struct l7snmpagent_log_level *log = l7ag_store_mibdata::getInstance().getAgentLogmibdata();
1183
1184         switch (reqinfo->mode) {
1185         case MODE_GET:
1186                 snmp_set_var_typed_value(requests->requestvb, ASN_INTEGER,
1187                 (u_char *) &log->managerReceive,
1188                 sizeof(l7vs::LOG_LEVEL_TAG));
1189                 break;
1190
1191         default:
1192                 snmp_log(LOG_ERR,
1193                 "unknown mode (%d) in handle_um7LogSnmpManagerReceive\n",
1194                 reqinfo->mode);
1195                 return SNMP_ERR_GENERR;
1196         }
1197
1198         return SNMP_ERR_NOERROR;
1199 }
1200
1201 int
1202 handle_um7LogSnmpManagerSend(netsnmp_mib_handler *handler,
1203 netsnmp_handler_registration *reginfo,
1204 netsnmp_agent_request_info *reqinfo,
1205 netsnmp_request_info *requests)
1206 {
1207         struct l7snmpagent_log_level *log = l7ag_store_mibdata::getInstance().getAgentLogmibdata();
1208
1209         switch (reqinfo->mode) {
1210         case MODE_GET:
1211                 snmp_set_var_typed_value(requests->requestvb, ASN_INTEGER,
1212                 (u_char *) &log->managerSend,
1213                 sizeof(l7vs::LOG_LEVEL_TAG));
1214                 break;
1215
1216         default:
1217                 snmp_log(LOG_ERR,
1218                 "unknown mode (%d) in handle_um7LogSnmpManagerSend\n",
1219                 reqinfo->mode);
1220                 return SNMP_ERR_GENERR;
1221         }
1222
1223         return SNMP_ERR_NOERROR;
1224 }
1225
1226 int
1227 handle_um7LogSnmpL7vsdReceive(netsnmp_mib_handler *handler,
1228 netsnmp_handler_registration *reginfo,
1229 netsnmp_agent_request_info *reqinfo,
1230 netsnmp_request_info *requests)
1231 {
1232         struct l7snmpagent_log_level *log = l7ag_store_mibdata::getInstance().getAgentLogmibdata();
1233
1234         switch (reqinfo->mode) {
1235         case MODE_GET:
1236                 snmp_set_var_typed_value(requests->requestvb, ASN_INTEGER,
1237                 (u_char *) &log->l7vsdReceive,
1238                 sizeof(l7vs::LOG_LEVEL_TAG));
1239                 break;
1240
1241         default:
1242                 snmp_log(LOG_ERR,
1243                 "unknown mode (%d) in handle_um7LogSnmpL7vsdReceive\n",
1244                 reqinfo->mode);
1245                 return SNMP_ERR_GENERR;
1246         }
1247
1248         return SNMP_ERR_NOERROR;
1249 }
1250
1251 int
1252 handle_um7LogSnmpL7vsdSend(netsnmp_mib_handler *handler,
1253 netsnmp_handler_registration *reginfo,
1254 netsnmp_agent_request_info *reqinfo,
1255 netsnmp_request_info *requests)
1256 {
1257         struct l7snmpagent_log_level *log = l7ag_store_mibdata::getInstance().getAgentLogmibdata();
1258
1259         switch (reqinfo->mode) {
1260         case MODE_GET:
1261                 snmp_set_var_typed_value(requests->requestvb, ASN_INTEGER,
1262                 (u_char *) &log->l7vsdSend,
1263                 sizeof(l7vs::LOG_LEVEL_TAG));
1264                 break;
1265
1266         default:
1267                 snmp_log(LOG_ERR,
1268                 "unknown mode (%d) in handle_um7LogSnmpL7vsdSend\n",
1269                 reqinfo->mode);
1270                 return SNMP_ERR_GENERR;
1271         }
1272
1273         return SNMP_ERR_NOERROR;
1274 }
1275
1276 int
1277 handle_um7LogSnmpLogger(netsnmp_mib_handler *handler,
1278 netsnmp_handler_registration *reginfo,
1279 netsnmp_agent_request_info *reqinfo,
1280 netsnmp_request_info *requests)
1281 {
1282         struct l7snmpagent_log_level *log = l7ag_store_mibdata::getInstance().getAgentLogmibdata();
1283
1284         switch (reqinfo->mode) {
1285         case MODE_GET:
1286                 snmp_set_var_typed_value(requests->requestvb, ASN_INTEGER,
1287                 (u_char *) &log->logger,
1288                 sizeof(l7vs::LOG_LEVEL_TAG));
1289                 break;
1290
1291         default:
1292                 snmp_log(LOG_ERR, "unknown mode (%d) in handle_um7LogSnmpLogger\n",
1293                 reqinfo->mode);
1294                 return SNMP_ERR_GENERR;
1295         }
1296
1297         return SNMP_ERR_NOERROR;
1298 }
1299
1300 int
1301 handle_um7LogSnmpParameter(netsnmp_mib_handler *handler,
1302 netsnmp_handler_registration *reginfo,
1303 netsnmp_agent_request_info *reqinfo,
1304 netsnmp_request_info *requests)
1305 {
1306         struct l7snmpagent_log_level *log = l7ag_store_mibdata::getInstance().getAgentLogmibdata();
1307
1308         switch (reqinfo->mode) {
1309         case MODE_GET:
1310                 snmp_set_var_typed_value(requests->requestvb, ASN_INTEGER,
1311                 (u_char *) &log->parameter,
1312                 sizeof(l7vs::LOG_LEVEL_TAG));
1313                 break;
1314
1315         default:
1316                 snmp_log(LOG_ERR,
1317                 "unknown mode (%d) in handle_um7LogSnmpParameter\n",
1318                 reqinfo->mode);
1319                 return SNMP_ERR_GENERR;
1320         }
1321
1322         return SNMP_ERR_NOERROR;
1323 }
1324
1325 int
1326 handle_um7StatMessage(netsnmp_mib_handler *handler,
1327 netsnmp_handler_registration *reginfo,
1328 netsnmp_agent_request_info *reqinfo,
1329 netsnmp_request_info *requests)
1330 {
1331         struct l7_status *stat = l7ag_store_mibdata::getInstance().getStatmibdata();
1332
1333         switch (reqinfo->mode) {
1334         case MODE_GET:
1335                 snmp_set_var_typed_value(requests->requestvb, ASN_OCTET_STR,
1336                 (u_char *) &stat->message,
1337                 strnlen(stat->message, DISPLAYSTRING_LEN));
1338                 break;
1339
1340         default:
1341                 snmp_log(LOG_ERR, "unknown mode (%d) in handle_um7StatMessage\n",
1342                 reqinfo->mode);
1343                 return SNMP_ERR_GENERR;
1344         }
1345
1346         return SNMP_ERR_NOERROR;
1347 }
1348
1349 int
1350 handle_um7StatReplication(netsnmp_mib_handler *handler,
1351 netsnmp_handler_registration *reginfo,
1352 netsnmp_agent_request_info *reqinfo,
1353 netsnmp_request_info *requests)
1354 {
1355 //     struct l7_status* stat = l7ag_store_mibdata::getInstance().getStatmibdata();
1356
1357         switch (reqinfo->mode) {
1358         case MODE_GET:
1359                 /*        snmp_set_var_typed_value(requests->requestvb, ASN_INTEGER,
1360                                                  (u_char *) &stat->replication,
1361                                                   sizeof(REPLICATION_MODE_TAG)  );*/
1362                 break;
1363
1364         default:
1365                 snmp_log(LOG_ERR,
1366                 "unknown mode (%d) in handle_um7StatReplication\n",
1367                 reqinfo->mode);
1368                 return SNMP_ERR_GENERR;
1369         }
1370
1371         return SNMP_ERR_NOERROR;
1372 }
1373
1374 int
1375 handle_um7StatSnmpAgent(netsnmp_mib_handler *handler,
1376 netsnmp_handler_registration *reginfo,
1377 netsnmp_agent_request_info *reqinfo,
1378 netsnmp_request_info *requests)
1379 {
1380         struct l7_status *stat = l7ag_store_mibdata::getInstance().getStatmibdata();
1381
1382         switch (reqinfo->mode) {
1383         case MODE_GET:
1384                 snmp_set_var_typed_value(requests->requestvb, ASN_INTEGER,
1385                 (u_char *) &stat->snmpAgent,
1386                 sizeof(IPC_STATUS_TAG));
1387                 break;
1388
1389         default:
1390                 snmp_log(LOG_ERR, "unknown mode (%d) in handle_um7StatSnmpAgent\n",
1391                 reqinfo->mode);
1392                 return SNMP_ERR_GENERR;
1393         }
1394
1395         return SNMP_ERR_NOERROR;
1396 }
1397
1398 /** Initialize the um7VirtualServiceTable table by defining its contents and how it's structured */
1399 void
1400 initialize_table_um7VirtualServiceTable()
1401 {
1402         static oid      um7VirtualServiceTable_oid[] =
1403         { 1, 3, 6, 1, 4, 1, 60000, 1, 1, 1 };
1404         size_t          um7VirtualServiceTable_oid_len =
1405         OID_LENGTH(um7VirtualServiceTable_oid);
1406
1407         /*
1408          * create the table structure itself
1409          */
1410         vs_table_set = netsnmp_create_table_data_set("um7VirtualServiceTable");
1411         l7ag_store_mibdata::getInstance().setVsTableSet(vs_table_set);
1412
1413         /*
1414          * comment this out or delete if you don't support creation of new rows
1415          */
1416 //    vs_table_set->allow_creation = 1;
1417
1418         /***************************************************
1419          * Adding indexes
1420          */
1421         DEBUGMSGTL(("initialize_table_um7VirtualServiceTable",
1422         "adding indexes to table um7VirtualServiceTable\n"));
1423         netsnmp_table_set_add_indexes(vs_table_set, ASN_INTEGER,       /* index: um7VSIndex */
1424         0);
1425
1426         DEBUGMSGTL(("initialize_table_um7VirtualServiceTable",
1427         "adding column types to table um7VirtualServiceTable\n"));
1428         netsnmp_table_set_multi_add_default_row(vs_table_set,
1429         COLUMN_UM7VSINDEX, ASN_INTEGER,
1430         0, NULL, 0,
1431         COLUMN_UM7VSPROTOCOL,
1432         ASN_INTEGER, 0, NULL, 0,
1433         COLUMN_UM7VSIPADDRESS,
1434         ASN_OCTET_STR, 0, NULL, 0,
1435         COLUMN_UM7VSPORTNUMBER,
1436         ASN_UNSIGNED, 0, NULL, 0,
1437         COLUMN_UM7VSSCHEDULEMODULE,
1438         ASN_OCTET_STR, 0, NULL, 0,
1439         COLUMN_UM7VSPROTOCOLMODULE,
1440         ASN_OCTET_STR, 0, NULL, 0,
1441         COLUMN_UM7VSPROTOCOLMODULEOPTION,
1442         ASN_OCTET_STR, 0, NULL, 0,
1443         COLUMN_UM7VSRESCHEDULE,
1444         ASN_INTEGER, 0, NULL, 0,
1445         COLUMN_UM7VSSORRYIPADDRESS,
1446         ASN_OCTET_STR, 0, NULL, 0,
1447         COLUMN_UM7VSSORRYPORTNUMBER,
1448         ASN_UNSIGNED, 0, NULL, 0,
1449         COLUMN_UM7VSSORRYTHRESHOLD,
1450         ASN_INTEGER, 0, NULL, 0,
1451         COLUMN_UM7VSSORRYFORCEFLAG,
1452         ASN_INTEGER, 0, NULL, 0,
1453         COLUMN_UM7VSQOSTHRESHOLDUP,
1454         ASN_INTEGER, 0, NULL, 0,
1455         COLUMN_UM7VSQOSTHRESHOLDDOWN,
1456         ASN_INTEGER, 0, NULL, 0,
1457         COLUMN_UM7VSTHROUGHPUTUP,
1458         ASN_INTEGER, 0, NULL, 0,
1459         COLUMN_UM7VSTHROUGHPUTDOWN,
1460         ASN_INTEGER, 0, NULL, 0, 0);
1461
1462         /*
1463          * registering the table with the master agent
1464          */
1465         /*
1466          * note: if you don't need a subhandler to deal with any aspects
1467          * of the request, change um7VirtualServiceTable_handler to "NULL"
1468          */
1469         netsnmp_register_table_data_set(netsnmp_create_handler_registration
1470         ("um7VirtualServiceTable",
1471         um7VirtualServiceTable_handler,
1472         um7VirtualServiceTable_oid,
1473         um7VirtualServiceTable_oid_len,
1474         HANDLER_CAN_RWRITE), vs_table_set, NULL);
1475 }
1476
1477 /** Initialize the um7RealServerTable table by defining its contents and how it's structured */
1478 void
1479 initialize_table_um7RealServerTable()
1480 {
1481         static oid      um7RealServerTable_oid[] =
1482         { 1, 3, 6, 1, 4, 1, 60000, 1, 1, 2 };
1483         size_t          um7RealServerTable_oid_len =
1484         OID_LENGTH(um7RealServerTable_oid);
1485
1486         /*
1487          * create the table structure itself
1488          */
1489         rs_table_set = netsnmp_create_table_data_set("um7RealServerTable");
1490         l7ag_store_mibdata::getInstance().setRsTableSet(rs_table_set);
1491
1492         /*
1493          * comment this out or delete if you don't support creation of new rows
1494          */
1495 //    rs_table_set->allow_creation = 1;
1496
1497         /***************************************************
1498          * Adding indexes
1499          */
1500         DEBUGMSGTL(("initialize_table_um7RealServerTable",
1501         "adding indexes to table um7RealServerTable\n"));
1502         netsnmp_table_set_add_indexes(rs_table_set, ASN_INTEGER,       /* index: um7RSIndex */
1503         0);
1504
1505         DEBUGMSGTL(("initialize_table_um7RealServerTable",
1506         "adding column types to table um7RealServerTable\n"));
1507         netsnmp_table_set_multi_add_default_row(rs_table_set,
1508         COLUMN_UM7RSINDEX, ASN_INTEGER,
1509         0, NULL, 0,
1510         COLUMN_UM7RSVIRTUALSERVICEINDEX,
1511         ASN_INTEGER, 0, NULL, 0,
1512         COLUMN_UM7RSIPADDRESS,
1513         ASN_OCTET_STR, 0, NULL, 0,
1514         COLUMN_UM7RSPORTNUMBER,
1515         ASN_UNSIGNED, 0, NULL, 0,
1516         COLUMN_UM7RSFORWARDMODE,
1517         ASN_INTEGER, 0, NULL, 0,
1518         COLUMN_UM7RSWEIGHT,
1519         ASN_INTEGER, 0, NULL, 0,
1520         COLUMN_UM7RSACTIVECONN,
1521         ASN_INTEGER, 0, NULL, 0,
1522         COLUMN_UM7RSINACTIVECONN,
1523         ASN_INTEGER, 0, NULL, 0, 0);
1524
1525         /*
1526          * registering the table with the master agent
1527          */
1528         /*
1529          * note: if you don't need a subhandler to deal with any aspects
1530          * of the request, change um7RealServerTable_handler to "NULL"
1531          */
1532         netsnmp_register_table_data_set(netsnmp_create_handler_registration
1533         ("um7RealServerTable",
1534         um7RealServerTable_handler,
1535         um7RealServerTable_oid,
1536         um7RealServerTable_oid_len,
1537         HANDLER_CAN_RWRITE), rs_table_set, NULL);
1538 }
1539
1540 /** handles requests for the um7VirtualServiceTable table, if anything else needs to be done */
1541 int
1542 um7VirtualServiceTable_handler(netsnmp_mib_handler *handler,
1543 netsnmp_handler_registration *reginfo,
1544 netsnmp_agent_request_info *reqinfo,
1545 netsnmp_request_info *requests)
1546 {
1547         /*
1548          * perform anything here that you need to do.  The requests have
1549          * already been processed by the master table_dataset handler, but
1550          * this gives you chance to act on the request in some other way
1551          * if need be.
1552          */
1553         return SNMP_ERR_NOERROR;
1554 }
1555
1556 /** handles requests for the um7RealServerTable table, if anything else needs to be done */
1557 int
1558 um7RealServerTable_handler(netsnmp_mib_handler *handler,
1559 netsnmp_handler_registration *reginfo,
1560 netsnmp_agent_request_info *reqinfo,
1561 netsnmp_request_info *requests)
1562 {
1563         /*
1564          * perform anything here that you need to do.  The requests have
1565          * already been processed by the master table_dataset handler, but
1566          * this gives you chance to act on the request in some other way
1567          * if need be.
1568          */
1569         return SNMP_ERR_NOERROR;
1570 }
1571
1572 int
1573 send_um7StateAlert_trap()
1574 {
1575         netsnmp_variable_list *var_list = NULL;
1576         oid             um7StateAlert_oid[] =
1577         { 1, 3, 6, 1, 4, 1, 60000, 0, 1 };
1578         /*    oid             um7StatReplication_oid[] =
1579                 { 1, 3, 6, 1, 4, 1, 60000, 1, 1, 4, 2, 0 };*/
1580         oid             um7StatSnmpAgent_oid[] =
1581         { 1, 3, 6, 1, 4, 1, 60000, 1, 1, 4, 3, 0 };
1582
1583         /*
1584          * Set the snmpTrapOid.0 value
1585          */
1586         snmp_varlist_add_variable(&var_list,
1587         snmptrap_oid, OID_LENGTH(snmptrap_oid),
1588         ASN_OBJECT_ID,
1589         (u_char *) um7StateAlert_oid,
1590         sizeof(um7StateAlert_oid));
1591
1592         struct l7_status *stat = l7ag_store_mibdata::getInstance().getStatmibdata();
1593         /*    snmp_varlist_add_variable(&var_list,
1594                                       um7StatReplication_oid,
1595                                       OID_LENGTH(um7StatReplication_oid),
1596                                       ASN_INTEGER, (u_char*) &stat->replication,
1597                                       sizeof(REPLICATION_MODE_TAG));*/
1598         snmp_varlist_add_variable(&var_list,
1599         um7StatSnmpAgent_oid,
1600         OID_LENGTH(um7StatSnmpAgent_oid),
1601         ASN_INTEGER, (u_char *) &stat->snmpAgent,
1602         sizeof(IPC_STATUS_TAG));
1603
1604         /*
1605          * Add any extra (optional) objects here
1606          */
1607
1608         /*
1609          * Send the trap to the list of configured destinations
1610          *  and clean up
1611          */
1612         send_v2trap(var_list);
1613         snmp_free_varbind(var_list);
1614
1615         return SNMP_ERR_NOERROR;
1616 }
1617
1618 int
1619 send_um7VirtualServiceAlert_trap()
1620 {
1621         netsnmp_variable_list *var_list = NULL;
1622         oid             um7VirtualServiceAlert_oid[] =
1623         { 1, 3, 6, 1, 4, 1, 60000, 0, 2 };
1624 //     oid             um7VirtualServiceTable_oid[] =
1625 //         { 1, 3, 6, 1, 4, 1, 60000, 1, 1, 1, 0 };
1626 //     oid             um7RealServerTable_oid[] =
1627 //         { 1, 3, 6, 1, 4, 1, 60000, 1, 1, 2, 0 };
1628
1629         /*
1630          * Set the snmpTrapOid.0 value
1631          */
1632         snmp_varlist_add_variable(&var_list,
1633         snmptrap_oid, OID_LENGTH(snmptrap_oid),
1634         ASN_OBJECT_ID,
1635         (u_char *) um7VirtualServiceAlert_oid,
1636         sizeof(um7VirtualServiceAlert_oid));
1637
1638         /*
1639          * Add any objects from the trap definition
1640          */
1641         /*
1642             snmp_varlist_add_variable(&var_list,
1643                                       um7VirtualServiceTable_oid,
1644                                       OID_LENGTH(um7VirtualServiceTable_oid),,
1645                                       // Set an appropriate value for um7VirtualServiceTable
1646                                       NULL, 0);
1647             snmp_varlist_add_variable(&var_list,
1648                                       um7RealServerTable_oid,
1649                                       OID_LENGTH(um7RealServerTable_oid),,
1650                                       // Set an appropriate value for um7RealServerTable
1651                                       NULL, 0);
1652         */
1653
1654         /*
1655          * Add any extra (optional) objects here
1656          */
1657
1658         /*
1659          * Send the trap to the list of configured destinations
1660          *  and clean up
1661          */
1662         send_v2trap(var_list);
1663         snmp_free_varbind(var_list);
1664
1665         return SNMP_ERR_NOERROR;
1666 }
1667
1668 int
1669 send_um7ReplicationAlert_trap()
1670 {
1671         netsnmp_variable_list *var_list = NULL;
1672         oid             um7ReplicationAlert_oid[] =
1673         { 1, 3, 6, 1, 4, 1, 60000, 0, 3 };
1674         oid             um7StatMessage_oid[] =
1675         { 1, 3, 6, 1, 4, 1, 60000, 1, 1, 4, 1, 0 };
1676
1677         /*
1678          * Set the snmpTrapOid.0 value
1679          */
1680         snmp_varlist_add_variable(&var_list,
1681         snmptrap_oid, OID_LENGTH(snmptrap_oid),
1682         ASN_OBJECT_ID,
1683         (u_char *) um7ReplicationAlert_oid,
1684         sizeof(um7ReplicationAlert_oid));
1685
1686         struct l7_status *stat = l7ag_store_mibdata::getInstance().getStatmibdata();
1687         snmp_varlist_add_variable(&var_list,
1688         um7StatMessage_oid,
1689         OID_LENGTH(um7StatMessage_oid),
1690         ASN_OCTET_STR,
1691         (u_char *) &stat->message,
1692         strnlen(stat->message, DISPLAYSTRING_LEN));
1693
1694         /*
1695          * Add any extra (optional) objects here
1696          */
1697
1698         /*
1699          * Send the trap to the list of configured destinations
1700          *  and clean up
1701          */
1702         send_v2trap(var_list);
1703         snmp_free_varbind(var_list);
1704
1705         return SNMP_ERR_NOERROR;
1706 }
1707
1708 int
1709 send_um7LogLevelAlert_trap()
1710 {
1711         netsnmp_variable_list *var_list = NULL;
1712         oid             um7LogLevelAlert_oid[] =
1713         { 1, 3, 6, 1, 4, 1, 60000, 0, 4 };
1714 //     oid             um7LogLevel_oid[] =
1715 //         { 1, 3, 6, 1, 4, 1, 60000, 1, 1, 3, /* insert index here */  };
1716
1717         /*
1718          * Set the snmpTrapOid.0 value
1719          */
1720         snmp_varlist_add_variable(&var_list,
1721         snmptrap_oid, OID_LENGTH(snmptrap_oid),
1722         ASN_OBJECT_ID,
1723         (u_char *) um7LogLevelAlert_oid,
1724         sizeof(um7LogLevelAlert_oid));
1725
1726         /*
1727          * Add any objects from the trap definition
1728          */
1729         /*
1730             snmp_varlist_add_variable(&var_list,
1731                                       um7LogLevel_oid,
1732                                       OID_LENGTH(um7LogLevel_oid),,
1733                                       // Set an appropriate value for um7LogLevel
1734                                       NULL, 0);
1735         */
1736
1737         /*
1738          * Add any extra (optional) objects here
1739          */
1740
1741         /*
1742          * Send the trap to the list of configured destinations
1743          *  and clean up
1744          */
1745         send_v2trap(var_list);
1746         snmp_free_varbind(var_list);
1747
1748         return SNMP_ERR_NOERROR;
1749 }
1750
1751 int
1752 send_um7QoSAlarmOn_trap(size_t index)
1753 {
1754         netsnmp_variable_list *var_list = NULL;
1755         oid             um7QoSAlarmOn_oid[] =
1756         { 1, 3, 6, 1, 4, 1, 60000, 0, 5 };
1757         oid             um7VSQoSThresholdUp_oid[] =
1758         { 1, 3, 6, 1, 4, 1, 60000, 1, 1, 1, 1, 13, index };
1759         oid             um7VSQoSThresholdDown_oid[] =
1760         { 1, 3, 6, 1, 4, 1, 60000, 1, 1, 1, 1, 14, index };
1761         oid             um7VSThroughputUp_oid[] =
1762         { 1, 3, 6, 1, 4, 1, 60000, 1, 1, 1, 1, 15, index };
1763         oid             um7VSThroughputDown_oid[] =
1764         { 1, 3, 6, 1, 4, 1, 60000, 1, 1, 1, 1, 16, index };
1765
1766         /*
1767          * Set the snmpTrapOid.0 value
1768          */
1769         snmp_varlist_add_variable(&var_list,
1770         snmptrap_oid, OID_LENGTH(snmptrap_oid),
1771         ASN_OBJECT_ID,
1772         (u_char *) um7QoSAlarmOn_oid,
1773         sizeof(um7QoSAlarmOn_oid));
1774
1775         vsdata *vs = l7ag_store_mibdata::getInstance().getVSmibdata(index);
1776         if (vs) {
1777                 snmp_varlist_add_variable(&var_list,
1778                 um7VSQoSThresholdUp_oid,
1779                 OID_LENGTH(um7VSQoSThresholdUp_oid),
1780                 ASN_INTEGER,
1781                 (u_char *) &vs->QoSThresholdUp,
1782                 sizeof(unsigned long long));
1783                 snmp_varlist_add_variable(&var_list,
1784                 um7VSQoSThresholdDown_oid,
1785                 OID_LENGTH(um7VSQoSThresholdDown_oid),
1786                 ASN_INTEGER,
1787                 (u_char *) &vs->QoSThresholdDown,
1788                 sizeof(unsigned long long));
1789                 snmp_varlist_add_variable(&var_list,
1790                 um7VSThroughputUp_oid,
1791                 OID_LENGTH(um7VSThroughputUp_oid),
1792                 ASN_INTEGER,
1793                 (u_char *) &vs->throughputUp,
1794                 sizeof(unsigned long long));
1795                 snmp_varlist_add_variable(&var_list,
1796                 um7VSThroughputDown_oid,
1797                 OID_LENGTH(um7VSThroughputDown_oid),
1798                 ASN_INTEGER,
1799                 (u_char *) &vs->throughputDown,
1800                 sizeof(unsigned long long));
1801         }
1802
1803         /*
1804          * Add any extra (optional) objects here
1805          */
1806
1807         /*
1808          * Send the trap to the list of configured destinations
1809          *  and clean up
1810          */
1811         send_v2trap(var_list);
1812         snmp_free_varbind(var_list);
1813
1814         return SNMP_ERR_NOERROR;
1815 }
1816
1817 int
1818 send_um7QoSAlarmOff_trap(size_t index)
1819 {
1820         netsnmp_variable_list *var_list = NULL;
1821         oid             um7QoSAlarmOff_oid[] =
1822         { 1, 3, 6, 1, 4, 1, 60000, 0, 6 };
1823         oid             um7VSQoSThresholdUp_oid[] =
1824         { 1, 3, 6, 1, 4, 1, 60000, 1, 1, 1, 1, 13, index };
1825         oid             um7VSQoSThresholdDown_oid[] =
1826         { 1, 3, 6, 1, 4, 1, 60000, 1, 1, 1, 1, 14, index };
1827         oid             um7VSThroughputUp_oid[] =
1828         { 1, 3, 6, 1, 4, 1, 60000, 1, 1, 1, 1, 15, index };
1829         oid             um7VSThroughputDown_oid[] =
1830         { 1, 3, 6, 1, 4, 1, 60000, 1, 1, 1, 1, 16, index };
1831
1832         /*
1833          * Set the snmpTrapOid.0 value
1834          */
1835         snmp_varlist_add_variable(&var_list,
1836         snmptrap_oid, OID_LENGTH(snmptrap_oid),
1837         ASN_OBJECT_ID,
1838         (u_char *) um7QoSAlarmOff_oid,
1839         sizeof(um7QoSAlarmOff_oid));
1840
1841         vsdata *vs = l7ag_store_mibdata::getInstance().getVSmibdata(index);
1842         if (vs) {
1843                 snmp_varlist_add_variable(&var_list,
1844                 um7VSQoSThresholdUp_oid,
1845                 OID_LENGTH(um7VSQoSThresholdUp_oid),
1846                 ASN_INTEGER,
1847                 (u_char *) &vs->QoSThresholdUp,
1848                 sizeof(unsigned long long));
1849                 snmp_varlist_add_variable(&var_list,
1850                 um7VSQoSThresholdDown_oid,
1851                 OID_LENGTH(um7VSQoSThresholdDown_oid),
1852                 ASN_INTEGER,
1853                 (u_char *) &vs->QoSThresholdDown,
1854                 sizeof(unsigned long long));
1855                 snmp_varlist_add_variable(&var_list,
1856                 um7VSThroughputUp_oid,
1857                 OID_LENGTH(um7VSThroughputUp_oid),
1858                 ASN_INTEGER,
1859                 (u_char *) &vs->throughputUp,
1860                 sizeof(unsigned long long));
1861                 snmp_varlist_add_variable(&var_list,
1862                 um7VSThroughputDown_oid,
1863                 OID_LENGTH(um7VSThroughputDown_oid),
1864                 ASN_INTEGER,
1865                 (u_char *) &vs->throughputDown,
1866                 sizeof(unsigned long long));
1867         }
1868
1869         /*
1870          * Add any extra (optional) objects here
1871          */
1872
1873         /*
1874          * Send the trap to the list of configured destinations
1875          *  and clean up
1876          */
1877         send_v2trap(var_list);
1878         snmp_free_varbind(var_list);
1879
1880         return SNMP_ERR_NOERROR;
1881 }
1882
1883 int
1884 send_um7MessageAlert_trap()
1885 {
1886         netsnmp_variable_list *var_list = NULL;
1887         oid             um7MessageAlert_oid[] =
1888         { 1, 3, 6, 1, 4, 1, 60000, 0, 7 };
1889         oid             um7StatMessage_oid[] =
1890         { 1, 3, 6, 1, 4, 1, 60000, 1, 1, 4, 1, 0 };
1891
1892         /*
1893          * Set the snmpTrapOid.0 value
1894          */
1895         snmp_varlist_add_variable(&var_list,
1896         snmptrap_oid, OID_LENGTH(snmptrap_oid),
1897         ASN_OBJECT_ID,
1898         (u_char *) um7MessageAlert_oid,
1899         sizeof(um7MessageAlert_oid));
1900
1901         struct l7_status *stat = l7ag_store_mibdata::getInstance().getStatmibdata();
1902         snmp_varlist_add_variable(&var_list,
1903         um7StatMessage_oid,
1904         OID_LENGTH(um7StatMessage_oid),
1905         ASN_OCTET_STR,
1906         (u_char *) &stat->message,
1907         strnlen(stat->message, DISPLAYSTRING_LEN));
1908
1909         /*
1910          * Add any extra (optional) objects here
1911          */
1912
1913         /*
1914          * Send the trap to the list of configured destinations
1915          *  and clean up
1916          */
1917         send_v2trap(var_list);
1918         snmp_free_varbind(var_list);
1919
1920         return SNMP_ERR_NOERROR;
1921 }
1922
1923 // get all mib data from l7vsd
1924 // called every REPEAT_SEC sec.
1925 void
1926 getL7vsdData(unsigned int clientreg, void *clientarg)
1927 {
1928         if (!clientarg) return;
1929         MessengerClient *message = (MessengerClient *) clientarg;
1930
1931         long long buf_size = sizeof(struct l7ag_message_header)
1932         + sizeof(struct l7ag_payload_header)
1933         + sizeof(struct l7ag_mibrequest_message);
1934         char *sendbuf = (char *) calloc(1, buf_size);
1935
1936         struct l7ag_message_header *msg_head = (struct l7ag_message_header *) sendbuf;
1937         msg_head->magic[0]      = 0x4d; // M
1938         msg_head->magic[1]      = 0x47; // G
1939         msg_head->version       = 1;
1940         msg_head->size          = buf_size;
1941         msg_head->payload_count = 1;
1942 // TODO set time    msg_head->time          = 1;
1943
1944         struct l7ag_payload_header *payload  = (struct l7ag_payload_header *)(msg_head + 1);
1945         payload->magic[0]         = 0x50; // P
1946         payload->magic[1]         = 0x59; // Y
1947         payload->message_id       = MESSAGE_ID_MIBCOLLECTREQUEST;
1948         payload->payload_datasize = sizeof(struct l7ag_payload_header)
1949         + sizeof(struct l7ag_mibrequest_message);
1950
1951         struct l7ag_mibrequest_message *request = (struct l7ag_mibrequest_message *)(payload + 1);
1952         memset(request, 0, sizeof(struct l7ag_mibrequest_message));
1953         request->magic[0] = 0x52; // R
1954         request->magic[1] = 0x51; // Q
1955
1956         if (message->connect()) {
1957                 int ret = message->send(buf_size, sendbuf);
1958                 if (ret != buf_size) {
1959                         // TODO error
1960                         message->close();
1961                 }
1962         }
1963 }
1964