T168_111\system\Ethernet：第9~15

最新推荐文章于 2024-08-14 10:08:54 发布

qq_33772147

最新推荐文章于 2024-08-14 10:08:54 发布

阅读量312

点赞数 4

文章标签： javascript 前端服务器

本文链接：https://blog.csdn.net/qq_33772147/article/details/137607415

版权

mib2prt.c 。。。。。。。。。。。。。。。。。。。。。。。。。。。。。

/******************************************************************************
* *
* M O D U L E D E F I N E *
* *
******************************************************************************/

#define MIB2PRT_C

/******************************************************************************
* *
* C O M P I L E R D E F I N E D I N C L U D E F I L E S *
* *
******************************************************************************/

#include <string.h>

/******************************************************************************
* *
* U S E R D E F I N E D I N C L U D E F I L E S *
* *
******************************************************************************/

#include "Common.h"
#include "XCore.h"
#include "XNutOS.h"
#include "XAppVer.h"

#include "net\confnet.h"
#include "pro\snmp.h"
#include "pro\snmp_api.h"
#include "mib2.h"

#if defined(NUTNET)

/******************************************************************************
* *
* L O C A L D E F I N E S *
* *
******************************************************************************/

enum {
   /* General */
   MAG_PRT_GENERAL_CONFIG_CHANGES,
   MAG_PRT_GENERAL_CURRENT_LOCAL,
   MAG_PRT_GENERAL_RESET,
   MAG_PRT_GENERAL_CURRENT_OPERATOR,
   MAG_PRT_GENERAL_SERVICE_PERSON,
   MAG_PRT_INPUT_DEFAULT_INDEX,
   MAG_PRT_OUTPUT_DEFAULT_INDEX,
   MAG_PRT_MARKER_DEFAULT_INDEX,
   MAG_PRT_MEDIA_PATH_DEFAULT_INDEX,
   MAG_PRT_CONSOLE_LOCAL,
   MAG_PRT_CONSOLE_NUMBER_OF_DISPLAY_LINES,
   MAG_PRT_CONSOLE_NUMBER_OF_DISPLAY_CHARS,
   MAG_PRT_CONSOLE_DISABLE,
   MAG_PRT_AUXILIARY_SHEET_STARTUP_PAGE,
   MAG_PRT_AUXILIARY_SHEET_BANNER_PAGE,
   MAG_PRT_GENERAL_PRINTER_NAME,
   MAG_PRT_GENERAL_SERIAL_NUMBER,
   MAG_PRT_ALERT_CRITICAL_EVENTS,
   MAG_PRT_ALERT_ALL_EVENTS,
   MAG_PRT_DEVICE_REF_INDEX,
   /* Cover */
   MAG_PRT_COVER_DESCRIPTION,
   MAG_PRT_COVER_STATUS,
   /* Localization */
   MAG_PRT_LOCAL_LANGUAGE,
   MAG_PRT_LOCAL_COUNTRY,
   MAG_PRT_LOCAL_CHAR_SET,
   /* Input */
   MAG_PRT_INPUT_TYPE,
   MAG_PRT_INPUT_DIM_UNIT,
   MAG_PRT_INPUT_MEDIA_DIM_FEED_DIR_DECLARED,
   MAG_PRT_INPUT_MEDIA_DIM_XFEED_DIR_DECLARED,
   MAG_PRT_INPUT_MEDIA_DIM_FEED_DIR_CHOSEN,
   MAG_PRT_INPUT_MEDIA_DIM_XFEED_DIR_CHOSEN,
   MAG_PRT_INPUT_CAPACITY_UNIT,
   MAG_PRT_INPUT_MAX_CAPACITY,
   MAG_PRT_INPUT_CURRENT_LEVEL,
   MAG_PRT_INPUT_STATUS,
   MAG_PRT_INPUT_MEDIA_NAME,
   MAG_PRT_INPUT_NAME,
   MAG_PRT_INPUT_VENDOR_NAME,
   MAG_PRT_INPUT_MODEL,
   MAG_PRT_INPUT_VERSION,
   MAG_PRT_INPUT_SERIAL_NUMBER,
   MAG_PRT_INPUT_DESCRIPTION,
   MAG_PRT_INPUT_SECURITY,
   MAG_PRT_INPUT_MEDIA_WEIGHT,
   MAG_PRT_INPUT_MEDIA_TYPE,
   MAG_PRT_INPUT_MEDIA_COLOR,
   MAG_PRT_INPUT_MEDIA_FORM_PARTS,
   /* Output */
   MAG_PRT_OUTPUT_TYPE,
   MAG_PRT_OUTPUT_CAPACITY_UNIT,
   MAG_PRT_OUTPUT_MAX_CAPACITY,
   MAG_PRT_OUTPUT_REMAINING_CAPACITY,
   MAG_PRT_OUTPUT_STATUS,
   MAG_PRT_OUTPUT_NAME,
   MAG_PRT_OUTPUT_VENDOR_NAME,
   MAG_PRT_OUTPUT_MODEL,
   MAG_PRT_OUTPUT_VERSION,
   MAG_PRT_OUTPUT_SERIAL_NUMBER,
   MAG_PRT_OUTPUT_DESCRIPTION,
   MAG_PRT_OUTPUT_SECURITY,
   MAG_PRT_OUTPUT_DIM_UNIT,
   MAG_PRT_OUTPUT_MAX_DIM_FEED_DIR,
   MAG_PRT_OUTPUT_MAX_DIM_XFEED_DIR,
   MAG_PRT_OUTPUT_MIN_DIM_FEED_DIR,
   MAG_PRT_OUTPUT_MIN_DIM_XFEED_DIR,
   MAG_PRT_OUTPUT_STACKING_ORDER,
   MAG_PRT_OUTPUT_PAGE_DELIVERY_ORIENTATION,
   MAG_PRT_OUTPUT_BURSTING,
   MAG_PRT_OUTPUT_DECOLLATING,
   MAG_PRT_OUTPUT_PAGE_COLLATED,
   MAG_PRT_OUTPUT_OFFSET_STACKING,
   /* Marker */
   MAG_PRT_MARKER_MARK_TECH,
   MAG_PRT_MARKER_COUNTER_UNIT,
   MAG_PRT_MARKER_LIFE_COUNT,
   MAG_PRT_MARKER_POWER_ON_COUNT,
   MAG_PRT_MARKER_PROCESS_COLORANTS,
   MAG_PRT_MARKER_SPOT_COLORANTS,
   MAG_PRT_MARKER_ADDRESSABILITY_UNIT,
   MAG_PRT_MARKER_ADDRESSABILITY_FEED_DIR,
   MAG_PRT_MARKER_ADDRESSABILITY_XFEED_DIR,
   MAG_PRT_MARKER_NORTH_MARGIN,
   MAG_PRT_MARKER_SOUTH_MARGIN,
   MAG_PRT_MARKER_WEST_MARGIN,
   MAG_PRT_MARKER_EAST_MARGIN,
   MAG_PRT_MARKER_STATUS,
   /* Marker Supplies */
   MAG_PRT_MARKER_SUPPLIES_MARKER_INDEX,
   MAG_PRT_MARKER_SUPPLIES_COLORANT_INDEX,
   MAG_PRT_MARKER_SUPPLIES_CLASS,
   MAG_PRT_MARKER_SUPPLIES_TYPE,
   MAG_PRT_MARKER_SUPPLIES_DESCRIPTION,
   MAG_PRT_MARKER_SUPPLIES_SUPPLY_UNIT,
   MAG_PRT_MARKER_SUPPLIES_MAX_CAPACITY,
   MAG_PRT_MARKER_SUPPLIES_LEVEL,
   /* Marker Colorant */
   MAG_PRT_MARKER_COLORANT_MARKER_INDEX,
   MAG_PRT_MARKER_COLORANT_ROLE,
   MAG_PRT_MARKER_COLORANT_VALUE,
   MAG_PRT_MARKER_COLORANT_TONALITY,
   /* Marker Path */
   MAG_PRT_MEDIA_PATH_MAX_SPEED_PRINT_UNIT,
   MAG_PRT_MEDIA_PATH_MEDIA_SIZE_UNIT,
   MAG_PRT_MEDIA_PATH_MAX_SPEED,
   MAG_PRT_MEDIA_PATH_MAX_MEDIA_FEED_DIR,
   MAG_PRT_MEDIA_PATH_MAX_MEDIA_XFEED_DIR,
   MAG_PRT_MEDIA_PATH_MIN_MEDIA_FEED_DIR,
   MAG_PRT_MEDIA_PATH_MIN_MEDIA_XFEED_DIR,
   MAG_PRT_MEDIA_PATH_TYPE,
   MAG_PRT_MEDIA_PATH_DESCRIPTION,
   MAG_PRT_MEDIA_PATH_STATUS,
   /* Channel */
   MAG_PRT_CHANNEL_TYPE,
   MAG_PRT_CHANNEL_PROTOCOL_VERSION,
   MAG_PRT_CHANNEL_CURRENT_JOB_CNTL_LANG_INDEX,
   MAG_PRT_CHANNEL_DEFAULT_PAGE_DESC_LANG_INDEX,
   MAG_PRT_CHANNEL_STATE,
   MAG_PRT_CHANNEL_IF_INDEX,
   MAG_PRT_CHANNEL_STATUS,
   /* Interpreter */
   MAG_PRT_INTERPRETER_LANG_FAMILY,
   MAG_PRT_INTERPRETER_LANG_LEVEL,
   MAG_PRT_INTERPRETER_LANG_VERSION,
   MAG_PRT_INTERPRETER_DESCRIPTION,
   MAG_PRT_INTERPRETER_VERSION,
   MAG_PRT_INTERPRETER_DEFAULT_ORIENTATION,
   MAG_PRT_INTERPRETER_FEED_ADDRESSABILITY,
   MAG_PRT_INTERPRETER_XFEED_ADDRESSABILITY,
   MAG_PRT_INTERPRETER_DEFAULT_CHAR_SET_IN,
   MAG_PRT_INTERPRETER_DEFAULT_CHAR_SET_OUT,
   MAG_PRT_INTERPRETER_TWO_WAY,
   /* Console Display Buffer */
   MAG_PRT_CONSOLE_DISPLAY_BUFFER_TEXT,
   /* Console Lights */
   MAG_PRT_CONSOLE_ON_TIME,
   MAG_PRT_CONSOLE_OFF_TIME,
   MAG_PRT_CONSOLE_COLOR,
   MAG_PRT_CONSOLE_DESCRIPTION,
};

/******************************************************************************
* *
* L O C A L T Y P E D E F S *
* *
******************************************************************************/

/* None */

/******************************************************************************
* *
* L O C A L F U N C T I O N P R O T O T Y P E S *
* *
******************************************************************************/

static u_char *MibVarsPrtGet(CONST SNMPVAR *, OID *, size_t *, int, size_t *, WMETHOD **);

/******************************************************************************
* *
* L O C A L I N I T I A L I Z E D D A T A D E F I N I T I O N S *
* *
******************************************************************************/

static OID base_oid[] = { SNMP_OID_MIB2, 43 };
static size_t base_oidlen = sizeof(base_oid) / sizeof(OID);

