Chapter 199: SNMP Agent Implementation

// main/custom_mib.h
#ifndef CUSTOM_MIB_H
#define CUSTOM_MIB_H

#include "lwip/apps/snmp_opts.h"
#include "lwip/apps/snmp_core.h"

// Define our private enterprise OID base
// .iso(1).org(3).dod(6).internet(1).private(4).enterprise(1).yourEnterpriseID(99999)
#define CUSTOM_ENTERPRISE_OID_BASE {1, 3, 6, 1, 4, 1, 99999}
#define CUSTOM_ENTERPRISE_OID_LEN 7 // Length of the base OID

// Our custom MIB objects under this base
// .1.3.6.1.4.1.99999.1.1.0 : esp32DeviceStatus (OCTET_STRING, RO)
// .1.3.6.1.4.1.99999.1.2.0 : esp32Uptime (TIMETICKS, RO)
// .1.3.6.1.4.1.99999.1.3.0 : esp32LedState (INTEGER, RW)

// These are leaf identifiers relative to CUSTOM_ENTERPRISE_OID_BASE.productGroup.moduleGroup
// For simplicity, let's assume productGroup = 1, moduleGroup = 1
// So, esp32DeviceStatus will be CUSTOM_ENTERPRISE_OID_BASE + .1.1.0
// esp32Uptime will be CUSTOM_ENTERPRISE_OID_BASE + .1.2.0
// esp32LedState will be CUSTOM_ENTERPRISE_OID_BASE + .1.3.0


// Structure to hold the state for our custom MIB objects (e.g., LED state)
typedef struct {
    int32_t led_state; // 0 for OFF, 1 for ON
    // Add other states here if needed
} custom_mib_states_t;

extern custom_mib_states_t g_custom_mib_states;

void custom_mib_init(void);

// Optional: function to simulate an event and send a trap
void send_custom_trap_example(void);


#endif // CUSTOM_MIB_H

// main/custom_mib.c
#include "custom_mib.h"
#include "esp_system.h" // For esp_log.h, esp_timer_get_time
#include "esp_log.h"
#include "lwip/apps/snmp_scalar.h"
#include "lwip/apps/snmp_agent.h" // For snmp_send_trap_specific etc.
#include "lwip/apps/snmp_msg.h"   // For snmp_varbind_alloc etc.

static const char *TAG_MIB = "CUSTOM_MIB";

custom_mib_states_t g_custom_mib_states = {
    .led_state = 0 // Initial LED state is OFF
};

// --- esp32DeviceStatus Callbacks (.1.3.6.1.4.1.99999.1.1.0) ---
static s16_t get_device_status(struct snmp_node_instance* instance, void* value) {
    const char *status = "Running";
    // Ensure value buffer is large enough. SNMP_MAX_VALUE_SIZE defined in snmp_opts.h or lwipopts.h
    strncpy((char*)value, status, SNMP_MAX_VALUE_SIZE); 
    ((char*)value)[SNMP_MAX_VALUE_SIZE -1] = '\0'; // Ensure null termination
    return strlen(status);
}

// --- esp32Uptime Callbacks (.1.3.6.1.4.1.99999.1.2.0) ---
static s16_t get_uptime(struct snmp_node_instance* instance, void* value) {
    uint32_t uptime_ticks = (uint32_t)(esp_timer_get_time() / 10000); // esp_timer_get_time is in microseconds, timeticks are 1/100 sec
    *(uint32_t*)value = uptime_ticks;
    return sizeof(uint32_t);
}

// --- esp32LedState Callbacks (.1.3.6.1.4.1.99999.1.3.0) ---
static s16_t get_led_state(struct snmp_node_instance* instance, void* value) {
    *(s32_t*)value = g_custom_mib_states.led_state;
    return sizeof(s32_t);
}

static snmp_err_t set_led_state_test(struct snmp_node_instance* instance, u16_t len, void* value) {
    s32_t new_state = *(s32_t*)value;
    if (new_state == 0 || new_state == 1) {
        return SNMP_ERR_NOERROR;
    }
    return SNMP_ERR_WRONGVALUE;
}