static SNMPVAR mib_variables[] = {
   /* General */
   {MAG_PRT_GENERAL_CONFIG_CHANGES, ASN_INTEGER, ACL_RONLY, MibVarsPrtGet, 4, {5, 1, 1, 1}},
   {MAG_PRT_GENERAL_CURRENT_LOCAL, ASN_INTEGER, ACL_RWRITE, MibVarsPrtGet, 4, {5, 1, 1, 2}},
   {MAG_PRT_GENERAL_RESET, ASN_INTEGER, ACL_RWRITE, MibVarsPrtGet, 4, {5, 1, 1, 3}},
   {MAG_PRT_GENERAL_CURRENT_OPERATOR, ASN_OCTET_STR, ACL_RWRITE, MibVarsPrtGet, 4, {5, 1, 1, 4}},
   {MAG_PRT_GENERAL_SERVICE_PERSON, ASN_OCTET_STR, ACL_RWRITE, MibVarsPrtGet, 4, {5, 1, 1, 5}},
   {MAG_PRT_INPUT_DEFAULT_INDEX, ASN_INTEGER, ACL_RWRITE, MibVarsPrtGet, 4, {5, 1, 1, 6}},
   {MAG_PRT_OUTPUT_DEFAULT_INDEX, ASN_INTEGER, ACL_RWRITE, MibVarsPrtGet, 4, {5, 1, 1, 7}},
   {MAG_PRT_MARKER_DEFAULT_INDEX, ASN_INTEGER, ACL_RWRITE, MibVarsPrtGet, 4, {5, 1, 1, 8}},
   {MAG_PRT_MEDIA_PATH_DEFAULT_INDEX, ASN_INTEGER, ACL_RWRITE, MibVarsPrtGet, 4, {5, 1, 1, 9}},
   {MAG_PRT_CONSOLE_LOCAL, ASN_INTEGER, ACL_RWRITE, MibVarsPrtGet, 4, {5, 1, 1, 10}},
   {MAG_PRT_CONSOLE_NUMBER_OF_DISPLAY_LINES, ASN_INTEGER, ACL_RONLY, MibVarsPrtGet, 4, {5, 1, 1, 11}},
   {MAG_PRT_CONSOLE_NUMBER_OF_DISPLAY_CHARS, ASN_INTEGER, ACL_RONLY, MibVarsPrtGet, 4, {5, 1, 1, 12}},
   {MAG_PRT_CONSOLE_DISABLE, ASN_INTEGER, ACL_RWRITE, MibVarsPrtGet, 4, {5, 1, 1, 13}},
   {MAG_PRT_AUXILIARY_SHEET_STARTUP_PAGE, ASN_INTEGER, ACL_RWRITE, MibVarsPrtGet, 4, {5, 1, 1, 14}},
   {MAG_PRT_AUXILIARY_SHEET_BANNER_PAGE, ASN_INTEGER, ACL_RWRITE, MibVarsPrtGet, 4, {5, 1, 1, 15}},
   {MAG_PRT_GENERAL_PRINTER_NAME, ASN_OCTET_STR, ACL_RWRITE, MibVarsPrtGet, 4, {5, 1, 1, 16}},
   {MAG_PRT_GENERAL_SERIAL_NUMBER, ASN_OCTET_STR, ACL_RWRITE, MibVarsPrtGet, 4, {5, 1, 1, 17}},
   {MAG_PRT_ALERT_CRITICAL_EVENTS, ASN_COUNTER, ACL_RONLY, MibVarsPrtGet, 4, {5, 1, 1, 18}},
   {MAG_PRT_ALERT_ALL_EVENTS, ASN_COUNTER, ACL_RONLY, MibVarsPrtGet, 4, {5, 1, 1, 19}},
   {MAG_PRT_DEVICE_REF_INDEX, ASN_INTEGER, ACL_RONLY, MibVarsPrtGet, 5, {5, 3, 1, 2, 1}},
   /* Cover */
   {MAG_PRT_COVER_DESCRIPTION, ASN_OCTET_STR, ACL_RONLY, MibVarsPrtGet, 5, {6, 1, 1, 2, 1}},
   {MAG_PRT_COVER_STATUS, ASN_INTEGER, ACL_RONLY, MibVarsPrtGet, 5, {6, 1, 1, 3, 1}},
   /* Localization */
   {MAG_PRT_LOCAL_LANGUAGE, ASN_OCTET_STR, ACL_RONLY, MibVarsPrtGet, 5, {7, 1, 1, 2, 1}},
   {MAG_PRT_LOCAL_COUNTRY, ASN_OCTET_STR, ACL_RONLY, MibVarsPrtGet, 5, {7, 1, 1, 3, 1}},
   {MAG_PRT_LOCAL_CHAR_SET, ASN_INTEGER, ACL_RONLY, MibVarsPrtGet, 5, {7, 1, 1, 4, 1}},
   /* Input */
   {MAG_PRT_INPUT_TYPE, ASN_INTEGER, ACL_RONLY, MibVarsPrtGet, 5, {8, 2, 1, 2, 1}},
   {MAG_PRT_INPUT_DIM_UNIT, ASN_INTEGER, ACL_RONLY, MibVarsPrtGet, 5, {8, 2, 1, 3, 1}},
   {MAG_PRT_INPUT_MEDIA_DIM_FEED_DIR_DECLARED, ASN_INTEGER, ACL_RWRITE, MibVarsPrtGet, 5, {8, 2, 1, 4, 1}},
   {MAG_PRT_INPUT_MEDIA_DIM_XFEED_DIR_DECLARED, ASN_INTEGER, ACL_RWRITE, MibVarsPrtGet, 5, {8, 2, 1, 5, 1}},
   {MAG_PRT_INPUT_MEDIA_DIM_FEED_DIR_CHOSEN, ASN_INTEGER, ACL_RONLY, MibVarsPrtGet, 5, {8, 2, 1, 6, 1}},
   {MAG_PRT_INPUT_MEDIA_DIM_XFEED_DIR_CHOSEN, ASN_INTEGER, ACL_RONLY, MibVarsPrtGet, 5, {8, 2, 1, 7, 1}},
   {MAG_PRT_INPUT_CAPACITY_UNIT, ASN_INTEGER, ACL_RONLY, MibVarsPrtGet, 5, {8, 2, 1, 8, 1}},
   {MAG_PRT_INPUT_MAX_CAPACITY, ASN_INTEGER, ACL_RWRITE, MibVarsPrtGet, 5, {8, 2, 1, 9, 1}},
   {MAG_PRT_INPUT_CURRENT_LEVEL, ASN_INTEGER, ACL_RWRITE, MibVarsPrtGet, 5, {8, 2, 1, 10, 1}},
   {MAG_PRT_INPUT_STATUS, ASN_INTEGER, ACL_RONLY, MibVarsPrtGet, 5, {8, 2, 1, 11, 1}},
   {MAG_PRT_INPUT_MEDIA_NAME, ASN_OCTET_STR, ACL_RWRITE, MibVarsPrtGet, 5, {8, 2, 1, 12, 1}},
   {MAG_PRT_INPUT_NAME, ASN_OCTET_STR, ACL_RWRITE, MibVarsPrtGet, 5, {8, 2, 1, 13, 1}},
   {MAG_PRT_INPUT_VENDOR_NAME, ASN_OCTET_STR, ACL_RONLY, MibVarsPrtGet, 5, {8, 2, 1, 14, 1}},
   {MAG_PRT_INPUT_MODEL, ASN_OCTET_STR, ACL_RONLY, MibVarsPrtGet, 5, {8, 2, 1, 15, 1}},
   {MAG_PRT_INPUT_VERSION, ASN_OCTET_STR, ACL_RONLY, MibVarsPrtGet, 5, {8, 2, 1, 16, 1}},
   {MAG_PRT_INPUT_SERIAL_NUMBER, ASN_OCTET_STR, ACL_RONLY, MibVarsPrtGet, 5, {8, 2, 1, 17, 1}},
   {MAG_PRT_INPUT_DESCRIPTION, ASN_OCTET_STR, ACL_RONLY, MibVarsPrtGet, 5, {8, 2, 1, 18, 1}},
   {MAG_PRT_INPUT_SECURITY, ASN_INTEGER, ACL_RWRITE, MibVarsPrtGet, 5, {8, 2, 1, 19, 1}},
   {MAG_PRT_INPUT_MEDIA_WEIGHT, ASN_INTEGER, ACL_RWRITE, MibVarsPrtGet, 5, {8, 2, 1, 20, 1}},
   {MAG_PRT_INPUT_MEDIA_TYPE, ASN_OCTET_STR, ACL_RWRITE, MibVarsPrtGet, 5, {8, 2, 1, 21, 1}},
   {MAG_PRT_INPUT_MEDIA_COLOR, ASN_OCTET_STR, ACL_RWRITE, MibVarsPrtGet, 5, {8, 2, 1, 22, 1}},
   {MAG_PRT_INPUT_MEDIA_FORM_PARTS, ASN_INTEGER, ACL_RWRITE, MibVarsPrtGet, 5, {8, 2, 1, 23, 1}},
   /* Output */
   {MAG_PRT_OUTPUT_TYPE, ASN_INTEGER, ACL_RONLY, MibVarsPrtGet, 5, {9, 2, 1, 2, 1}},
   {MAG_PRT_OUTPUT_CAPACITY_UNIT, ASN_INTEGER, ACL_RONLY, MibVarsPrtGet, 5, {9, 2, 1, 3, 1}},
   {MAG_PRT_OUTPUT_MAX_CAPACITY, ASN_INTEGER, ACL_RWRITE, MibVarsPrtGet, 5, {9, 2, 1, 4, 1}},
   {MAG_PRT_OUTPUT_REMAINING_CAPACITY, ASN_INTEGER, ACL_RWRITE, MibVarsPrtGet, 5, {9, 2, 1, 5, 1}},
   {MAG_PRT_OUTPUT_STATUS, ASN_INTEGER, ACL_RONLY, MibVarsPrtGet, 5, {9, 2, 1, 6, 1}},
   {MAG_PRT_OUTPUT_NAME, ASN_OCTET_STR, ACL_RWRITE, MibVarsPrtGet, 5, {9, 2, 1, 7, 1}},
   {MAG_PRT_OUTPUT_VENDOR_NAME, ASN_OCTET_STR, ACL_RONLY, MibVarsPrtGet, 5, {9, 2, 1, 8, 1}},
   {MAG_PRT_OUTPUT_MODEL, ASN_OCTET_STR, ACL_RONLY, MibVarsPrtGet, 5, {9, 2, 1, 9, 1}},
   {MAG_PRT_OUTPUT_VERSION, ASN_OCTET_STR, ACL_RONLY, MibVarsPrtGet, 5, {9, 2, 1, 10, 1}},
   {MAG_PRT_OUTPUT_SERIAL_NUMBER, ASN_OCTET_STR, ACL_RONLY, MibVarsPrtGet, 5, {9, 2, 1, 11, 1}},
   {MAG_PRT_OUTPUT_DESCRIPTION, ASN_OCTET_STR, ACL_RONLY, MibVarsPrtGet, 5, {9, 2, 1, 12, 1}},
   {MAG_PRT_OUTPUT_SECURITY, ASN_INTEGER, ACL_RWRITE, MibVarsPrtGet, 5, {9, 2, 1, 13, 1}},
   {MAG_PRT_OUTPUT_DIM_UNIT, ASN_INTEGER, ACL_RONLY, MibVarsPrtGet, 5, {9, 2, 1, 14, 1}},
   {MAG_PRT_OUTPUT_MAX_DIM_FEED_DIR, ASN_INTEGER, ACL_RWRITE, MibVarsPrtGet, 5, {9, 2, 1, 15, 1}},
   {MAG_PRT_OUTPUT_MAX_DIM_XFEED_DIR, ASN_INTEGER, ACL_RWRITE, MibVarsPrtGet, 5, {9, 2, 1, 16, 1}},
   {MAG_PRT_OUTPUT_MIN_DIM_FEED_DIR, ASN_INTEGER, ACL_RWRITE, MibVarsPrtGet, 5, {9, 2, 1, 17, 1}},
   {MAG_PRT_OUTPUT_MIN_DIM_XFEED_DIR, ASN_INTEGER, ACL_RWRITE, MibVarsPrtGet, 5, {9, 2, 1, 18, 1}},
   {MAG_PRT_OUTPUT_STACKING_ORDER, ASN_INTEGER, ACL_RWRITE, MibVarsPrtGet, 5, {9, 2, 1, 19, 1}},
   {MAG_PRT_OUTPUT_PAGE_DELIVERY_ORIENTATION, ASN_INTEGER, ACL_RWRITE, MibVarsPrtGet, 5, {9, 2, 1, 20, 1}},
   {MAG_PRT_OUTPUT_BURSTING, ASN_INTEGER, ACL_RWRITE, MibVarsPrtGet, 5, {9, 2, 1, 21, 1}},
   {MAG_PRT_OUTPUT_DECOLLATING, ASN_INTEGER, ACL_RWRITE, MibVarsPrtGet, 5, {9, 2, 1, 22, 1}},
   {MAG_PRT_OUTPUT_PAGE_COLLATED, ASN_INTEGER, ACL_RWRITE, MibVarsPrtGet, 5, {9, 2, 1, 23, 1}},
   {MAG_PRT_OUTPUT_OFFSET_STACKING, ASN_INTEGER, ACL_RWRITE, MibVarsPrtGet, 5, {9, 2, 1, 24, 1}},
   /* Marker */
   {MAG_PRT_MARKER_MARK_TECH, ASN_INTEGER, ACL_RONLY, MibVarsPrtGet, 5, {10, 2, 1, 2, 1}},
   {MAG_PRT_MARKER_COUNTER_UNIT, ASN_INTEGER, ACL_RONLY, MibVarsPrtGet, 5, {10, 2, 1, 3, 1}},
   {MAG_PRT_MARKER_LIFE_COUNT, ASN_COUNTER, ACL_RONLY, MibVarsPrtGet, 5, {10, 2, 1, 4, 1}},
   {MAG_PRT_MARKER_POWER_ON_COUNT, ASN_COUNTER, ACL_RONLY, MibVarsPrtGet, 5, {10, 2, 1, 5, 1}},
   {MAG_PRT_MARKER_PROCESS_COLORANTS, ASN_INTEGER, ACL_RONLY, MibVarsPrtGet, 5, {10, 2, 1, 6, 1}},
   {MAG_PRT_MARKER_SPOT_COLORANTS, ASN_INTEGER, ACL_RONLY, MibVarsPrtGet, 5, {10, 2, 1, 7, 1}},
   {MAG_PRT_MARKER_ADDRESSABILITY_UNIT, ASN_INTEGER, ACL_RONLY, MibVarsPrtGet, 5, {10, 2, 1, 8, 1}},
   {MAG_PRT_MARKER_ADDRESSABILITY_FEED_DIR, ASN_INTEGER, ACL_RONLY, MibVarsPrtGet, 5, {10, 2, 1, 9, 1}},
   {MAG_PRT_MARKER_ADDRESSABILITY_XFEED_DIR, ASN_INTEGER, ACL_RONLY, MibVarsPrtGet, 5, {10, 2, 1, 10, 1}},
   {MAG_PRT_MARKER_NORTH_MARGIN, ASN_INTEGER, ACL_RONLY, MibVarsPrtGet, 5, {10, 2, 1, 11, 1}},
   {MAG_PRT_MARKER_SOUTH_MARGIN, ASN_INTEGER, ACL_RONLY, MibVarsPrtGet, 5, {10, 2, 1, 12, 1}},
   {MAG_PRT_MARKER_WEST_MARGIN, ASN_INTEGER, ACL_RONLY, MibVarsPrtGet, 5, {10, 2, 1, 13, 1}},
   {MAG_PRT_MARKER_EAST_MARGIN, ASN_INTEGER, ACL_RONLY, MibVarsPrtGet, 5, {10, 2, 1, 14, 1}},
   {MAG_PRT_MARKER_STATUS, ASN_INTEGER, ACL_RONLY, MibVarsPrtGet, 5, {10, 2, 1, 15, 1}},
   /* Marker Supplies */
   {MAG_PRT_MARKER_SUPPLIES_MARKER_INDEX, ASN_INTEGER, ACL_RONLY, MibVarsPrtGet, 5, {11, 1, 1, 2, 1}},
   {MAG_PRT_MARKER_SUPPLIES_COLORANT_INDEX, ASN_INTEGER, ACL_RONLY, MibVarsPrtGet, 5, {11, 1, 1, 3, 1}},
   {MAG_PRT_MARKER_SUPPLIES_CLASS, ASN_INTEGER, ACL_RONLY, MibVarsPrtGet, 5, {11, 1, 1, 4, 1}},
   {MAG_PRT_MARKER_SUPPLIES_TYPE, ASN_INTEGER, ACL_RONLY, MibVarsPrtGet, 5, {11, 1, 1, 5, 1}},
   {MAG_PRT_MARKER_SUPPLIES_DESCRIPTION, ASN_OCTET_STR, ACL_RONLY, MibVarsPrtGet, 5, {11, 1, 1, 6, 1}},
   {MAG_PRT_MARKER_SUPPLIES_SUPPLY_UNIT, ASN_INTEGER, ACL_RONLY, MibVarsPrtGet, 5, {11, 1, 1, 7, 1}},
   {MAG_PRT_MARKER_SUPPLIES_MAX_CAPACITY, ASN_INTEGER, ACL_RONLY, MibVarsPrtGet, 5, {11, 1, 1, 8, 1}},
   {MAG_PRT_MARKER_SUPPLIES_LEVEL, ASN_INTEGER, ACL_RONLY, MibVarsPrtGet, 5, {11, 1, 1, 9, 1}},
   /* Marker Colorant */
   {MAG_PRT_MARKER_COLORANT_MARKER_INDEX, ASN_INTEGER, ACL_RONLY, MibVarsPrtGet, 5, {12, 1, 1, 2, 1}},
   {MAG_PRT_MARKER_COLORANT_ROLE, ASN_INTEGER, ACL_RONLY, MibVarsPrtGet, 5, {12, 1, 1, 3, 1}},
   {MAG_PRT_MARKER_COLORANT_VALUE, ASN_OCTET_STR, ACL_RONLY, MibVarsPrtGet, 5, {12, 1, 1, 4, 1}},
   {MAG_PRT_MARKER_COLORANT_TONALITY, ASN_INTEGER, ACL_RONLY, MibVarsPrtGet, 5, {12, 1, 1, 5, 1}},
   /* Marker Path */
   {MAG_PRT_MEDIA_PATH_MAX_SPEED_PRINT_UNIT, ASN_INTEGER, ACL_RONLY, MibVarsPrtGet, 5, {13, 4, 1, 2, 1}},
   {MAG_PRT_MEDIA_PATH_MEDIA_SIZE_UNIT, ASN_INTEGER, ACL_RONLY, MibVarsPrtGet, 5, {13, 4, 1, 3, 1}},
   {MAG_PRT_MEDIA_PATH_MAX_SPEED, ASN_INTEGER, ACL_RONLY, MibVarsPrtGet, 5, {13, 4, 1, 4, 1}},
   {MAG_PRT_MEDIA_PATH_MAX_MEDIA_FEED_DIR, ASN_INTEGER, ACL_RONLY, MibVarsPrtGet, 5, {13, 4, 1, 5, 1}},
   {MAG_PRT_MEDIA_PATH_MAX_MEDIA_XFEED_DIR, ASN_INTEGER, ACL_RONLY, MibVarsPrtGet, 5, {13, 4, 1, 6, 1}},
   {MAG_PRT_MEDIA_PATH_MIN_MEDIA_FEED_DIR, ASN_INTEGER, ACL_RONLY, MibVarsPrtGet, 5, {13, 4, 1, 7, 1}},
   {MAG_PRT_MEDIA_PATH_MIN_MEDIA_XFEED_DIR, ASN_INTEGER, ACL_RONLY, MibVarsPrtGet, 5, {13, 4, 1, 8, 1}},
   {MAG_PRT_MEDIA_PATH_TYPE, ASN_INTEGER, ACL_RONLY, MibVarsPrtGet, 5, {13, 4, 1, 9, 1}},
   {MAG_PRT_MEDIA_PATH_DESCRIPTION, ASN_OCTET_STR, ACL_RONLY, MibVarsPrtGet, 5, {13, 4, 1, 10, 1}},
   {MAG_PRT_MEDIA_PATH_STATUS, ASN_INTEGER, ACL_RONLY, MibVarsPrtGet, 5, {13, 4, 1, 11, 1}},
   /* Channel */
   {MAG_PRT_CHANNEL_TYPE, ASN_INTEGER, ACL_RONLY, MibVarsPrtGet, 5, {14, 1, 1, 2, 1}},
   {MAG_PRT_CHANNEL_PROTOCOL_VERSION, ASN_OCTET_STR, ACL_RONLY, MibVarsPrtGet, 5, {14, 1, 1, 3, 1}},
   {MAG_PRT_CHANNEL_CURRENT_JOB_CNTL_LANG_INDEX, ASN_INTEGER, ACL_RWRITE, MibVarsPrtGet, 5, {14, 1, 1, 4, 1}},
   {MAG_PRT_CHANNEL_DEFAULT_PAGE_DESC_LANG_INDEX, ASN_INTEGER, ACL_RWRITE, MibVarsPrtGet, 5, {14, 1, 1, 5, 1}},
   {MAG_PRT_CHANNEL_STATE, ASN_INTEGER, ACL_RWRITE, MibVarsPrtGet, 5, {14, 1, 1, 6, 1}},
   {MAG_PRT_CHANNEL_IF_INDEX, ASN_INTEGER, ACL_RWRITE, MibVarsPrtGet, 5, {14, 1, 1, 7, 1}},
   {MAG_PRT_CHANNEL_STATUS, ASN_INTEGER, ACL_RONLY, MibVarsPrtGet, 5, {14, 1, 1, 8, 1}},
   /* Interpreter */
   {MAG_PRT_INTERPRETER_LANG_FAMILY, ASN_INTEGER, ACL_RONLY, MibVarsPrtGet, 5, {15, 1, 1, 2, 1}},
   {MAG_PRT_INTERPRETER_LANG_LEVEL, ASN_OCTET_STR, ACL_RONLY, MibVarsPrtGet, 5, {15, 1, 1, 3, 1}},
   {MAG_PRT_INTERPRETER_LANG_VERSION, ASN_OCTET_STR, ACL_RONLY, MibVarsPrtGet, 5, {15, 1, 1, 4, 1}},
   {MAG_PRT_INTERPRETER_DESCRIPTION, ASN_OCTET_STR, ACL_RONLY, MibVarsPrtGet, 5, {15, 1, 1, 5, 1}},
   {MAG_PRT_INTERPRETER_VERSION, ASN_OCTET_STR, ACL_RONLY, MibVarsPrtGet, 5, {15, 1, 1, 6, 1}},
   {MAG_PRT_INTERPRETER_DEFAULT_ORIENTATION, ASN_INTEGER, ACL_RWRITE, MibVarsPrtGet, 5, {15, 1, 1, 7, 1}},
   {MAG_PRT_INTERPRETER_FEED_ADDRESSABILITY, ASN_INTEGER, ACL_RONLY, MibVarsPrtGet, 5, {15, 1, 1, 8, 1}},
   {MAG_PRT_INTERPRETER_XFEED_ADDRESSABILITY, ASN_INTEGER, ACL_RONLY, MibVarsPrtGet, 5, {15, 1, 1, 9, 1}},
   {MAG_PRT_INTERPRETER_DEFAULT_CHAR_SET_IN, ASN_INTEGER, ACL_RWRITE, MibVarsPrtGet, 5, {15, 1, 1, 10, 1}},
   {MAG_PRT_INTERPRETER_DEFAULT_CHAR_SET_OUT, ASN_INTEGER, ACL_RWRITE, MibVarsPrtGet, 5, {15, 1, 1, 11, 1}},
   {MAG_PRT_INTERPRETER_TWO_WAY, ASN_INTEGER, ACL_RONLY, MibVarsPrtGet, 5, {15, 1, 1, 12, 1}},
   /* Console Display Buffer */
   {MAG_PRT_CONSOLE_DISPLAY_BUFFER_TEXT, ASN_OCTET_STR, ACL_RWRITE, MibVarsPrtGet, 5, {16, 5, 1, 2, 1}},
   /* Console Lights */
   {MAG_PRT_CONSOLE_ON_TIME, ASN_INTEGER, ACL_RONLY, MibVarsPrtGet, 5, {17, 6, 1, 2, 1}},
   {MAG_PRT_CONSOLE_OFF_TIME, ASN_INTEGER, ACL_RONLY, MibVarsPrtGet, 5, {17, 6, 1, 3, 1}},
   {MAG_PRT_CONSOLE_COLOR, ASN_INTEGER, ACL_RONLY, MibVarsPrtGet, 5, {17, 6, 1, 4, 1}},
   {MAG_PRT_CONSOLE_DESCRIPTION, ASN_OCTET_STR, ACL_RONLY, MibVarsPrtGet, 5, {17, 6, 1, 5, 1}},
};