static snmp_err_t set_led_state_commit(struct snmp_node_instance* instance, u16_t len, void* value) {
    s32_t new_state = *(s32_t*)value;
    g_custom_mib_states.led_state = new_state;
    ESP_LOGI(TAG_MIB, "LED state set to: %s", new_state == 1 ? "ON" : "OFF");
    // Here you would actually control an LED GPIO
    // gpio_set_level(LED_GPIO, new_state);
    return SNMP_ERR_NOERROR;
}

// Define the scalar MIB nodes
// Node OIDs: Base + ProductGroup + ModuleGroup + Leaf
// Example: .1.3.6.1.4.1.99999.1.1.1.0 (DeviceStatus) - adding .0 for scalar instance
// Note: lwIP SNMP scalar nodes automatically append '.0' to the OID you define.
// So, if you define OID {CUSTOM_ENTERPRISE_OID_BASE, 1, 1, 1}, it becomes ...99999.1.1.1.0 when queried.

// Product Group OID part (e.g., 1)
#define PRODUCT_GROUP_OID 1
// Module Group OID part (e.g., 1 for generic device info, 2 for sensor module etc.)
#define MODULE_GROUP_OID 1

// Leaf OIDs
#define DEVICE_STATUS_OID_LEAF  1
#define UPTIME_OID_LEAF         2
#define LED_STATE_OID_LEAF      3

// OID for esp32DeviceStatus: CUSTOM_ENTERPRISE_OID_BASE + .PRODUCT_GROUP_OID.MODULE_GROUP_OID.DEVICE_STATUS_OID_LEAF
static const struct snmp_scalar_array_node_def esp32_device_status_node =
    SNMP_SCALAR_CREATE_NODE_READONLY(DEVICE_STATUS_OID_LEAF, SNMP_ASN1_TYPE_OCTET_STRING, get_device_status);

// OID for esp32Uptime: CUSTOM_ENTERPRISE_OID_BASE + .PRODUCT_GROUP_OID.MODULE_GROUP_OID.UPTIME_OID_LEAF
static const struct snmp_scalar_array_node_def esp32_uptime_node =
    SNMP_SCALAR_CREATE_NODE_READONLY(UPTIME_OID_LEAF, SNMP_ASN1_TYPE_TIMETICKS, get_uptime);

// OID for esp32LedState: CUSTOM_ENTERPRISE_OID_BASE + .PRODUCT_GROUP_OID.MODULE_GROUP_OID.LED_STATE_OID_LEAF
static const struct snmp_scalar_array_node_def esp32_led_state_node =
    SNMP_SCALAR_CREATE_NODE(LED_STATE_OID_LEAF, SNMP_ASN1_TYPE_INTEGER, SNMP_NODE_INSTANCE_ACCESS_READ_WRITE, get_led_state, set_led_state_test, set_led_state_commit);


// Array of pointers to our scalar MIB nodes
static const struct snmp_scalar_array_node* const custom_mib_nodes[] = {
    &esp32_device_status_node.node.node, // Need to get the inner snmp_scalar_node
    &esp32_uptime_node.node.node,
    &esp32_led_state_node.node.node
};

// Create the MIB tree structure
// This defines the ".1.3.6.1.4.1.99999.1.1" part of the OID tree
// where our scalar nodes will reside.
static const u32_t enterprise_product_module_oid_base[] = {CUSTOM_ENTERPRISE_OID_BASE, PRODUCT_GROUP_OID, MODULE_GROUP_OID};
static const struct snmp_tree_node custom_mib_product_module_branch =
    SNMP_CREATE_TREE_NODE(MODULE_GROUP_OID, custom_mib_nodes); // Module group under product group

static const struct snmp_tree_node* const product_group_nodes[] = {
    &custom_mib_product_module_branch.node // custom_mib_product_module_branch is already a snmp_node
};
static const struct snmp_tree_node custom_mib_product_branch = 
    SNMP_CREATE_TREE_NODE(PRODUCT_GROUP_OID, product_group_nodes); // Product group under enterprise

// Root of our custom MIB structure under .1.3.6.1.4.1.99999 (CUSTOM_ENTERPRISE_OID_BASE)
static const u32_t private_enterprise_oid[] = {CUSTOM_ENTERPRISE_OID_BASE}; // This is just the enterprise ID itself
struct snmp_node_instance custom_mib_enterprise_root_instance; // Instance for the root