/* General */
static long prtGeneralConfigChanges = 0;
static long prtGeneralCurrentLocalization = 1;
static long prtGeneralReset = 3;   /* notResetting */
static char prtGeneralCurrentOperator[128] = "";
static char prtGeneralServicePerson[128] = "";
static long prtInputDefaultIndex = 1;
static long prtOutputDefaultIndex = 1;
static long prtMarkerDefaultIndex = 1;
static long prtMediaPathDefaultIndex = 1;
static long prtConsoleLocalization = 1;
static long prtConsoleNumberOfDisplayLines = 2;
static long prtConsoleNumberOfDisplayChars = 16;
static long prtConsoleDisable = 3;   /* enabled */
static long prtAuxiliarySheetStartupPage = 2;
static long prtAuxiliarySheetBannerPage = 2;
static char prtGeneralPrinterName[128] = "Barcode Printer";
static char prtGeneralSerialNumber[256] = "0000000000000000";
static long prtAlertCriticalEvents = 0;
static long prtAlertAllEvents = 0;
static long prtDeviceRefIndex = 1;
/* Cover */
static char *prtCoverDescription = "Platen";
static long prtCoverStatus = 4;   /* doorClosed */
/* Localization */
static char *prtLocalizationLanguage = "en";
static char *prtLocalizationCountry = "US";
static long prtLocalizationCharacterSet = 3;   /* csASCII */
/* Input */
static long prtInputType = 6;   /* continuousRoll */
static long prtInputDimUnit = 4;   /* micrometers */
static long prtInputMediaDimFeedDirDeclared = -1;   /* other */
static long prtInputMediaDimXFeedDirDeclared = -1;   /* other */
static long prtInputMediaDimFeedDirChosen = -1;   /* other */
static long prtInputMediaDimXFeedDirChosen = -1;   /* other */
static long prtInputCapacityUnit = 4;   /* micrometers */
static long prtInputMaxCapacity = -1;   /* other */
static long prtInputCurrentLevel = -2;   /* unknown */
static long prtInputStatus = 0;
static char prtInputMediaName[64] = "";
static char prtInputName[64] = "STANDARD INBIN";
static char *prtInputVendorName = "";
static char *prtInputModel = "";
static char *prtInputVersion = "";
static char *prtInputSerialNumber = "";
static char *prtInputDescription = "Tractor Feed";
static long prtInputSecurity = 5;   /* notPresent */
static long prtInputMediaWeight = -2;   /* unknown */
static char prtInputMediaType[64] = "Roll";
static char prtInputMediaColor[64] = "unknown";
static long prtInputMediaFormParts = -2;   /* unknown */
/* Output */
static long prtOutputType = 5;   /* continuousRollDevice */
static long prtOutputCapacityUnit = 4;   /* micrometers */
static long prtOutputMaxCapacity = -2;   /* unknown */
static long prtOutputRemainingCapacity = -2;   /* unknown */
static long prtOutputStatus = 0;
static char prtOutputName[64] = "STANDARD OUTBIN";
static char *prtOutputVendorName = "";
static char *prtOutputModel = "";
static char *prtOutputVersion = "";
static char *prtOutputSerialNumber = "";
static char *prtOutputDescription = "Tractor Feed";
static long prtOutputSecurity = 5; /* notPresent */
static long prtOutputDimUnit = 4;   /* micrometers */
static long prtOutputMaxDimFeedDir = -2;   /* unknown */
static long prtOutputMaxDimXFeedDir = -2;   /* unknown */
static long prtOutputMinDimFeedDir = -2;   /* unknown */
static long prtOutputMinDimXFeedDir = -2;   /* unknown */
static long prtOutputStackingOrder = 3;   /* firstToLast */
static long prtOutputPageDeliveryOrientation = 3;   /* faceUp */
static long prtOutputBursting = 5;   /* notPresent */
static long prtOutputDecollating = 5;   /* notPresent */
static long prtOutputPageCollated = 5;   /* notPresent */
static long prtOutputOffsetStacking = 5;   /* notPresent */
/* Marker */
static long prtMarkerMarkTech = 16;   /* thermalTransfer */
static long prtMarkerCounterUnit = 9;   /* dotRow */
static long prtMarkerLifeCount = 400000000;
static long prtMarkerPowerOnCount = 0;
static long prtMarkerProcessColorants = 1;
static long prtMarkerSpotColorants = 0;
static long prtMarkerAddressabilityUnit = 4;   /* micrometers */
static long prtMarkerAddressabilityFeedDir = -2;   /* unknown */
static long prtMarkerAddressabilityXFeedDir = -2;   /* unknown */
static long prtMarkerNorthMargin = -2;   /* unknown */
static long prtMarkerSouthMargin = -2;   /* unknown */
static long prtMarkerWestMargin = -2;   /* unknown */
static long prtMarkerEastMargin = -2;   /* unknown */
static long prtMarkerStatus = 0;
/* Marker Supplies */
static long prtMarkerSuppliesMarkerIndex = 1;
static long prtMarkerSuppliesColorantIndex = 1;
static long prtMarkerSuppliesClass = 3;   /* supplyThatIsConsumed */
static long prtMarkerSuppliesType = 13;   /* ribbonWax */
static char *prtMarkerSuppliesDescription = "Black Ribbon";
static long prtMarkerSuppliesSupplyUnit = 4;   /* micrometer */
static long prtMarkerSuppliesMaxCapacity = 300000000;
static long prtMarkerSuppliesLevel = 40;
/* Marker Colorant */
static long prtMarkerColorantMarkerIndex = 1;
static long prtMarkerColorantRole = 3;
static char *prtMarkerColorantValue = "black";
static long prtMarkerColorantTonality = 2;
/* Marker Path */
static long prtMediaPathMaxSpeedPrintUnit = 4;   /* micrometerPerHour */
static long prtMediaPathMediaSizeUnit = 4;   /* micrometers */
static long prtMediaPathMaxSpeed = 540000000;
static long prtMediaPathMaxMediaFeedDir = -1;   /* unlimited */
static long prtMediaPathMaxMediaXFeedDir = -2;   /* unknown */
static long prtMediaPathMinMediaFeedDir = -2;   /* unknown */
static long prtMediaPathMinMediaXFeedDir = -2;   /* unknown */
static long prtMediaPathType = 5;   /* simplex */
static char *prtMediaPathDescription = "Simplex";
static long prtMediaPathStatus = 0;
/* Channel */
static long prtChannelType = 11;   /* chPort9100 */
static char *prtChannelProtocolVersion = "";
static long prtChannelCurrentJobCntlLangIndex = 0;
static long prtChannelDefaultPageDescLangIndex = 0;
static long prtChannelState = 3;   /* printDataAccepted */
static long prtChannelIfIndex = 0;
static long prtChannelStatus = 0;
/* Interpreter */
static long prtInterpreterLangFamily = 1;   /* other */
static char *prtInterpreterLangLevel = "EZ";
static char *prtInterpreterLangVersion = "";
static char *prtInterpreterDescription = "EZ";
static char prtInterpreterVersion[] = { 0x00,0x00,0x00,0x03 };
static long prtInterpreterDefaultOrientation = 3;   /* portrait */
static long prtInterpreterFeedAddressability = -1;   /* other */
static long prtInterpreterXFeedAddressability = -1;   /* other */
static long prtInterpreterDefaultCharSetIn = 1;   /* other */
static long prtInterpreterDefaultCharSetOut = 1;   /* other */
static long prtInterpreterTwoWay = 4;   /* no */
/* Console Display Buffer */
static char prtConsoleDisplayBufferText[256] = "Online";
/* Console Lights */
static long prtConsoleOnTime = 1;
static long prtConsoleOffTime = 0;
static long prtConsoleColor = 5;   /* green */
static char *prtConsoleDescription = "Ready";

/******************************************************************************
* *
* L O C A L U N I T I A L I Z E D D A T A D E F I N I T I O N S *
* *
******************************************************************************/

/*!
* \brief Register MIB II printter variables.
*
* \note Preliminary code with hard coded values.
*/
int MibRegisterPrtVars(void)
{
return SnmpMibRegister(base_oid, base_oidlen, mib_variables, sizeof(mib_variables) / sizeof(SNMPVAR));
}

static int MibVarsPrtSet(int action, u_char * var_val, u_char var_val_type, size_t var_val_len, OID * name, size_t name_len)
{
   if (action != SNMP_ACT_COMMIT) {
       return 0;
   }
   return 0;
}

static u_char *MibVarsPrtGet(CONST SNMPVAR * vp, OID * name, size_t * namelen, int exact, size_t * varlen, WMETHOD ** wmethod)
{
   int rc;
   int devc = 0;
   OID *fullname;
   size_t fullnamelen = base_oidlen + vp->var_namelen + 1;

   if ((fullname = NutHeapAlloc(fullnamelen * sizeof(OID))) == NULL) {
       return NULL;
   }
   memcpy(fullname, base_oid, base_oidlen * sizeof(OID));
   memcpy(fullname + base_oidlen, vp->var_name, vp->var_namelen * sizeof(OID));

   /* Determine the device number. */
   *(fullname + fullnamelen - 1) = devc + 1;
   rc = SnmpOidCmp(name, *namelen, fullname, fullnamelen);
   if ((exact && rc) || (!exact && rc >= 0)) {
       NutHeapFree(fullname);
       return NULL;
   }
   memcpy(name, fullname, fullnamelen * sizeof(OID));
   *namelen = fullnamelen;
   NutHeapFree(fullname);

   *wmethod = NULL;
   *varlen = sizeof(long);
   switch (vp->var_magic) {
   /* General */
   case MAG_PRT_GENERAL_CONFIG_CHANGES:
       return (u_char *) & prtGeneralConfigChanges;
   case MAG_PRT_GENERAL_CURRENT_LOCAL:
       return (u_char *) & prtGeneralCurrentLocalization;
   case MAG_PRT_GENERAL_RESET:
       return (u_char *) & prtGeneralReset;
   case MAG_PRT_GENERAL_CURRENT_OPERATOR:
       *varlen = strlen(prtGeneralCurrentOperator);
       return (u_char *) prtGeneralCurrentOperator;
   case MAG_PRT_GENERAL_SERVICE_PERSON:
       *varlen = strlen(prtGeneralServicePerson);
       return (u_char *) prtGeneralServicePerson;
   case MAG_PRT_INPUT_DEFAULT_INDEX:
       return (u_char *) & prtInputDefaultIndex;
   case MAG_PRT_OUTPUT_DEFAULT_INDEX:
       return (u_char *) & prtOutputDefaultIndex;
   case MAG_PRT_MARKER_DEFAULT_INDEX:
       return (u_char *) & prtMarkerDefaultIndex;
   case MAG_PRT_MEDIA_PATH_DEFAULT_INDEX:
       return (u_char *) & prtMediaPathDefaultIndex;
   case MAG_PRT_CONSOLE_LOCAL:
       return (u_char *) & prtConsoleLocalization;
   case MAG_PRT_CONSOLE_NUMBER_OF_DISPLAY_LINES:
       return (u_char *) & prtConsoleNumberOfDisplayLines;
   case MAG_PRT_CONSOLE_NUMBER_OF_DISPLAY_CHARS:
       return (u_char *) & prtConsoleNumberOfDisplayChars;
   case MAG_PRT_CONSOLE_DISABLE:
       return (u_char *) & prtConsoleDisable;
   case MAG_PRT_AUXILIARY_SHEET_STARTUP_PAGE:
       return (u_char *) & prtAuxiliarySheetStartupPage;
   case MAG_PRT_AUXILIARY_SHEET_BANNER_PAGE:
       return (u_char *) & prtAuxiliarySheetBannerPage;
   case MAG_PRT_GENERAL_PRINTER_NAME:
       *varlen = strlen(prtGeneralPrinterName);
       return (u_char *) prtGeneralPrinterName;
   case MAG_PRT_GENERAL_SERIAL_NUMBER:
       *varlen = strlen(prtGeneralSerialNumber);
       return (u_char *) prtGeneralSerialNumber;
   case MAG_PRT_ALERT_CRITICAL_EVENTS:
       return (u_char *) & prtAlertCriticalEvents;
   case MAG_PRT_ALERT_ALL_EVENTS:
       return (u_char *) & prtAlertAllEvents;
   case MAG_PRT_DEVICE_REF_INDEX:
       return (u_char *) & prtDeviceRefIndex;
   /* Cover */
   case MAG_PRT_COVER_DESCRIPTION:
       *varlen = strlen(prtCoverDescription);
       return (u_char *) prtCoverDescription;
   case MAG_PRT_COVER_STATUS:
       return (u_char *) & prtCoverStatus;
   /* Localization */
   case MAG_PRT_LOCAL_LANGUAGE:
       *varlen = strlen(prtLocalizationLanguage);
       return (u_char *) prtLocalizationLanguage;
   case MAG_PRT_LOCAL_COUNTRY:
       *varlen = strlen(prtLocalizationCountry);
       return (u_char *) prtLocalizationCountry;
   case MAG_PRT_LOCAL_CHAR_SET:
       return (u_char *) & prtLocalizationCharacterSet;
   /* Input */
   case MAG_PRT_INPUT_TYPE:
       return (u_char *) & prtInputType;
   case MAG_PRT_INPUT_DIM_UNIT:
       return (u_char *) & prtInputDimUnit;
   case MAG_PRT_INPUT_MEDIA_DIM_FEED_DIR_DECLARED:
       return (u_char *) & prtInputMediaDimFeedDirDeclared;
   case MAG_PRT_INPUT_MEDIA_DIM_XFEED_DIR_DECLARED:
       return (u_char *) & prtInputMediaDimXFeedDirDeclared;
   case MAG_PRT_INPUT_MEDIA_DIM_FEED_DIR_CHOSEN:
       return (u_char *) & prtInputMediaDimFeedDirChosen;
   case MAG_PRT_INPUT_MEDIA_DIM_XFEED_DIR_CHOSEN:
       return (u_char *) & prtInputMediaDimXFeedDirChosen;
   case MAG_PRT_INPUT_CAPACITY_UNIT:
       return (u_char *) & prtInputCapacityUnit;
   case MAG_PRT_INPUT_MAX_CAPACITY:
       return (u_char *) & prtInputMaxCapacity;
   case MAG_PRT_INPUT_CURRENT_LEVEL:
       return (u_char *) & prtInputCurrentLevel;
   case MAG_PRT_INPUT_STATUS:
       return (u_char *) & prtInputStatus;
   case MAG_PRT_INPUT_MEDIA_NAME:
       *varlen = strlen(prtInputMediaName);
       return (u_char *) prtInputMediaName;
   case MAG_PRT_INPUT_NAME:
       *varlen = strlen(prtInputName);
       return (u_char *) prtInputName;
   case MAG_PRT_INPUT_VENDOR_NAME:
       *varlen = strlen(prtInputVendorName);
       return (u_char *) prtInputVendorName;
   case MAG_PRT_INPUT_MODEL:
       *varlen = strlen(prtInputModel);
       return (u_char *) prtInputModel;
   case MAG_PRT_INPUT_VERSION:
       *varlen = strlen(prtInputVersion);
       return (u_char *) prtInputVersion;
   case MAG_PRT_INPUT_SERIAL_NUMBER:
       *varlen = strlen(prtInputSerialNumber);
       return (u_char *) prtInputSerialNumber;
   case MAG_PRT_INPUT_DESCRIPTION:
       *varlen = strlen(prtInputDescription);
       return (u_char *) prtInputDescription;
   case MAG_PRT_INPUT_SECURITY:
       return (u_char *) & prtInputSecurity;
   case MAG_PRT_INPUT_MEDIA_WEIGHT:
       return (u_char *) & prtInputMediaWeight;
   case MAG_PRT_INPUT_MEDIA_TYPE:
       *varlen = strlen(prtInputMediaType);
       return (u_char *) prtInputMediaType;
   case MAG_PRT_INPUT_MEDIA_COLOR:
       *varlen = strlen(prtInputMediaColor);
       return (u_char *) prtInputMediaColor;
   case MAG_PRT_INPUT_MEDIA_FORM_PARTS:
       return (u_char *) & prtInputMediaFormParts;
   /* Output */
   case MAG_PRT_OUTPUT_TYPE:
       return (u_char *) & prtOutputType;
   case MAG_PRT_OUTPUT_CAPACITY_UNIT:
       return (u_char *) & prtOutputCapacityUnit;
   case MAG_PRT_OUTPUT_MAX_CAPACITY:
       return (u_char *) & prtOutputMaxCapacity;
   case MAG_PRT_OUTPUT_REMAINING_CAPACITY:
       return (u_char *) & prtOutputRemainingCapacity;
   case MAG_PRT_OUTPUT_STATUS:
       return (u_char *) & prtOutputStatus;
   case MAG_PRT_OUTPUT_NAME:
       *varlen = strlen(prtOutputName);
       return (u_char *) prtOutputName;
   case MAG_PRT_OUTPUT_VENDOR_NAME:
       *varlen = strlen(prtOutputVendorName);
       return (u_char *) prtOutputVendorName;
   case MAG_PRT_OUTPUT_MODEL:
       *varlen = strlen(prtOutputModel);
       return (u_char *) prtOutputModel;
   case MAG_PRT_OUTPUT_VERSION:
       *varlen = strlen(prtOutputVersion);
       return (u_char *) prtOutputVersion;
   case MAG_PRT_OUTPUT_SERIAL_NUMBER:
       *varlen = strlen(prtOutputSerialNumber);
       return (u_char *) prtOutputSerialNumber;
   case MAG_PRT_OUTPUT_DESCRIPTION:
       *varlen = strlen(prtOutputDescription);
       return (u_char *) prtOutputDescription;
   case MAG_PRT_OUTPUT_SECURITY:
       return (u_char *) & prtOutputSecurity;
   case MAG_PRT_OUTPUT_DIM_UNIT:
       return (u_char *) & prtOutputDimUnit;
   case MAG_PRT_OUTPUT_MAX_DIM_FEED_DIR:
       return (u_char *) & prtOutputMaxDimFeedDir;
   case MAG_PRT_OUTPUT_MAX_DIM_XFEED_DIR:
       return (u_char *) & prtOutputMaxDimXFeedDir;
   case MAG_PRT_OUTPUT_MIN_DIM_FEED_DIR:
       return (u_char *) & prtOutputMinDimFeedDir;
   case MAG_PRT_OUTPUT_MIN_DIM_XFEED_DIR:
       return (u_char *) & prtOutputMinDimXFeedDir;
   case MAG_PRT_OUTPUT_STACKING_ORDER:
       return (u_char *) & prtOutputStackingOrder;
   case MAG_PRT_OUTPUT_PAGE_DELIVERY_ORIENTATION:
       return (u_char *) & prtOutputPageDeliveryOrientation;
   case MAG_PRT_OUTPUT_BURSTING:
       return (u_char *) & prtOutputBursting;
   case MAG_PRT_OUTPUT_DECOLLATING:
       return (u_char *) & prtOutputDecollating;
   case MAG_PRT_OUTPUT_PAGE_COLLATED:
       return (u_char *) & prtOutputPageCollated;
   case MAG_PRT_OUTPUT_OFFSET_STACKING:
       return (u_char *) & prtOutputOffsetStacking;
   /* Marker */
   case MAG_PRT_MARKER_MARK_TECH:
       return (u_char *) & prtMarkerMarkTech;
   case MAG_PRT_MARKER_COUNTER_UNIT:
       return (u_char *) & prtMarkerCounterUnit;
   case MAG_PRT_MARKER_LIFE_COUNT:
       return (u_char *) & prtMarkerLifeCount;
   case MAG_PRT_MARKER_POWER_ON_COUNT:
       return (u_char *) & prtMarkerPowerOnCount;
   case MAG_PRT_MARKER_PROCESS_COLORANTS:
       return (u_char *) & prtMarkerProcessColorants;
   case MAG_PRT_MARKER_SPOT_COLORANTS:
       return (u_char *) & prtMarkerSpotColorants;
   case MAG_PRT_MARKER_ADDRESSABILITY_UNIT:
       return (u_char *) & prtMarkerAddressabilityUnit;
   case MAG_PRT_MARKER_ADDRESSABILITY_FEED_DIR:
       return (u_char *) & prtMarkerAddressabilityFeedDir;
   case MAG_PRT_MARKER_ADDRESSABILITY_XFEED_DIR:
       return (u_char *) & prtMarkerAddressabilityXFeedDir;
   case MAG_PRT_MARKER_NORTH_MARGIN:
       return (u_char *) & prtMarkerNorthMargin;
   case MAG_PRT_MARKER_SOUTH_MARGIN:
       return (u_char *) & prtMarkerSouthMargin;
   case MAG_PRT_MARKER_WEST_MARGIN:
       return (u_char *) & prtMarkerWestMargin;
   case MAG_PRT_MARKER_EAST_MARGIN:
       return (u_char *) & prtMarkerEastMargin;
   case MAG_PRT_MARKER_STATUS:
       return (u_char *) & prtMarkerStatus;
   /* Marker Supplies */
   case MAG_PRT_MARKER_SUPPLIES_MARKER_INDEX:
       return (u_char *) & prtMarkerSuppliesMarkerIndex;
   case MAG_PRT_MARKER_SUPPLIES_COLORANT_INDEX:
       return (u_char *) & prtMarkerSuppliesColorantIndex;
   case MAG_PRT_MARKER_SUPPLIES_CLASS:
       return (u_char *) & prtMarkerSuppliesClass;
   case MAG_PRT_MARKER_SUPPLIES_TYPE:
       return (u_char *) & prtMarkerSuppliesType;
   case MAG_PRT_MARKER_SUPPLIES_DESCRIPTION:
       *varlen = strlen(prtMarkerSuppliesDescription);
       return (u_char *) prtMarkerSuppliesDescription;
   case MAG_PRT_MARKER_SUPPLIES_SUPPLY_UNIT:
       return (u_char *) & prtMarkerSuppliesSupplyUnit;
   case MAG_PRT_MARKER_SUPPLIES_MAX_CAPACITY:
       return (u_char *) & prtMarkerSuppliesMaxCapacity;
   case MAG_PRT_MARKER_SUPPLIES_LEVEL:
       return (u_char *) & prtMarkerSuppliesLevel;
   /* Marker Colorant */
   case MAG_PRT_MARKER_COLORANT_MARKER_INDEX:
       return (u_char *) & prtMarkerColorantMarkerIndex;
   case MAG_PRT_MARKER_COLORANT_ROLE:
       return (u_char *) & prtMarkerColorantRole;
   case MAG_PRT_MARKER_COLORANT_VALUE:
       *varlen = strlen(prtMarkerColorantValue);
       return (u_char *) prtMarkerColorantValue;
   case MAG_PRT_MARKER_COLORANT_TONALITY:
       return (u_char *) & prtMarkerColorantTonality;
   /* Marker Path */
   case MAG_PRT_MEDIA_PATH_MAX_SPEED_PRINT_UNIT:
       return (u_char *) & prtMediaPathMaxSpeedPrintUnit;
   case MAG_PRT_MEDIA_PATH_MEDIA_SIZE_UNIT:
       return (u_char *) & prtMediaPathMediaSizeUnit;
   case MAG_PRT_MEDIA_PATH_MAX_SPEED:
       return (u_char *) & prtMediaPathMaxSpeed;
   case MAG_PRT_MEDIA_PATH_MAX_MEDIA_FEED_DIR:
       return (u_char *) & prtMediaPathMaxMediaFeedDir;
   case MAG_PRT_MEDIA_PATH_MAX_MEDIA_XFEED_DIR:
       return (u_char *) & prtMediaPathMaxMediaXFeedDir;
   case MAG_PRT_MEDIA_PATH_MIN_MEDIA_FEED_DIR:
       return (u_char *) & prtMediaPathMinMediaFeedDir;
   case MAG_PRT_MEDIA_PATH_MIN_MEDIA_XFEED_DIR:
       return (u_char *) & prtMediaPathMinMediaXFeedDir;
   case MAG_PRT_MEDIA_PATH_TYPE:
       return (u_char *) & prtMediaPathType;
   case MAG_PRT_MEDIA_PATH_DESCRIPTION:
       *varlen = strlen(prtMediaPathDescription);
       return (u_char *) prtMediaPathDescription;
   case MAG_PRT_MEDIA_PATH_STATUS:
       return (u_char *) & prtMediaPathStatus;
   /* Channel */
   case MAG_PRT_CHANNEL_TYPE:
       return (u_char *) & prtChannelType;
   case MAG_PRT_CHANNEL_PROTOCOL_VERSION:
       *varlen = strlen(prtChannelProtocolVersion);
       return (u_char *) prtChannelProtocolVersion;
   case MAG_PRT_CHANNEL_CURRENT_JOB_CNTL_LANG_INDEX:
       return (u_char *) & prtChannelCurrentJobCntlLangIndex;
   case MAG_PRT_CHANNEL_DEFAULT_PAGE_DESC_LANG_INDEX:
       return (u_char *) & prtChannelDefaultPageDescLangIndex;
   case MAG_PRT_CHANNEL_STATE:
       return (u_char *) & prtChannelState;
   case MAG_PRT_CHANNEL_IF_INDEX:
       return (u_char *) & prtChannelIfIndex;
   case MAG_PRT_CHANNEL_STATUS:
       return (u_char *) & prtChannelStatus;
   /* Interpreter */
   case MAG_PRT_INTERPRETER_LANG_FAMILY:
       return (u_char *) & prtInterpreterLangFamily;
   case MAG_PRT_INTERPRETER_LANG_LEVEL:
       *varlen = strlen(prtInterpreterLangLevel);
       return (u_char *) prtInterpreterLangLevel;
   case MAG_PRT_INTERPRETER_LANG_VERSION:
       *varlen = strlen(prtInterpreterLangVersion);
       return (u_char *) prtInterpreterLangVersion;
   case MAG_PRT_INTERPRETER_DESCRIPTION:
       *varlen = strlen(prtInterpreterDescription);
       return (u_char *) prtInterpreterDescription;
   case MAG_PRT_INTERPRETER_VERSION:
       *varlen = sizeof(prtInterpreterVersion);
       return (u_char *) prtInterpreterVersion;
   case MAG_PRT_INTERPRETER_DEFAULT_ORIENTATION:
       return (u_char *) & prtInterpreterDefaultOrientation;
   case MAG_PRT_INTERPRETER_FEED_ADDRESSABILITY:
       return (u_char *) & prtInterpreterFeedAddressability;
   case MAG_PRT_INTERPRETER_XFEED_ADDRESSABILITY:
       return (u_char *) & prtInterpreterXFeedAddressability;
   case MAG_PRT_INTERPRETER_DEFAULT_CHAR_SET_IN:
       return (u_char *) & prtInterpreterDefaultCharSetIn;
   case MAG_PRT_INTERPRETER_DEFAULT_CHAR_SET_OUT:
       return (u_char *) & prtInterpreterDefaultCharSetOut;
   case MAG_PRT_INTERPRETER_TWO_WAY:
       return (u_char *) & prtInterpreterTwoWay;
   /* Console Display Buffer */
   case MAG_PRT_CONSOLE_DISPLAY_BUFFER_TEXT:
       *varlen = strlen(prtConsoleDisplayBufferText);
       return (u_char *) prtConsoleDisplayBufferText;
   /* Console Lights */
   case MAG_PRT_CONSOLE_ON_TIME:
       return (u_char *) & prtConsoleOnTime;
   case MAG_PRT_CONSOLE_OFF_TIME:
       return (u_char *) & prtConsoleOffTime;
   case MAG_PRT_CONSOLE_COLOR:
       return (u_char *) & prtConsoleColor;
   case MAG_PRT_CONSOLE_DESCRIPTION:
       *varlen = strlen(prtConsoleDescription);
       return (u_char *) prtConsoleDescription;
   }
   return NULL;
}