void custom_mib_init(void) {
    ESP_LOGI(TAG_MIB, "Initializing Custom MIB");

    // Register the root of our custom MIB structure.
    // This makes .1.3.6.1.4.1.99999 accessible.
    // Then, we add our 'product_branch' under this.
    // The '99999' is the last element of private_enterprise_oid.
    // The parent OID for snmp_register_tree_node_instance should be .1.3.6.1.4.1
    // And the node OID itself will be 99999.

    static const struct snmp_tree_node* const enterprise_nodes[] = {&custom_mib_product_branch.node};
    const struct snmp_tree_node enterprise_root_node = SNMP_CREATE_TREE_NODE(private_enterprise_oid[CUSTOM_ENTERPRISE_OID_LEN-1], enterprise_nodes);
    
    // snmp_mib2_ दूसरा arg parent OID लेता है, इसलिए .1.3.6.1.4.1 को hardcode करने के बजाय,
    // हम SNMP_NODE_OID_PRIVATE_ENTERPRISE का उपयोग करते हैं, जो SNMP मानक OID ट्री में सही स्थान है
    // निजी उद्यम नोड्स के लिए।
    // The OID for snmp_register_tree_node_instance is the OID of the node itself,
    // not its parent. The parent is implicitly .1.3.6.1.4.1 (SNMP_NODE_OID_ENTERPRISE)
    snmp_register_tree_node(SNMP_NODE_OID_ENTERPRISE, &enterprise_root_node.node);

    ESP_LOGI(TAG_MIB, "Custom MIB initialized.");
    ESP_LOGI(TAG_MIB, "DeviceStatus OID: .1.3.6.1.4.1.99999.%d.%d.%d.0", PRODUCT_GROUP_OID, MODULE_GROUP_OID, DEVICE_STATUS_OID_LEAF);
    ESP_LOGI(TAG_MIB, "Uptime OID:       .1.3.6.1.4.1.99999.%d.%d.%d.0", PRODUCT_GROUP_OID, MODULE_GROUP_OID, UPTIME_OID_LEAF);
    ESP_LOGI(TAG_MIB, "LedState OID:     .1.3.6.1.4.1.99999.%d.%d.%d.0", PRODUCT_GROUP_OID, MODULE_GROUP_OID, LED_STATE_OID_LEAF);
}