#endif

mib2sys.c 。。。。。。。。。。。。。。。。。。。。。。。。。。。

/******************************************************************************
* *
* M O D U L E D E F I N E *
* *
******************************************************************************/

#define MIB2SYS_C

#include <string.h>
#include <ctype.h>

#include "Common.h"
#include "XCore.h"
#include "XNutOS.h"
#include "XAppVer.h"

#include "net\confnet.h"
#include "pro\snmp.h"
#include "pro\snmp_api.h"
#include "mib2.h"

#if defined(NUTNET)

/******************************************************************************
* *
* L O C A L D E F I N E S *
* *
******************************************************************************/

#define MAG_SYS_DESCR       1
#define MAG_SYS_OID           2
#define MAG_SYS_UPTIME       3
#define MAG_SYS_CONTACT       4
#define MAG_SYS_NAME       5
#define MAG_SYS_LOCATION   6
#define MAG_SYS_SERVICES   7

/******************************************************************************
* *
* L O C A L T Y P E D E F S *
* *
******************************************************************************/

/* None */

static u_char *MibVarsSysGet(CONST SNMPVAR *, OID *, size_t *, int, size_t *, WMETHOD **);

static OID base_oid[] = { SNMP_OID_MIB2, 1 };
static size_t base_oidlen = sizeof(base_oid) / sizeof(OID);

static SNMPVAR mib_variables[] = {
{MAG_SYS_DESCR, ASN_OCTET_STR, ACL_RONLY, MibVarsSysGet, 1, {1}},
{MAG_SYS_OID, ASN_OBJECT_ID, ACL_RONLY, MibVarsSysGet, 1, {2}},
{MAG_SYS_UPTIME, ASN_TIMETICKS, ACL_RONLY, MibVarsSysGet, 1, {3}},
{MAG_SYS_CONTACT, ASN_OCTET_STR, ACL_RWRITE, MibVarsSysGet, 1, {4}},
{MAG_SYS_NAME, ASN_OCTET_STR, ACL_RWRITE, MibVarsSysGet, 1, {5}},
{MAG_SYS_LOCATION, ASN_OCTET_STR, ACL_RWRITE, MibVarsSysGet, 1, {6}},
{MAG_SYS_SERVICES, ASN_INTEGER, ACL_RONLY, MibVarsSysGet, 1, {7}},
};

static OID sys_oid[] = {
SNMP_OID_ENTERPRISES,
3444, /* egnite */
2, /* egnite products=1 local=2 experimental=3 */
6, /* egnite Nut/OS */
};

static long sys_services = 72;

static char sys_descr[MAX_SYSSTR_LEN + 1];
static char sys_contact[MAX_SYSSTR_LEN + 1];
static char sys_name[MAX_SYSSTR_LEN + 1];
static char sys_location[MAX_SYSSTR_LEN + 1];
static long sys_uptime;

/*!
* \brief Register MIB II system variables.
*
* \note Preliminary code with hard coded values.
*/
int MibRegisterSysVars(void)
{
char *cp;

sprintf(sys_descr, "%s Version: %s %s", ModelName, VerName, ExtModelName);

strcpy(sys_contact, "");
strcpy(sys_name, ModelName/*confos.hostname*/);
strcpy(sys_location, "");

return SnmpMibRegister(base_oid, base_oidlen, mib_variables, sizeof(mib_variables) / sizeof(SNMPVAR));
}

static int MibVarsSysSet(int action, u_char * var_val, u_char var_val_type, size_t var_val_len, OID * name, size_t name_len)
{
size_t len = SNMP_MAX_LEN;
u_char *value;
u_char *cp;
size_t size;

if (action != SNMP_ACT_COMMIT) {
return 0;
}

if (var_val_type != ASN_OCTET_STR) {
return SNMP_ERR_WRONGTYPE;
}
if (var_val_len > MAX_SYSSTR_LEN) {
return SNMP_ERR_WRONGLENGTH;
}
size = MAX_SYSSTR_LEN;
if ((value = NutHeapAlloc(MAX_SYSSTR_LEN + 1)) == NULL) {
return SNMP_ERR_RESOURCEUNAVAILABLE;
}
AsnOctetStringParse(var_val, &len, &var_val_type, value, &size);
value[size] = 0;
for (cp = value; *cp; cp++) {
if (!isprint(*cp)) {
NutHeapFree(value);
return SNMP_ERR_WRONGVALUE;
}
}
if (action == SNMP_ACT_COMMIT) {
switch (name[7]) {
case 4:
strcpy(sys_contact, (char *) value);
break;
case 5:
strcpy(sys_name, (char *) value);
break;
case 6:
strcpy(sys_location, (char *) value);
break;
}
}
NutHeapFree(value);

return 0;
}

/*!
* \brief Access the specified MIB variable.
*
* \param vp
* \param name Contains the name to look for, either exact or one that
* is in front. On return the exact name is stored here.
* \param namelen Number of sub identifiers in the name upon entry. On
* return the length of the exact name is stored here.
* \param exact If not zero, the name must match exactly. Otherwise we
* want the first name that is following the given one.
* \param varlen Size of the variable.
*/
static u_char *MibVarsSysGet(CONST SNMPVAR * vp, OID * name, size_t * namelen, int exact, size_t * varlen, WMETHOD ** wmethod)
{
int rc;
OID *fullname;
size_t fullnamelen = base_oidlen + vp->var_namelen + 1;

if ((fullname = NutHeapAlloc(fullnamelen * sizeof(OID))) == NULL) {
return NULL;
}
memcpy(fullname, base_oid, base_oidlen * sizeof(OID));
memcpy(fullname + base_oidlen, vp->var_name, vp->var_namelen * sizeof(OID));
*(fullname + fullnamelen - 1) = 0;

rc = SnmpOidCmp(name, *namelen, fullname, fullnamelen);
if ((exact && rc) || (!exact && rc >= 0)) {
NutHeapFree(fullname);
return NULL;
}
memcpy(name, fullname, fullnamelen * sizeof(OID));
*namelen = fullnamelen;
NutHeapFree(fullname);

*wmethod = NULL;
*varlen = sizeof(long);
switch (vp->var_magic) {
case MAG_SYS_DESCR:
*varlen = strlen(sys_descr);
return (u_char *) sys_descr;
case MAG_SYS_OID:
*varlen = sizeof(sys_oid);
return (u_char *) sys_oid;
case MAG_SYS_UPTIME:
sys_uptime = NutGetMillis() / 10;
return (u_char *) & sys_uptime;
case MAG_SYS_CONTACT:
*wmethod = MibVarsSysSet;
*varlen = strlen(sys_contact);
return (u_char *) sys_contact;
case MAG_SYS_NAME:
*wmethod = MibVarsSysSet;
*varlen = strlen(sys_name);
return (u_char *) sys_name;
case MAG_SYS_LOCATION:
*wmethod = MibVarsSysSet;
*varlen = strlen(sys_location);
return (u_char *) sys_location;
case MAG_SYS_SERVICES:
return (u_char *) & sys_services;
}
return NULL;
}

#endif

netrx.c 。。。。。。。。。。。。。。。。。。。。。。。。。。。

/******************************************************************************
* *
* M O D U L E D E F I N E *
* *
******************************************************************************/

#define NETRX_C

/* None */

#include "Common.h"
#include "XCore.h"
#include "XNutOS.h"

#include "netrx.h"

#if defined(NUTNET)

/******************************************************************************
* *
* L O C A L D E F I N E S *
* *
******************************************************************************/

#define NET_RECEIVE_BUF_SIZE 2048

/******************************************************************************
* *
* L O C A L T Y P E D E F S *
* *
******************************************************************************/

/* None */

NETRXBUF *NetRxCreate(void)
{
NETRXBUF *rxbuf;

   /* Allocates a NETRX structure from heap memory */
   if ((rxbuf = NutHeapAlloc(sizeof(NETRXBUF))) != 0) {
       if ((rxbuf->begin = NutHeapAlloc(NET_RECEIVE_BUF_SIZE)) != 0) {
           rxbuf->end = rxbuf->begin + NET_RECEIVE_BUF_SIZE - 1;
           rxbuf->input = rxbuf->begin;
           rxbuf->output = rxbuf->begin;
           rxbuf->length = 0;

rxbuf->next = 0;
rxbuf->sock = 0;

           /* Append the segment to our receive queue. */
           if (NetRxBufList) {
               NETRXBUF *qp = NetRxBufList;
               while (qp->next)
                   qp = qp->next;
               qp->next = rxbuf;
           } else
               NetRxBufList = rxbuf;
       }
       else {
           NutHeapFree(rxbuf);
           rxbuf = 0;
       }
   }
return rxbuf;
}