void send_custom_trap_example(void) {
    // Define a specific trap OID under our enterprise: .1.3.6.1.4.1.99999.2.1
    // (.1.3.6.1.4.1.yourEnterpriseID.yourTrapsGroup.yourSpecificTrapID)
    // For traps, the last sub-identifier is often 0.
    // The second to last is the specific trap number.
    // The enterprise OID itself is usually passed as part of the trap PDU.
    
    // Generic trap type for enterprise specific traps
    #define SNMP_TRAP_ENTERPRISE_SPECIFIC 6 

    // Our specific trap ID (e.g., 1 for "device restart", 2 for "sensor alert")
    u32_t specific_trap_id = 1; // Example: Sensor Alert Trap

    // The OID that defines this trap. This is usually your enterprise OID + a traps sub-identifier + specific trap id.
    // For example: .1.3.6.1.4.1.99999 (enterprise) .2 (traps group) .1 (specific trap)
    // This full OID is sent as the "snmpTrapOID.0" varbind in an SNMPv2c trap.
    oid_t trap_oid_val[] = {CUSTOM_ENTERPRISE_OID_BASE, 2, specific_trap_id}; // .1.3.6.1.4.1.99999.2.1
    struct snmp_obj_id trap_oid;
    SNMP_OBJ_ID_SET(&trap_oid, trap_oid_val, LWIP_ARRAYSIZE(trap_oid_val));


    // Optional: Add variable bindings (varbinds) to the trap PDU to provide more context
    struct snmp_varbind *vb = snmp_varbind_alloc(&trap_oid, SNMP_ASN1_TYPE_OCTET_STRING, strlen("Sensor threshold exceeded"));
    if (vb == NULL) {
        ESP_LOGE(TAG_MIB, "Failed to allocate varbind for trap");
        return;
    }
    memcpy(vb->value, "Sensor threshold exceeded", strlen("Sensor threshold exceeded"));
    
    // Add another varbind, e.g., current temperature that caused the alert
    // For this, we'd need the OID of our temperature sensor
    oid_t temp_oid_val[] = {CUSTOM_ENTERPRISE_OID_BASE, PRODUCT_GROUP_OID, MODULE_GROUP_OID, DEVICE_STATUS_OID_LEAF, 0}; // Using device status OID for example
    struct snmp_obj_id temp_obj_oid;
    SNMP_OBJ_ID_SET(&temp_obj_oid, temp_oid_val, LWIP_ARRAYSIZE(temp_oid_val));
    
    s32_t current_temp_val = 35; // Example value
    struct snmp_varbind *vb_temp = snmp_varbind_alloc(&temp_obj_oid, SNMP_ASN1_TYPE_INTEGER, sizeof(s32_t));
    if(vb_temp == NULL) {
        ESP_LOGE(TAG_MIB, "Failed to allocate temp varbind for trap");
        snmp_varbind_free(vb); // Free previously allocated varbind
        return;
    }
    *(s32_t*)vb_temp->value = current_temp_val;
    vb->next = vb_temp; // Link varbinds

    ESP_LOGI(TAG_MIB, "Sending SNMP Trap for specific ID %lu", specific_trap_id);
    // For SNMPv2c/v3 traps, snmpTrapOID.0 is the first varbind.
    // The uptime is also automatically included as sysUpTimeInstance.0.
    // The enterprise OID used in snmp_send_trap_specific is often the agent's enterprise root.
    oid_t enterprise_oid_val[] = {CUSTOM_ENTERPRISE_OID_BASE};
    struct snmp_obj_id enterprise_obj_oid;
    SNMP_OBJ_ID_SET(&enterprise_obj_oid, enterprise_oid_val, LWIP_ARRAYSIZE(enterprise_oid_val));

    // For SNMPv2c, the trap OID itself is sent as the first varbind.
    // The `snmp_send_trap_specific` is more for SNMPv1 style traps if not careful.
    // For v2c, we should use `snmp_send_trap_ext` or build PDU manually.
    // lwIP's snmp_trap() or snmp_send_trap_specific() might be v1 oriented.
    // Let's try a more direct approach for SNMPv2 TRAP if available or a standard v1 trap.
    // The lwIP API `snmp_send_trap_specific` is for SNMPv1.
    // To send SNMPv2c trap, you usually set `snmp_trap_varbind_enterprise_oid = 0`
    // and provide the trap OID as the first varbind.
    
    // For simplicity, we'll use the generic `snmp_trap` which should adapt based on context or default to v1/v2c basics.
    // The modern way is `snmp_send_trap_ext(SNMP_TRAP_ENTERPRISE_SPECIFIC, specific_trap_id, &enterprise_obj_oid, vb);`
    // However, snmp_send_trap_ext might not be available or easy to use in all lwIP versions/configs directly.
    // The `snmp_send_trap_specific` is more for SNMPv1.
    // The `snmp_send_inform` is for INFORMs.
    // `snmp_v2_trap_ex` seems to be the internal function.
    //
    // The easiest way to send an SNMPv2c TRAP with specific OID and varbinds with lwIP's default agent:
    // 1. The first varbind MUST be sysUpTime.0 (SNMP_MSG_OID_SYSUPTIME, 0) - usually added automatically by snmp_send_trap()
    // 2. The second varbind MUST be snmpTrapOID.0 (SNMP_MSG_OID_SNMPTRAPOID, 0) with the value of your trap OID.
    // 3. Subsequent varbinds are your custom data.

    // Let's construct the varbind list for an SNMPv2c TRAP.
    // snmp_varbind_list_free(&vb_list_head); // Clear any previous
    // struct snmp_varbind *vb_list_head = NULL;
    // struct snmp_varbind *vb_list_tail = NULL;

    // // Varbind 1: snmpTrapOID.0 (Value is our trap OID: .1.3.6.1.4.1.99999.2.1)
    // oid_t snmptrapoid_oid_val[] = {SNMP_MSG_OID_SNMPTRAPOID, 0};
    // struct snmp_obj_id snmptrapoid_objid;
    // SNMP_OBJ_ID_SET(&snmptrapoid_objid, snmptrapoid_oid_val, LWIP_ARRAYSIZE(snmptrapoid_oid_val));
    // struct snmp_varbind *vbs_trapoid = snmp_varbind_alloc(&snmptrapoid_objid, SNMP_ASN1_TYPE_OBJECT_ID, trap_oid.len * sizeof(oid_t));
    // if(!vbs_trapoid) { ESP_LOGE(TAG_MIB, "Failed to alloc snmpTrapOID.0 varbind"); return; }
    // SNMP_OBJ_ID_COPY((struct snmp_obj_id *)vbs_trapoid->value, &trap_oid); // Value is the trap OID itself
    // snmp_varbind_tail_add(&vb_list_head, &vb_list_tail, vbs_trapoid);
    
    // // Varbind 2: Custom varbind (e.g., alert message)
    // // OID: .1.3.6.1.4.1.99999.1.1.0 (esp32DeviceStatus, using it as an example payload OID)
    // oid_t alert_msg_oid_val[] = {CUSTOM_ENTERPRISE_OID_BASE, PRODUCT_GROUP_OID, MODULE_GROUP_OID, DEVICE_STATUS_OID_LEAF, 0};
    // struct snmp_obj_id alert_msg_objid;
    // SNMP_OBJ_ID_SET(&alert_msg_objid, alert_msg_oid_val, LWIP_ARRAYSIZE(alert_msg_oid_val));
    // const char *alert_str = "High Temperature Alert!";
    // struct snmp_varbind *vbs_alert_msg = snmp_varbind_alloc(&alert_msg_objid, SNMP_ASN1_TYPE_OCTET_STRING, strlen(alert_str));
    // if(!vbs_alert_msg) { ESP_LOGE(TAG_MIB, "Failed to alloc alert_msg varbind"); snmp_varbind_list_free(&vb_list_head); return; }
    // MEMCPY(vbs_alert_msg->value, alert_str, strlen(alert_str));
    // snmp_varbind_tail_add(&vb_list_head, &vb_list_tail, vbs_alert_msg);

    // ESP_LOGI(TAG_MIB, "Sending SNMPv2c Trap with specific OID and varbinds");
    // snmp_send_trap(SNMP_GENTRAP_ENTERPRISE_SPECIFIC, &enterprise_obj_oid, specific_trap_id, vb_list_head);
    // snmp_varbind_list_free(&vb_list_head);
    
    // The above is complex. For a simpler trap using SNMPv1 style (often what basic lwIP `snmp_send_trap_specific` does):
    ESP_LOGI(TAG_MIB, "Sending SNMPv1-style Trap (specific %lu)", specific_trap_id);
    snmp_send_trap_specific(
        SNMP_TRAP_ENTERPRISE_SPECIFIC, // generic trap type = 6 for enterpriseSpecific
        specific_trap_id,              // specific trap code
        &enterprise_obj_oid,           // enterprise OID (.1.3.6.1.4.1.99999)
        vb                             // list of varbinds (can be NULL)
    );

    // Free the varbind list if it was allocated (vb points to the head)
    if (vb != NULL) {
        snmp_varbind_list_free(&vb);
    }
}