void NetRxDestroy(NETRXBUF * rxbuf)
{
NETRXBUF *qp = NetRxBufList;
NETRXBUF **qpp = &NetRxBufList;

   /* Remove receive buffer from the list. */
   while (qp) {
       if (qp == rxbuf) {
           *qpp = rxbuf->next;
           /* Free all occupied memory. */
           NutHeapFree(rxbuf->begin);
           NutHeapFree(rxbuf);
           break;
       }
       qpp = &qp->next;
       qp = qp->next;
   }
}

void NetRxDataIn(u_char * data, int len, NETRXBUF * rxbuf)
{
   while (len-- > 0) {
       while (rxbuf->length >= NET_RECEIVE_BUF_SIZE)
           NutSleep(20);
       *rxbuf->input++ = *data++;
       if (rxbuf->input > rxbuf->end)
           rxbuf->input = rxbuf->begin;
       rxbuf->length++;
   }
}

int NetRxDataOut(u_char * data)
{
NETRXBUF *rxbuf = NetRxBufList;

   if (rxbuf) {
       if (rxbuf->length) {
           *data = *rxbuf->output++;
           if (rxbuf->output > rxbuf->end)
               rxbuf->output = rxbuf->begin;
           rxbuf->length--;
           return 1;
       }
       if (rxbuf->sock == 0)
           NetRxDestroy(rxbuf);
   }
   return 0;
}

int NetRxDataLength(void)
{
NETRXBUF *rxbuf = NetRxBufList;

   if (rxbuf) {
       return rxbuf->length;
   }
   return 0;
}

#endif

netrx.h 。。。。。。。。。。。。。。。。。。。。。。。。。。。。

#ifndef NETRX_H

/******************************************************************************
* *
* M O D U L E D E F I N E *
* *
******************************************************************************/

#define NETRX_H

/* None */

#include "net\socket.h"

#ifdef __cplusplus
extern "C" { /* Assume C declarations for C++ */
#endif /* __cplusplus */

/******************************************************************************
* *
* G L O B A L D E F I N E S *
* *
******************************************************************************/

/* None */

/******************************************************************************
* *
* S T R U C T U R E D E F I N I T I O N S *
* *
******************************************************************************/

/*!
* \brief Network receive buffer type.
*/
typedef struct net_rx_buf NETRXBUF;

/*!
* \brief Network receive buffer structure.
*/
struct net_rx_buf {
NETRXBUF *next; /*!< \brief Link to next structure. */
TCPSOCKET *sock; /*!< \brief Online flags. */

   u_char *begin;
   u_char *end;
   u_char *input;
   u_char *output;
   volatile int length;
};

/******************************************************************************
* *
* G L O B A L V A R I A B L E S - N O I N I T I A L I Z E R S *
* *
******************************************************************************/

#ifdef NETRX_C
#define EXTERN
#else
#define EXTERN extern
#endif

EXTERN NETRXBUF *NetRxBufList; /*!< Global linked list of all receive buffers. */

/******************************************************************************
* *
* G L O B A L V A R I A B L E S - I N I T I A L I Z E R S *
* *
******************************************************************************/

/* None */

/******************************************************************************
* *
* F U N C T I O N P R O T O T Y P E S *
* *
******************************************************************************/

NETRXBUF *NetRxCreate(void);
void NetRxDestroy(NETRXBUF *);
void NetRxDataIn(u_char *, int, NETRXBUF *);
int NetRxDataOut(u_char *);
int NetRxDataLength(void);

#undef EXTERN

#ifdef __cplusplus
} /* End of extern "C" { */
#endif /* __cplusplus */

#endif

snmpd.c 。。。。。。。。。。。。。。。。。。。。。。。。。。。。

/******************************************************************************
* *
* M O D U L E D E F I N E *
* *
******************************************************************************/

#define SNMPD_C

#include <stdio.h>

#include "Common.h"
#include "XCore.h"
#include "XNutOS.h"

#include "pro\snmp_config.h"
#include "pro\snmp_mib.h"
#include "pro\snmp_api.h"
#include "pro\snmp_agent.h"
#include "mib2.h"

#if defined(NUTNET)

/******************************************************************************
* *
* L O C A L D E F I N E S *
* *
******************************************************************************/

/* None */

/******************************************************************************
* *
* L O C A L T Y P E D E F S *
* *
******************************************************************************/

/* None */

THREAD(NutSnmp, arg)
{
   UDPSOCKET *sock;
   OID view_all[] = { SNMP_OID_INTERNET };
   int view_idx;

   /* Register system variables. */
   if (MibRegisterSysVars()) {
       NutThreadExit();
   }
   /* Register interface variables. */
   if (MibRegisterIfVars()) {
       NutThreadExit();
   }
   /* Register host variables. */
   if (MibRegisterHrVars()) {
       NutThreadExit();
   }
   /* Register printer variables. */
   if (MibRegisterPrtVars()) {
       NutThreadExit();
   }
   /* Register hp variables. */
   if (MibRegisterHpVars()) {
       NutThreadExit();
   }

   /* Create views. */
   if ((view_idx = SnmpViewCreate("all", view_all, sizeof(view_all), SNMP_VIEW_INCLUDED)) <= 0) {
       NutThreadExit();
   }

   /* Create communities. */
   if (SnmpCommunityCreate("public", view_idx, view_idx) || SnmpCommunityCreate("private", view_idx, view_idx)) {
       NutThreadExit();
   }

   /* Create socket. */
   if (sock = NutUdpCreateSocket(SNMP_PORT)) {
       /* Nut/Net doesn't provide UDP datagram buffering by default. */
       u_short max_ms = SNMP_MAX_MSG_SIZE * 2;
       NutUdpSetSockOpt(sock, SO_RCVBUF, &max_ms, sizeof(max_ms));

/* Run agent. */
SnmpAgent(sock);

       /* Program stopped. */
       NutUdpDestroySocket(sock);
   }

NutThreadExit();
}

void NutRegisterSnmp(void)
{
NutThreadCreate("snmp", NutSnmp, NULL, NUT_THREAD_SNMP_STACK);
}

#endif

sntpc.c 。。。。。。。。。。。。。。。。。。。。。。。。。。。。。

/******************************************************************************
* *
* M O D U L E D E F I N E *
* *
******************************************************************************/

#define SNTPC_C

#include <string.h>
#include <stdio.h>
#include <time.h>

#include "Common.h"
#include "XCore.h"
#include "XNutOS.h"
#include "XLib.h"
#include "XRTC.h"
#include "XVarBank.h"

#include "net\socket.h"
#include "net\in.h"
#include "net\netdb.h"

#if defined(NUTNET)

/******************************************************************************
* *
* L O C A L D E F I N E S *
* *
******************************************************************************/

#define NTP_PORT 123
#define SNTP_PORT NTP_PORT

#define SNTP_1970_SEC 2208988800 /* 1900 - 1970 in seconds */

/******************************************************************************
* *
* L O C A L T Y P E D E F S *
* *
******************************************************************************/

typedef struct _SNTPFRAME SNTPFRAME;
struct _SNTPFRAME {
u_char mode;
u_char stratum;
u_char poll;
u_char precision;
u_long root_delay;
u_long root_dispersion;
u_long reference_identifier;
u_long reference_ts_sec;
u_long reference_ts_frac;
u_long originate_ts_sec;
u_long originate_ts_frac;
u_long receive_ts_sec;
u_long receive_ts_frac;
u_long transmit_ts_sec;
u_long transmit_ts_frac;
};

/* None */

static SNTPFRAME sntpframe;

static u_long NutSntpGetAddress(CONFSNTP * sntp, int index)
{
CONST char *server = sntp->server[index];
u_long address;

   if ((address = inet_addr(server)) != (u_long)-1)
       return address;
   return NutDnsGetHostByName((CONST u_char *)server);
}

static int NutSntpServerNext(CONFSNTP * sntp, int index)
{
CONST char *server;
int find = index;

   do {
       find++;
       if (find >= sizeof(sntp->server) / sizeof(sntp->server[0]))
           find = 0;
       if (NutSntpGetAddress(sntp, find) != 0)
           return find;
   }
   while (find != index);

return (-1);
}

static int NutSntpGetTime(u_long * server_addr, time_t * t)
{
   SNTPFRAME *data = &sntpframe;
   UDPSOCKET *sock;
   u_short bufsize = 256;
   u_short port;
   u_long rec_addr;
   int result = -1;
   int len;

   if (t == NULL)
       return -1;
   if (server_addr == NULL)
       return -1;

   /* allocate new udp socket */
   if ((sock = NutUdpCreateSocket(0)) == 0)
       return -1;

/* Set UDP input buffer to 256 bytes */
NutUdpSetSockOpt(sock, SO_RCVBUF, &bufsize, sizeof(bufsize));

/* clear the SNTP frame */
memset(data, 0, sizeof(SNTPFRAME));

/* LI, VN and Mode bit fields (all in u_char mode); */
data->mode = 0x1B;

/* Send packet to server */
if (NutUdpSendTo(sock, *server_addr, SNTP_PORT, data, sizeof(SNTPFRAME)) == 0) {

for (;;) {
rec_addr = 0;

           /* Receive packet with timeout of 5s */
           len = NutUdpReceiveFrom(sock, &rec_addr, &port, data, sizeof(SNTPFRAME), 5000);
           if (len <= 0)   /* error or timeout occured */
               break;

           /* if source port is SNTP_PORT and server is in sync return */
           if (port == SNTP_PORT && (data->mode & 0xc0) != 0xc0) {
               *t = ntohl(data->transmit_ts_sec) - SNTP_1970_SEC;
               *server_addr = rec_addr;
               result = 0;
               break;
           }

           /* unusable packets will be just ignored */
           if (*server_addr != 0xFFFFFFFF)
               break;
       }
   }

NutUdpDestroySocket(sock);
return result;
}

THREAD(SntpResync, arg)
{
   CONFSNTP *sntp = (CONFSNTP *)arg;
   u_long address;
   int index = (-1);
   int retry = 0;
   int ms;
   time_t t;

NutThreadSetPriority(NUT_THREAD_SNTP_PRIORITY);

   for (;;) {
       while (sntp->sync == 0) {
           NutSleep(5000);
       }

       for (;;) {
           while (index == (-1)) {
               if ((index = NutSntpServerNext(sntp, index)) == (-1))
                   NutSleep(5000);
           }
           if ((address = NutSntpGetAddress(sntp, index)) != 0) {
               break;
           }
           index = NutSntpServerNext(sntp, index);
       }

if (NutSntpGetTime(&address, &t) != 0) {

           /* if numer of retries >= 3 wait 30 secs before next retry sequence ... */
           if (retry++ >= 3) {
               retry = 0;
               NutSleep(30000);

               /* change the next SNTP server */
               index = NutSntpServerNext(sntp, index);
           }
           /* ... else wait 5 secs for next retry */
           else
               NutSleep(5000);
       }

       /* no error */
       else {
           retry = 0;

           /* set the time according to different time zone */
           t = t + sntp->timediffer;
           stime(&t);

           /* wait the interval time */
           while (sntp->interval == 0)
               NutSleep(5000);
           for (ms = 0; ms < 1000; ms++)
               NutSleep(sntp->interval);
       }
   }
}

void NutRegisterSntp(void)
{
_PrintCfg *cfg = GrabPrintConfig();
NutThreadCreate("sntpc", SntpResync, &cfg->confsntp, NUT_THREAD_SNTP_STACK);
}

#endif

utility.c 。。。。。。。。。。。。。。。。。。。。。。。。。。。。。

/******************************************************************************
* *
* M O D U L E D E F I N E *
* *
******************************************************************************/

#define UTILITY_C

#include <stdlib.h>
#include <string.h>

#include "Common.h"
#include "XCore.h"
#include "XNutOS.h"
#include "XAppVer.h"
#include "XPrtEng.h"
#include "XFunction.h"