#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/event_groups.h"
#include "esp_system.h"
#include "esp_wifi.h"
#include "esp_event.h"
#include "esp_log.h"
#include "nvs_flash.h"

#include "lwip/err.h"
#include "lwip/sys.h"
#include "lwip/sockets.h" // For getting IP address

// SNMP includes
#include "lwip/apps/snmp_opts.h" // For LWIP_SNMP
#if LWIP_SNMP
#include "lwip/apps/snmp.h"
#include "lwip/apps/snmp_core.h"
#include "lwip/apps/snmp_mib2.h"
#include "lwip/apps/snmp_agent.h" // For snmp_set_community_write etc.
#endif // LWIP_SNMP

#include "custom_mib.h" // Our custom MIB definitions

// Wi-Fi Configuration
#define EXAMPLE_ESP_WIFI_SSID      CONFIG_EXAMPLE_WIFI_SSID
#define EXAMPLE_ESP_WIFI_PASS      CONFIG_EXAMPLE_WIFI_PASSWORD
#define EXAMPLE_ESP_MAXIMUM_RETRY  CONFIG_EXAMPLE_MAXIMUM_RETRY

static const char *TAG_APP = "SNMP_APP";

/* FreeRTOS event group to signal when we are connected*/
static EventGroupHandle_t s_wifi_event_group;
#define WIFI_CONNECTED_BIT BIT0
#define WIFI_FAIL_BIT      BIT1
static int s_retry_num = 0;

static void event_handler(void* arg, esp_event_base_t event_base,
                                int32_t event_id, void* event_data) {
    // (Identical to event_handler from Chapter 197/198)
    if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_START) {
        esp_wifi_connect();
    } else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_DISCONNECTED) {
        if (s_retry_num < EXAMPLE_ESP_MAXIMUM_RETRY) {
            esp_wifi_connect();
            s_retry_num++;
            ESP_LOGI(TAG_APP, "retry to connect to the AP");
        } else {
            xEventGroupSetBits(s_wifi_event_group, WIFI_FAIL_BIT);
        }
        ESP_LOGI(TAG_APP,"connect to the AP fail");
    } else if (event_base == IP_EVENT && event_id == IP_EVENT_STA_GOT_IP) {
        ip_event_got_ip_t* event = (ip_event_got_ip_t*) event_data;
        ESP_LOGI(TAG_APP, "got ip:" IPSTR, IP2STR(&event->ip_info.ip));
        s_retry_num = 0;
        xEventGroupSetBits(s_wifi_event_group, WIFI_CONNECTED_BIT);
    }
}

void wifi_init_sta(void) {
    // (Identical to wifi_init_sta from Chapter 197/198)
    s_wifi_event_group = xEventGroupCreate();
    ESP_ERROR_CHECK(esp_netif_init());
    ESP_ERROR_CHECK(esp_event_loop_create_default());
    esp_netif_t* sta_netif = esp_netif_create_default_wifi_sta();
    assert(sta_netif);

    wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
    ESP_ERROR_CHECK(esp_wifi_init(&cfg));

    esp_event_handler_instance_t instance_any_id;
    esp_event_handler_instance_t instance_got_ip;
    ESP_ERROR_CHECK(esp_event_handler_instance_register(WIFI_EVENT, ESP_EVENT_ANY_ID, &event_handler, NULL, &instance_any_id));
    ESP_ERROR_CHECK(esp_event_handler_instance_register(IP_EVENT, IP_EVENT_STA_GOT_IP, &event_handler, NULL, &instance_got_ip));

    wifi_config_t wifi_config = {
        .sta = { .ssid = EXAMPLE_ESP_WIFI_SSID, .password = EXAMPLE_ESP_WIFI_PASS, .threshold.authmode = WIFI_AUTH_WPA2_PSK },
    };
    ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA) );
    ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_STA, &wifi_config) );
    ESP_ERROR_CHECK(esp_wifi_start() );
    ESP_LOGI(TAG_APP, "wifi_init_sta finished.");

    EventBits_t bits = xEventGroupWaitBits(s_wifi_event_group, WIFI_CONNECTED_BIT | WIFI_FAIL_BIT, pdFALSE, pdFALSE, portMAX_DELAY);

    if (bits & WIFI_CONNECTED_BIT) {
        ESP_LOGI(TAG_APP, "connected to ap SSID:%s", EXAMPLE_ESP_WIFI_SSID);
        esp_netif_ip_info_t ip_info;
        esp_netif_get_ip_info(sta_netif, &ip_info);
        ESP_LOGI(TAG_APP, "SNMP Agent IP address: " IPSTR, IP2STR(&ip_info.ip));

        // Configure SNMP Trap destination if not already set by menuconfig constants
        #if LWIP_SNMP
        // Note: CONFIG_LWIP_SNMP_TRAP_DESTINATION_IP is set via menuconfig
        // If you need to set it dynamically:
        // ip_addr_t trap_target_ip;
        // ipaddr_aton("192.168.1.100", &trap_target_ip); // Replace with your NMS IP
        // snmp_trap_dst_ip_set(0, &trap_target_ip);
        // snmp_trap_dst_enable(0, 1);
        ESP_LOGI(TAG_APP, "SNMP Trap Destination IP (from menuconfig): %s", CONFIG_LWIP_SNMP_TRAP_DESTINATION_IP);
        #endif

    } else if (bits & WIFI_FAIL_BIT) {
        ESP_LOGI(TAG_APP, "Failed to connect to SSID:%s", EXAMPLE_ESP_WIFI_SSID);
    } else {
        ESP_LOGE(TAG_APP, "UNEXPECTED WIFI EVENT");
    }
}