#include "net\socket.h"
#include "net\in.h"

#if defined(NUTNET)

/******************************************************************************
* *
* L O C A L D E F I N E S *
* *
******************************************************************************/

#define UTIL_PACKET_SIZE 2048

#define UTIL_PORT 22368

#define UTIL_TYPE_REQUEST           0
#define UTIL_TYPE_RELEASE           1
#define UTIL_TYPE_CONFIGURATION       2

#define UTIL_OPCODE_RESET           1
#define UTIL_OPCODE_DISCOVER       2
#define UTIL_OPCODE_INFORM           3
#define UTIL_OPCODE_SETUP           4

#define UTIL_CFG0_CHECKSUM 0x28
#define UTIL_CFG0_HOST_NAME 0xb0

#define UTIL_CFG4_IP_ADDR           0x45
#define UTIL_CFG4_IP_MASK           0x49
#define UTIL_CFG4_GATE_WAY           0x4d
#define UTIL_CFG4_WORKGROUP           0x61

#define UTIL_CFG5_DHCP1               0x3ae
#define UTIL_CFG5_IP_ADDR           0x3b0
#define UTIL_CFG5_DHCP2               0x3b4

/******************************************************************************
* *
* L O C A L T Y P E D E F S *
* *
******************************************************************************/

typedef struct {
   u_short header_len;       /* Fixed value: 32 */
   u_short unknown2;       /* Fixed value: 1 */
   u_short unknown4;       /* Fixed value: 1 */
   u_char unknown6;       /* Fixed value: 8 */
   u_char type;           /* Packet type: 0=request, 1=release, 2=configuration */
   u_short opcode;           /* Packet opcode: 1=reset, 2=discover, 3=inform, 4=setup */
   u_short data_len;       /* Bytes of data */
   u_long xid;           /* Transaction identification */
   u_char sid[6];           /* Set identification */
   u_char mac[6];           /* Hardware address */
   u_short unknown28;       /* Fixed value: 0 */
   u_short err_code;       /* Error code */
} UTILHEADER;

typedef struct {
   UTILHEADER header;
   u_char unknown32[8];
   u_short unknown40;       /* Printer status: 0=idle, 1=printing, 2=pause, 3=error */
   u_short firmware;       /* Firmware version */
   u_long ip_addr;           /* IP address */
   u_long up_time;           /* Up time */
   char model[32];           /* Model name */
   char name[32];           /* Host name */
} DISCOVER;

/* None */

static int saveConfig;

static u_short NutPrinterStatus(void)
{
u_short status = 0;

   if (GetJobMonitor() != MONITOR_IDLE)
       status = 1;
   if (CheckJobLock())
       status = 2;
   if (GetJobErrorState() & ERROR_JOB_ALL_STATE)
       status = 3;

return status;
}

static u_short NutCfgSum(int offset, const void *data, int size)
{
   u_char buf[32];
   u_short sum = 0;
   int i;

   memset(buf, 0, sizeof(buf));
   memcpy(buf + (offset % 2), data, size);
   for (i = 0; i < sizeof(buf) / sizeof(u_short); i += 2)
       sum += *(u_short *)(buf + i);
   return sum;
}

static void NutUtilityReset(void)
{
   sprintf(confos.hostname, "XP-%02X%02X%02X",
       confnet.cdn_mac[3], confnet.cdn_mac[4], confnet.cdn_mac[5]);
   confnet.cdn_ip_addr = 0;
   confnet.cdn_ip_mask = 0;
   confnet.cdn_gateway = 0;
   confnet.cdn_cip_addr = 0;
   saveConfig = 1;
}

static void NutUtilityDiscover(DISCOVER *dis)
{
   /* MAC Address */
   memcpy(dis->header.mac, confnet.cdn_mac, 6);
   /* Printer Status */
   dis->unknown40 = NutPrinterStatus();
   /* Firmware */
   dis->firmware = (atoi(VerName) << 8) | atoi(strchr(VerName, '.') + 1);
   /* IP Address */
   dis->ip_addr = confnet.cdn_ip_addr;
   /* Up Time */
   dis->up_time = NutGetSeconds();
   /* Model */
   strcpy(dis->model, ModelName);
   /* Device Name */
   strncpy(dis->name, confos.hostname, sizeof(confos.hostname));
}

static void NutUtilityInform(char *reply)
{
   static const char *workgroup = "WORKGROUP";
   u_short cfgtyp = *(u_short *)(reply + 0x22) = *(u_short *)(reply + 0x20);
   u_char dhcpflag1, dhcpflag2;
   u_long ipaddr;
   u_short sum;

   dhcpflag1 = 0x08;
   dhcpflag2 = 0x04;
   ipaddr = confnet.cdn_ip_addr;
   if (confnet.cdn_cip_addr)
   {
       dhcpflag1 = dhcpflag2 = 0x01;
       ipaddr = confnet.cdn_cip_addr;
   }

*(u_short *)(reply + 0x24) = 0x0400;

   switch (cfgtyp) {
   case 0:
       sum = 0x55aa;
       sum -= NutCfgSum(UTIL_CFG0_HOST_NAME, confos.hostname, sizeof(confos.hostname));
       sum -= NutCfgSum(UTIL_CFG4_IP_ADDR, &ipaddr, sizeof(u_long));
       sum -= NutCfgSum(UTIL_CFG4_IP_MASK, &confnet.cdn_ip_mask, sizeof(u_long));
       sum -= NutCfgSum(UTIL_CFG4_GATE_WAY, &confnet.cdn_gateway, sizeof(u_long));
       sum -= NutCfgSum(UTIL_CFG4_WORKGROUP, workgroup, strlen(workgroup));
       sum -= NutCfgSum(UTIL_CFG5_DHCP1, &dhcpflag1, sizeof(u_char));
       sum -= NutCfgSum(UTIL_CFG5_IP_ADDR, &ipaddr, sizeof(u_long));
       sum -= NutCfgSum(UTIL_CFG5_DHCP2, &dhcpflag2, sizeof(u_char));
       memcpy(reply + UTIL_CFG0_CHECKSUM, &sum, sizeof(u_short));
       memcpy(reply + UTIL_CFG0_HOST_NAME, confos.hostname, sizeof(confos.hostname));
       break;
   case 1:
       break;
   case 2:
       break;
   case 3:
       break;
   case 4:
       memcpy(reply + UTIL_CFG4_IP_ADDR, &ipaddr, sizeof(u_long));
       memcpy(reply + UTIL_CFG4_IP_MASK, &confnet.cdn_ip_mask, sizeof(u_long));
       memcpy(reply + UTIL_CFG4_GATE_WAY, &confnet.cdn_gateway, sizeof(u_long));
       memcpy(reply + UTIL_CFG4_WORKGROUP, workgroup, strlen(workgroup));
       break;
   case 5:
       memcpy(reply + UTIL_CFG5_DHCP1, &dhcpflag1, sizeof(u_char));
       memcpy(reply + UTIL_CFG5_IP_ADDR, &ipaddr, sizeof(u_long));
       memcpy(reply + UTIL_CFG5_DHCP2, &dhcpflag2, sizeof(u_char));
       break;
   case 6:
       break;
   case 7:
       break;
   }
}

static void NutUtilitySetup(char *data)
{
u_short cfgtyp = *(u_short *)(data + 0x20) = *(u_short *)(data + 0x22);

   switch (cfgtyp) {
   case 0:
       strncpy(confos.hostname, data + UTIL_CFG0_HOST_NAME, sizeof(confos.hostname));
       break;
   case 1:
       break;
   case 2:
       break;
   case 3:
       break;
   case 4:
       memcpy(&confnet.cdn_cip_addr, data + UTIL_CFG4_IP_ADDR, sizeof(u_long));
       memcpy(&confnet.cdn_ip_mask, data + UTIL_CFG4_IP_MASK, sizeof(u_long));
       memcpy(&confnet.cdn_gateway, data + UTIL_CFG4_GATE_WAY, sizeof(u_long));
       break;
   case 5:
       if (*(data + UTIL_CFG5_DHCP1) == 0x08)
           confnet.cdn_cip_addr = 0;
       break;
   case 6:
       break;
   case 7:
       saveConfig = 1;
       break;
   }
}

/*
* \brief Utility datagram handler.
*
* \param data Pointer to the UDP datagram buffer.
* \param len UDP datagram size.
*/
static int NutUtilityHandler(void *data, int len)
{
   static const u_char broadcast[6] = { 0xff,0xff,0xff,0xff,0xff,0xff };
   UTILHEADER *header = data;
   int rc = -1;

   /* Check minimum datagram length. */
   if (len < sizeof(UTILHEADER))
       return rc;

   if (memcmp(header->mac, broadcast, 6) &&
       memcmp(header->mac, confnet.cdn_mac, 6))
       return rc;

switch (htons(header->opcode)){

   case UTIL_OPCODE_RESET:       /* Factory Reset */
       if (header->type == UTIL_TYPE_RELEASE) {
           header->data_len = htons(32);
           rc = 64;
       }
       if (header->type == UTIL_TYPE_CONFIGURATION) {
           header->data_len = htons(0);
           rc = 32;
           NutUtilityReset();
       }
       break;

   case UTIL_OPCODE_DISCOVER:   /* Discover Device */
       if (header->type == UTIL_TYPE_REQUEST) {
           header->data_len = htons(sizeof(DISCOVER) - sizeof(UTILHEADER));
           rc = sizeof(DISCOVER);
           NutUtilityDiscover(data);
       }
       break;

   case UTIL_OPCODE_INFORM:
       if (header->type == UTIL_TYPE_REQUEST) {
           header->data_len = htons(0);
           header->sid[0] = 1;   /* Set it to 1 */
           rc = 32;
       }
       if (header->type == UTIL_TYPE_CONFIGURATION) {
           header->data_len = htons(1032);
           rc = 1064;
           NutUtilityInform(data);
       }
       break;

   case UTIL_OPCODE_SETUP:
       if (header->type == UTIL_TYPE_RELEASE) {
           header->data_len = htons(0);
           rc = 32;
       }
       if (header->type == UTIL_TYPE_CONFIGURATION) {
           header->data_len = htons(2);
           rc = 34;
           NutUtilitySetup(data);
       }
       break;

   case 9:       /* Print Test */
       header->data_len = htons(6);
       rc = 36;
       break;

   case 10:   /* Print Test */
       header->data_len = htons(6);
       rc = 38;
       break;
   }

return rc;
}

THREAD(NutUtil, arg)
{
   UDPSOCKET *sock;
   void *data;
   u_long raddr;
   u_short rport;
   int len;

   /* Insist on allocating a datagram buffer. */
   while ((data = NutHeapAlloc(UTIL_PACKET_SIZE)) == 0) {
       NutSleep(1000);
   }

   /* Insist on creating a socket. */
   while ((sock = NutUdpCreateSocket(UTIL_PORT)) == 0) {
       NutSleep(1000);
   }

saveConfig = 0;

   /* Handle discovery telegrams in an endless loop. */
   for (;;) {
       /* Avoid system blocking by datagram storms. */
       NutSleep(100);

       memset(data, 0, UTIL_PACKET_SIZE);
       len = NutUdpReceiveFrom(sock, &raddr, &rport, data, UTIL_PACKET_SIZE, 0);
       if ((len = NutUtilityHandler(data, len)) > 0) {
           /* Broadcast response if destination is unreachable. */
           if ((raddr & confnet.cdn_ip_mask) != (confnet.cdn_ip_addr & confnet.cdn_ip_mask)) {
               raddr = INADDR_BROADCAST;
           }
           NutUdpSendTo(sock, raddr, rport, data, len);
       }
       if (saveConfig) {
           NutSleep(1000);
           NutSaveConfig();
           NutNetSaveConfig();
           NutSetPrintServerName(confos.hostname);

           /* To restart the printer */
           PrinterReboot();
           saveConfig = 0;
       }
   }
}

/*!
* \brief Register utility datagram responder.
*/
void NutRegisterUtility(void)
{
NutThreadCreate("utility", NutUtil, NULL, NUT_THREAD_UTILITY_STACK);
}

#endif