static void snmp_agent_task(void *pvParameters) {
#if LWIP_SNMP
    ESP_LOGI(TAG_APP, "Starting SNMP agent task");
    // Initialize SNMP agent
    snmp_init(); // This initializes MIB2 stuff as well if enabled

    // Set community strings (these might also be set via menuconfig)
    // If set via menuconfig (CONFIG_LWIP_SNMP_COMMUNITY, CONFIG_LWIP_SNMP_COMMUNITY_WRITE),
    // they are typically compiled in. Calling these functions overrides them.
    snmp_set_community((const char*)CONFIG_LWIP_SNMP_COMMUNITY);
    snmp_set_community_write((const char*)CONFIG_LWIP_SNMP_COMMUNITY_WRITE);
    
    // Enable authentication for SET requests using the write community
    snmp_set_write_access(SNMP_VERSION_2c); // Or SNMP_VERSION_1, ensure this matches your manager
                                           // For SNMPv2c, the set_community_write is used.
                                           // For SNMPv1, it's also set_community_write.
                                           // It implies that if a packet comes with the write community, it's allowed.

    // Initialize our custom MIB
    custom_mib_init();

    ESP_LOGI(TAG_APP, "SNMP Agent initialized. Ready to receive requests.");
    ESP_LOGI(TAG_APP, "Read Community: %s", CONFIG_LWIP_SNMP_COMMUNITY);
    ESP_LOGI(TAG_APP, "Write Community: %s", CONFIG_LWIP_SNMP_COMMUNITY_WRITE);


    // Periodically send a trap as an example
    uint32_t trap_counter = 0;
    while(1) {
        vTaskDelay(pdMS_TO_TICKS(30000)); // Every 30 seconds
        ESP_LOGI(TAG_APP, "Sending example trap (%lu)...", trap_counter++);
        send_custom_trap_example();
    }
#else
    ESP_LOGE(TAG_APP, "SNMP is not enabled in lwIP. Please enable it in menuconfig.");
#endif //LWIP_SNMP
    vTaskDelete(NULL);
}

void app_main(void) {
    esp_err_t ret = nvs_flash_init();
    if (ret == ESP_ERR_NVS_NO_FREE_PAGES || ret == ESP_ERR_NVS_NEW_VERSION_FOUND) {
      ESP_ERROR_CHECK(nvs_flash_erase());
      ret = nvs_flash_init();
    }
    ESP_ERROR_CHECK(ret);

    ESP_LOGI(TAG_APP, "ESP_WIFI_MODE_STA");
    wifi_init_sta();

    EventBits_t bits = xEventGroupGetBits(s_wifi_event_group);
    if (bits & WIFI_CONNECTED_BIT) {
        ESP_LOGI(TAG_APP, "Wi-Fi Connected. Starting SNMP agent task if enabled.");
        #if LWIP_SNMP
        // The SNMP agent runs within the lwIP TCP/IP task context after snmp_init().
        // You don't typically need a separate high-priority task just for SNMP polling,
        // as requests are handled by lwIP. This task is for initialization and perhaps periodic actions like sending traps.
        xTaskCreate(&snmp_agent_task, "snmp_agent_task", 4096, NULL, 5, NULL);
        #else
        ESP_LOGW(TAG_APP, "SNMP agent not started as LWIP_SNMP is disabled.");
        #endif
    } else {
        ESP_LOGE(TAG_APP, "Wi-Fi not connected. SNMP agent task will not start.");
    }
}

# main/CMakeLists.txt
idf_component_register(SRCS "your_main_file.c" "custom_mib.c"
                    INCLUDE_DIRS "."
                    REQUIRES lwip esp_wifi nvs_flash)
# lwip component will be automatically linked if CONFIG_LWIP_SNMP_AGENT is set.