/* IBM_PROLOG_BEGIN_TAG */
/* This is an automatically generated prolog. */
/* */
/* tcpip720 src/tcpip/usr/include/snmp_dpi.h 1.4 */
/* */
/* Licensed Materials - Property of IBM */
/* */
/* Restricted Materials of IBM */
/* */
/* COPYRIGHT International Business Machines Corp. 1996,2007 */
/* All Rights Reserved */
/* */
/* US Government Users Restricted Rights - Use, duplication or */
/* disclosure restricted by GSA ADP Schedule Contract with IBM Corp. */
/* */
/* IBM_PROLOG_END_TAG */
/* @(#)28 1.4 src/tcpip/usr/include/snmp_dpi.h, snmp, tcpip720 9/5/07 15:39:11 */
/*
\begin{verbatim}
*/
#ifndef snmp_dpiH
#define snmp_dpiH
/*********************************************************************/
/* */
/* SNMP-DPI API - SNMP Distributed Protocol Interface */
/* Application Programming Interface */
/* */
/* Feb 17, 1999 - Version 2.0.31 */
/* */
/* Copyright - (C) International Business Machines Corp. 1994-1999*/
/* */
/* Permission to use, copy, modify, and distribute this software */
/* and its documentation for any lawful purpose and without fee is */
/* hereby granted, provided that this notice be retained unaltered,*/
/* and that the names of IBM and all other contributors shall not */
/* be used in advertising or publicity pertaining to distribution */
/* of the software without specific written prior permission. */
/* No contributor makes any representations about the suitability */
/* of this software for any purpose. It is provided "as is" */
/* without express or implied warranty. */
/* */
/* IBM AND ALL OTHER CONTRIBUTORS DISCLAIM ALL WARRANTIES WITH */
/* REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF */
/* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, TITLE, */
/* AND NON-INFRINGEMENT. */
/* */
/* IN NO EVENT SHALL IBM OR ANY OTHER CONTRIBUTOR BE LIABLE FOR */
/* ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES, WHETHER IN */
/* CONTRACT, TORT, OR OTHER FORM OF ACTION, ARISING OUT OF OR IN */
/* CONNECTION WITH, THE USE OR PERFORMANCE OF THIS SOFTWARE. */
/* */
/* snmp_dpi.h - Base include file for SNMP DPI subagent support */
/* - This file defines the DPI interface for the DPI */
/* subagent programmer. This interface should be the */
/* same on all platforms and in all implementations */
/* */
/*********************************************************************/
/* Change activitity:
*
* $Log:$
*-------------------------------------------------------------------*/
#ifdef DPI_VERY_MINIMAL_SUBAGENT
#ifndef DPI_MINIMAL_SUBAGENT
#define DPI_MINIMAL_SUBAGENT
#endif
#endif /* def DPI_VERY_MINIMAL_SUBAGENT */
#ifdef DPI_MINIMAL_SUBAGENT
#ifndef EXCLUDE_DPI_V1_SUPPORT
#define EXCLUDE_DPI_V1_SUPPORT
#endif
#ifdef INCLUDE_UDP_DOMAIN_FOR_DPI
#undef INCLUDE_UDP_DOMAIN_FOR_DPI
#endif
#ifdef INCLUDE_UNIX_DOMAIN_FOR_DPI
#undef INCLUDE_UNIX_DOMAIN_FOR_DPI
#endif
#ifdef INCLUDE_NMQ_DOMAIN_FOR_DPI
#undef INCLUDE_NMQ_DOMAIN_FOR_DPI
#endif
#ifndef SNMP_DPI_BUFSIZE
#define SNMP_DPI_BUFSIZE 1024 /* maxSize of a DPI packet */
#endif
#endif /* def DPI_MINIMAL_SUBAGENT */
#if defined(OS2) | defined(__OS2__) /* used on OS/2 only */
#pragma pack(4)
#endif /* OS2 */
/*********************************************************************/
/* Some of the compilers we used want a special LINKAGE keyword for */
/* functions so they can do compiler independent linking. So we can */
/* accomodate for that with e LINKAGE definition that is a no-op by */
/* default. Specifically OS/2 needs this. */
/*********************************************************************/
#ifndef LINKAGE
#if defined(OS2) | defined(__OS2__) /* for OS/2 we must define */
#define LINKAGE _System /* _System Linkage because */
#else /* not OS2 */ /* DLLs/LIBs use that, else*/
#define LINKAGE /* don't show to compiler */
#endif /* OS2 */
#endif /* ndef LINKAGE */
/*********************************************************************/
/* Some of the compilers we used seem to have trouble with the const */
/* qualifier (or I do not understand yet all its implications). */
/* Anyways, I have used CONST qualifier where I want to use const. */
/* If you compile with the -DCONST option, then the const qualifier */
/* is used. Otherwise, it is just ignored. */
/*********************************************************************/
#ifdef CONST
#ifndef CONST_ALREADY_DEFINED /* CONST not defined in other h file*/
#undef CONST /* undo and define our way */
#define CONST const /* show it to compiler */
#define CONST_ALREADY_DEFINED /* indicate CONST defined */
#endif
#else
#define CONST /* don't show compiler */
#define CONST_ALREADY_DEFINED /* indicate CONST defined */
#endif
/*********************************************************************/
/* This is the size of the (static) buffer in which DPI packets are */
/* created by the mkDPIxxxx functions. The variable is defined here */
/* so that DPI subagent programmers can inspect it. */
/*********************************************************************/
#ifndef SNMP_DPI_BUFSIZE
#define SNMP_DPI_BUFSIZE 4096 /* max size of a DPI packet */
#endif
/*********************************************************************/
/* These are the codes for the SNMP_DPI packet types. */
/* They come from RFC 1228 plus DPI 2.0 additions as defined in the */
/* RFC 1592 for DPI version 2.0 */
/*********************************************************************/
#define SNMP_DPI_GET 1
#define SNMP_DPI_GETNEXT 2
#define SNMP_DPI_SET 3
#define SNMP_DPI_TRAP 4
#define SNMP_DPI_TRAPV1 4 /* is the same as TRAP */
#define SNMP_DPI_RESPONSE 5
#define SNMP_DPI_REGISTER 6
#define SNMP_DPI_UNREGISTER 7
#define SNMP_DPI_OPEN 8
#define SNMP_DPI_CLOSE 9
#define SNMP_DPI_COMMIT 10
#define SNMP_DPI_UNDO 11
#define SNMP_DPI_GETBULK 12
#define SNMP_DPI_TRAPV2 13 /* reserved, not implemented */
#define SNMP_DPI_INFORM 14 /* reserved, not implemented */
#define SNMP_DPI_ARE_YOU_THERE 15
/*********************************************************************/
/* If a user a DPI subagent programmer wants to use an older level */
/* of the DPI protocol, then he/she can specify that in his source */
/* by these C-preprocessor define statements: */
/* #define SNMP_DPI_VERSION 1 */
/* #define SNMP_DPI_RELEASE 1 ** or 0 is also valid */
/* This may be useful when you want to use existing DPI subagent */
/* code with the DPI 2.0 library and include files. */
/* The default is Version 2 Release 0. */
/*********************************************************************/
#define SNMP_DPI_PROTOCOL 2 /* This is SNMP-DPI protocol */
#ifndef SNMP_DPI_VERSION /* if user did not specify a */
#define SNMP_DPI_VERSION 2 /* version, then default is 2 */
#endif
#ifndef SNMP_DPI_RELEASE /* if user did not specify a */
#define SNMP_DPI_RELEASE 0 /* release, then default is 0 */
#endif
#if (SNMP_DPI_VERSION == 1) /* if caller wants DPI 1.x */
#ifndef DPI_MINIMAL_SUBAGENT
#include "snmp_dp1.h" /* compatibility, include it */
#endif /* ndef DPI_MINIMAL_SUBAGENT */
#else /* no SNMP_DPI_VERSION 1 */ /* else define them for 2.x */
#ifndef DPI_MINIMAL_SUBAGENT
#define mkDPIAreYouThere mkDPIayt
#endif /* ndef DPI_MINIMAL_SUBAGENT */
#define mkDPIregister(a,b,c,d) mkDPIreg((a),(b),(c),(d),0)
#define mkDPIunregister(a,b) mkDPIureg((a),(b))
#define mkDPIresponse(a,b,c,d) mkDPIresp((a),(b),(c),(d))
#define mkDPItrap(a,b,c,d) mkDPItrape((a),(b),(c),(d))
#ifndef DPI_MINIMAL_SUBAGENT
#define mkDPIget(a,b,c) mkDPIget_packet((a),(b),(c))
#define mkDPInext(a,b,c) mkDPInext_packet((a),(b),(c))
#endif /* ndef DPI_MINIMAL_SUBAGENT */
#define mkDPIset(a,b,c,d,e,f) mkDPIset_packet((a),(b),(c),(d),(e),(f))
#define fDPIset(a) fDPIset_packet((a))
#ifndef DPI_MINIMAL_SUBAGENT
#define query_DPI_port(a,b,c) qDPIport((a),(b),(c))
#endif /* ndef DPI_MINIMAL_SUBAGENT */
#define DPI_PACKET_LEN(packet) (((packet) == (void *)0) ? 0 : \
(*((unsigned char *)(packet)) * 256 + \
*(((unsigned char *)(packet))+1)) + 2)
#endif /* (SNMP_DPI_VERSION == 1) */
#ifdef DPI_INCLUDE_SNMP_CONFIG
#include "snmp_config.h"
#endif
/*********************************************************************/
/* SNMP_DPI variable types from RFC1592 for SNMP DPI Version 2.0 */
/* - The 32-bit numeric-type TYPEs have the high order bit set so */
/* you can quickly check for a 4-byte numeric value. */
/* These have their value in the DPI packet in network byte order */
/* (MSB first, LSB last), but they have the value in host byte */
/* order when passed as arguments to functions or when present in */
/* a parse tree. So a DPI sub-agent programmer when using the API */
/* need not be concerned with the byte order in the DPI packet. */
/* - Counter 64 is currently implemented such that the the value is */
/* in 8-byte, network byte order in the DPI packet and that the */
/* value pointed to by the snmp_dpi_set_structure is a ptr to a */
/* snmp_dpi_u64 structure that has 2 unsigned int integers, one */
/* for the high order (Most significant) and one for the low order */
/* (Least significant) 32-bit pieces. The DPI sub-agent programmer */
/* need only be concerned with the snmp_dpi_u64 structure. */
/* - Beware that Textual Conventions are not known on the wire */
/* (in SNMP PDUs), so that is why we do not provide types for them.*/
/* You must use the base type in which the data is represented. */
/* The one exception is a DisplayString. If the agent knows the */
/* textual convention of an object to be DisplayString (from some */
/* form of a compiled MIB), then it passes SNMP_TYPE_DisplayString */
/* The reason for this is that DisplayString is special in the */
/* sense that it often used to determine how to print/display the */
/* data (always printable). */
/* - Values for DisplayString and OBJECT_IDENTIFIERS are represented */
/* as strings in the character set selected at DPI OPEN time. */
/* - In DPI 1.x the IP address was (128|5), and now it is just 5. */
/* In both cases it is an IP address, 4 bytes, network byte order. */
/* The high order bit (128) should not have been used in DPI 1.x */
/* - It is recommended to use these DPI 2.0 names for SNMP_TYPE_xxxx */
/* They are based on the names used in SNMPv2 (RFC1442) */
/* - The BIT_STRING is currently implemented such that you get an */
/* octet string of the form 0xuubbbb....bb where the first octet */
/* uu has a value in the range 0-7 indicating how many unused bits */
/* there are in the last byte bb. The bb bytes represent the bit */
/* string itself, where bit zero (0) comes fist and so on. This is */
/* the case both in the DPI packet and in the snmp_dpi_set_packet */
/* structure. */
/* */
/* Notes/Warnings: */
/* - #defines for UInteger32, NsapAddress and BIT_STRING below are */
/* here just in case someone used them in the past. */
/* However, current master agents do not accept those types. */
/* They are obsolete and only were used in RFC1442 which is now */
/* Historic. You better do not use them in new code. */
/* */
/*********************************************************************/
#define SNMP_TYPE_MASK 0x7f /* mask to isolate type */
#define SNMP_TYPE_Integer32 (128|1) /* 32-bit INTEGER */
#define SNMP_TYPE_OCTET_STRING 2 /* OCTET STRING (ASN.1) */
#define SNMP_TYPE_OBJECT_IDENTIFIER 3 /* OBJECT IDENTIFIER (ASN.1) */
#define SNMP_TYPE_NULL 4 /* NULL (ASN.1) */
#define SNMP_TYPE_IpAddress 5 /* IMPLICIT OCTET STRING (4) */
#define SNMP_TYPE_Counter32 (128|6) /* 32-bit Counter (unsigned) */
#define SNMP_TYPE_Gauge32 (128|7) /* 32-bit Gauge (unsigned) */
#define SNMP_TYPE_Unsigned32 (128|7) /* 32-bit Gauge (unsigned) */
#define SNMP_TYPE_TimeTicks (128|8) /* 32-bit TimeTicks (unsigned)*/
/* in hundreths of a second */
#define SNMP_TYPE_DisplayString 9 /* DisplayString (Textual Con)*/
#ifdef INCLUDE_RFC1442 /* is now Historic */
#define SNMP_TYPE_BIT_STRING 10 /* BIT STRING (ASN.1) */
#define SNMP_TYPE_NsapAddress 11 /* IMPLICIT OCTET STRING */
#define SNMP_TYPE_UInteger32 (128|12)/* 32-bit INTEGER (unsigned) */
#endif /* def INCLUDE_RFC1442 */
#define SNMP_TYPE_Counter64 13 /* 64-bit Counter (unsigned) */
#define SNMP_TYPE_Opaque 14 /* IMPLICIT OCTET STRING */
#define SNMP_TYPE_noSuchObject 15 /* IMPLICIT NULL */
#define SNMP_TYPE_noSuchInstance 16 /* IMPLICIT NULL */
#define SNMP_TYPE_endOfMibView 17 /* IMPLICIT NULL */
/*********************************************************************/
/* These codes should be used in the ret_code field of an SNMP DPI */
/* reponse packet. There are 2 types of error codes: */
/* - Error codes as defined in RFC1448, section 3, page 9. These are */
/* to be used when sending a response to an original SNMP request */
/* (e.g. GET, GETNEXT, SET, COMMIT, UNDO). */
/* - Additional SNMP DPI error codes, to be used for responses to */
/* DPI specific requests (e.g. OPEN, REGISTER, UNREGISTER). */
/*********************************************************************/
#ifndef snmp_baseH
#define SNMP_ERROR_noError 0
#define SNMP_ERROR_tooBig 1
#define SNMP_ERROR_noSuchName 2
#define SNMP_ERROR_badValue 3
#define SNMP_ERROR_readOnly 4
#define SNMP_ERROR_genErr 5
#define SNMP_ERROR_noAccess 6
#define SNMP_ERROR_wrongType 7
#define SNMP_ERROR_wrongLength 8
#define SNMP_ERROR_wrongEncoding 9
#define SNMP_ERROR_wrongValue 10
#define SNMP_ERROR_noCreation 11
#define SNMP_ERROR_inconsistentValue 12
#define SNMP_ERROR_resourceUnavailable 13
#define SNMP_ERROR_commitFailed 14
#define SNMP_ERROR_undoFailed 15
#define SNMP_ERROR_authorizationError 16
#define SNMP_ERROR_notWritable 17
#define SNMP_ERROR_inconsistentName 18
#endif /* ndef snmp_baseH */
#define SNMP_ERROR_DPI_noError 0
#define SNMP_ERROR_DPI_otherError 101
#define SNMP_ERROR_DPI_notFound 102
#define SNMP_ERROR_DPI_alreadyRegistered 103
#define SNMP_ERROR_DPI_higherPriorityRegistered 104
#define SNMP_ERROR_DPI_mustOpenFirst 105
#define SNMP_ERROR_DPI_notAuthorized 106
#define SNMP_ERROR_DPI_viewSelectionNotSupported 107
#define SNMP_ERROR_DPI_getBulkSelectionNotSupported 108
#define SNMP_ERROR_DPI_duplicateSubAgentIdentifier 109
#define SNMP_ERROR_DPI_invalidDisplayString 110
#define SNMP_ERROR_DPI_characterSetSelectionNotSupported 111
/*********************************************************************/
/* SNMP DPI UNREGISTER reason codes */
/*********************************************************************/
#define SNMP_UNREGISTER_otherReason 1
#define SNMP_UNREGISTER_goingDown 2
#define SNMP_UNREGISTER_justUnregister 3
#define SNMP_UNREGISTER_newRegistration 4
#define SNMP_UNREGISTER_higherPriorityRegistered 5
#define SNMP_UNREGISTER_byManager 6
#define SNMP_UNREGISTER_timeout 7
/*********************************************************************/
/* SNMP DPI CLOSE reason codes */
/*********************************************************************/
#define SNMP_CLOSE_otherReason 1
#define SNMP_CLOSE_goingDown 2
#define SNMP_CLOSE_unsupportedVersion 3
#define SNMP_CLOSE_protocolError 4
#define SNMP_CLOSE_authenticationFailure 5
#define SNMP_CLOSE_byManager 6
#define SNMP_CLOSE_timeout 7
#define SNMP_CLOSE_openError 8
/*********************************************************************/
/* These are structures for a (partial) parse tree for DPI packets. */
/*********************************************************************/
struct dpi_reg_packet {
unsigned short timeout; /* in seconds; 16-bit u_int */
int priority; /* priority for this subagent */
char *group_p; /* ptr to group OIDstring */
struct dpi_reg_packet *next_p; /* ptr to next in chain */
char view; /* for BNR DPI version 1.2 */
char bulk;
};
struct dpi_ureg_packet {
char reason_code; /* unregister reason code */
char *group_p; /* ptr to group OIDstring */
struct dpi_ureg_packet *next_p; /* ptr to next in chain */
};
struct dpi_get_packet {
char *object_p; /* ptr to OIDstring (DPI 1.x) */
char *group_p; /* ptr to group OIDstring */
char *instance_p; /* ptr to group OIDstring */
struct dpi_get_packet *next_p; /* ptr to next in chain */
};
struct dpi_next_packet {
char *object_p; /* ptr to OIDstring (DPI 1.x) */
char *group_p; /* ptr to group OIDstring */
char *instance_p; /* ptr to group OIDstring */
struct dpi_next_packet *next_p; /* ptr to next in chain */
};
struct dpi_bulk_packet {
int non_repeaters; /* number of non-repeaters */
int max_repetitions;/* max repeaters */
struct dpi_next_packet *varBind_p; /* ptr to varBinds: chain */
/* of dpi_next_packets */
};
struct snmp_dpi_u64 { /* for unsigned 64-bit int */
unsigned int high; /* - high order 32 bits */
unsigned int low; /* - low order 32 bits */
}; /* for unsigned 64-bit int */
typedef struct snmp_dpi_u64 snmp_dpi_u64;
struct dpi_set_packet {
char *object_p; /* ptr to OIDstring (DPI 1.x) */
char *group_p; /* ptr to group OIDstring */
char *instance_p; /* ptr to group OIDstring */
unsigned char value_type; /* value type; SNMP_TYPE_xxxx */
unsigned short value_len; /* value length */
char *value_p; /* ptr to the value itself */
struct dpi_set_packet *next_p; /* ptr to next in chain */
};
struct dpi_resp_packet {
char error_code; /* error code: SNMP_ERROR_xxx */
unsigned int error_index;/* index 1st varBind in error */
#define resp_priority error_index /* for response to register */
struct dpi_set_packet *varBind_p; /* ptr to varBinds: chain of */
}; /* dpi_set_packets */
struct dpi_trap_packet {
int generic; /* long must be 4 bytes long */
int specific;
struct dpi_set_packet *varBind_p; /* ptr to varBinds: chain of */
/* SET structures */
char *enterprise_p; /* ptr to enterprise ID */
};
struct dpi_open_packet {
char *oid_p; /* subagent ID, an OIDstring */
char *description_p; /* subagent descriptive name */
unsigned short timeout; /* in seconds, 16-bit u_int */
unsigned short max_varBinds; /* max varBinds I can handle */
char character_set; /* character set selection */
unsigned short password_len; /* length of password */
unsigned char *password_p; /* ptr to password itself */
};
struct dpi_close_packet {
char reason_code; /* reason for closing */
};
typedef struct snmp_dpi_hdr snmp_dpi_hdr;
typedef struct dpi_open_packet snmp_dpi_open_packet;
typedef struct dpi_close_packet snmp_dpi_close_packet;
typedef struct dpi_reg_packet snmp_dpi_reg_packet;
typedef struct dpi_ureg_packet snmp_dpi_ureg_packet;
typedef struct dpi_get_packet snmp_dpi_get_packet;
typedef struct dpi_next_packet snmp_dpi_next_packet;
typedef struct dpi_bulk_packet snmp_dpi_bulk_packet;
typedef struct dpi_set_packet snmp_dpi_set_packet;
typedef struct dpi_resp_packet snmp_dpi_resp_packet;
typedef struct dpi_trap_packet snmp_dpi_trap_packet;
#define snmp_dpi_hdr_NULL_p ((snmp_dpi_hdr *)0)
#define snmp_dpi_open_packet_NULL_p ((snmp_dpi_open_packet *)0)
#define snmp_dpi_close_packet_NULL_p ((snmp_dpi_close_packet *)0)
#define snmp_dpi_get_packet_NULL_p ((snmp_dpi_get_packet *)0)
#define snmp_dpi_next_packet_NULL_p ((snmp_dpi_next_packet *)0)
#define snmp_dpi_bulk_packet_NULL_p ((snmp_dpi_bulk_packet *)0)
#define snmp_dpi_set_packet_NULL_p ((snmp_dpi_set_packet *)0)
#define snmp_dpi_resp_packet_NULL_p ((snmp_dpi_resp_packet *)0)
#define snmp_dpi_trap_packet_NULL_p ((snmp_dpi_trap_packet *)0)
#define snmp_dpi_reg_packet_NULL_p ((snmp_dpi_reg_packet *)0)
#define snmp_dpi_ureg_packet_NULL_p ((snmp_dpi_ureg_packet *)0)
struct snmp_dpi_hdr {
unsigned char proto_major;
unsigned char proto_version;
#define proto_minor proto_version /* for DPI 1.x */
unsigned char proto_release;
unsigned short packet_id; /* 2 bytes; 16-bit int */
unsigned char packet_type;
union {
snmp_dpi_reg_packet *reg_p;
snmp_dpi_ureg_packet *ureg_p;
snmp_dpi_get_packet *get_p;
snmp_dpi_next_packet *next_p;
snmp_dpi_next_packet *bulk_p;
snmp_dpi_set_packet *set_p;
snmp_dpi_resp_packet *resp_p;
snmp_dpi_trap_packet *trap_p;
snmp_dpi_open_packet *open_p;
snmp_dpi_close_packet *close_p;
unsigned char *any_p;
} data_u;
unsigned short community_len; /* BNR DPI version 1.2 */
unsigned char *community_p; /* compatibility fields */
};
#if defined(__cplusplus) /* C++ compiler */
#ifndef DPI_NO_EXTERN_C
extern "C" { /* sees them as extern C */
#endif
#endif /* __cplusplus */
/*********************************************************************/
/* Following functions are common functions for DPI programmers: */
/* - DPIdebug can be used to turn all internal DPI tracing/debugging */
/* on or off. If turned on, the functions within the DPI library */
/* report what happens via messages to stdout and/or stderr. */
/* - pDPIpacket can be used to create a parse tree from a DPI packet */
/* received on the "wire" or "connection". */
/* - fDPIparse can be used to free the complete parse tree when it */
/* is no longer needed. It will free all allocated memory. */
/* - fDPIset (defined as a macro above so that it translates into a */
/* fDPIset_packet) can be used to free a complete SET parse tree */
/* This was found to be needed/handy when preparing a SET tree for */
/* a reponse or trap and then running into an error so that the */
/* tree is no longer needed, while there is no snmp_dpi_hdr (yet). */
/*********************************************************************/
#if !defined(DPI_VERY_MINIMAL_SUBAGENT) && \
!defined(SNMP_VERY_MINIMAL_AGENT)
void LINKAGE DPIdebug( /* Set all DPI internal debug */
int level); /* zero=off; otherwise=on at */
/* specified level */
char * LINKAGE DPIget_ptr_to_version(void);
#endif /* !defined(DPI_VERY_MINIMAL_SUBAGENT) */
snmp_dpi_hdr * LINKAGE pDPIpacket( /* parse a DPI packet */
unsigned char *packet_p); /* ptr to the DPI packet */
void LINKAGE fDPIparse( /* free a DPI parse tree */
snmp_dpi_hdr *hdr_p); /* ptr to parse tree */
void LINKAGE fDPIset_packet( /* free a DPI SET parse tree */
snmp_dpi_set_packet *packet_p); /* ptr to SET packet (varBind)*/
/*********************************************************************/
/* Following functions create a serialized SNMP DPI packet in a */
/* static buffer. There is only ONE such buffer, shared by all */
/* packet types. So access to the buffer must be serialized. */
/* - If success, a ptr to that buffer is returned. */
/* - if failure, a NULL ptr is returned. */
/* */
/* Note(s): */
/* - If success, then the first 2 bytes (network byte order) of the */
/* packet contain the length of remaining packet. Beware that the */
/* complete packet (including the length bytes) must be sent over */
/* to the other side of a DPI "connection". To calculate the total */
/* length, you can use the DPI_PACKET_LEN macro defined above. */
/* - The complete or partial parse tree that is passed to the PACKET,*/
/* RESP and TRAPe functions is ALWAYS freed by those functions. */
/* So upon return from these funcions (successful or unsuccessful) */
/* one should not reference the parse tree anymore. */
/*********************************************************************/
unsigned char * LINKAGE mkDPIpacket( /* Make a DPI packet */
snmp_dpi_hdr *hdr_p); /* ptr to a parse tree */
unsigned char * LINKAGE mkDPIopen( /* Make a DPI open packet */
char *oid_p, /* subagent Identifier (OID) */
char *description_p, /* subagent descriptive name */
unsigned int timeout, /* requested default timeout */
unsigned int max_varBinds, /* max varBinds per DPI packet*/
char character_set, /* selected character set */
#define DPI_MIN_CSET 0 /* minimum value possible */
#define DPI_NATIVE_CSET 0 /* 0 = native character set */
#define DPI_ASCII_CSET 1 /* 1 = ASCII character set */
#define DPI_MAX_CSET 1 /* maximum value possible */
unsigned int password_len, /* length of pasword (if any) */
unsigned char *password_p); /* ptr to password (if any) */
unsigned char * LINKAGE mkDPIclose( /* Make a DPI close packet */
char reason_code); /* reason for closing */
unsigned char * LINKAGE mkDPIreg( /* Make a DPI register packet */
unsigned short timeout, /* in seconds (16-bit) */
int priority, /* requested priority */
char *group_p, /* ptr to group ID (subtree) */
char bulk_select, /* Bulk selection (GETBULK) */
#define DPI_BULK_NO 0 /* map GETBULK into GETNEXTs */
#define DPI_BULK_YES 1 /* pass GETBULK to sub-agent */
char view_select); /* View selection yes(1)/no(0)*/
#define DPI_VIEW_NO 0 /* (for BNR DPI version 1.2 */
#define DPI_VIEW_YES 1 /* compatibility only) */
unsigned char * LINKAGE mkDPIureg( /* Make DPI unregister packet */
char reason_code, /* subagent specific code */
char *group_p); /* ptr to group ID (subtree) */
unsigned char * LINKAGE mkDPIbulk( /* Make a DPI response packet */
int non_repeaters, /* non repeaters */
int max_repetitions,/* maximum repetitions */
snmp_dpi_next_packet *packet_p); /* ptr to chain of NEXT packts*/
/* containing the varBinds */
#ifndef DPI_MINIMAL_SUBAGENT
unsigned char * LINKAGE mkDPIayt(void);/* Make DPI AreYouThere packet*/
#endif /* ndef DPI_MINIMAL_SUBAGENT */
unsigned char * LINKAGE mkDPIresp( /* Make a DPI response packet */
snmp_dpi_hdr *hdr_p, /* ptr to packet to respond to*/
int ret_code, /* error code: SNMP_ERROR_xxx */
int ret_index, /* index to varBind in error */
snmp_dpi_set_packet *packet_p); /* ptr to chain of SET packets*/
/* containing the varBinds */
unsigned char * LINKAGE mkDPItrape( /* Make a DPI trap packet */
int generic, /* generic trap type (32 bit)*/
int specific, /* specific trap type (32 bit)*/
snmp_dpi_set_packet *packet_p, /* ptr to chain of SET packets*/
/* containing the varBinds */
char *enterprise_p); /* ptr to enterprise OID */
/*********************************************************************/
/* Following functions will create a complete or partial parse tree. */
/* - If success, a ptr to the (complete or partial) parse tree is */
/* returned. */
/* - If failure, a NULL ptr is returned. */
/* */
/* Note(s): */
/* - All the callers other arguments are copied to newly and */
/* and dynamically allocated memory, so callers ptrs are always */
/* valid upon return (successful or unsuccessful). */
/* - All required memory is dynamically allocated. */
/* - The REG, UREG, GET, NEXT, SET, parse trees are formed by a */
/* chain of packet structures. For these functions: */
/* - When you pass a ptr to an existing chain of structures */
/* (partial parse tree), then a new structure will be added at */
/* the end of the chain. */
/* Upon success, the returned ptr will be the ptr to the first */
/* entry in the chain (e.g. the one you passed). */
/* Upon failure, you always get a NULL ptr returned, so you must */
/* ensure that you remember the ptr to the first entry. */
/* - When you pass a NULL ptr to indicate that this is the first */
/* structure you want to allocate, then a ptr to the new (and */
/* thus first entry) structure will be returned (if success). */
/* - All the callers other arguments are copied to newly and */
/* and dynamically allocated memory, so callers ptrs are always */
/* valid upon return (successful or unsuccessful). */
/* - The mkDPIhdrv() and mkDPInext_packet() are meant for use by an */
/* agent and are most probably not needed by a subagent. */
/*********************************************************************/
/* This macro for mkDPIhdr(a) provides the published mkDPIhdr() */
/* function that normally should be used by subagents: */
/* snmp_dpi_hdr *mkDPIhdr(int dpi_packet_type) */
/*********************************************************************/
#define mkDPIhdr(a) mkDPIhdr_version((a),SNMP_DPI_VERSION, \
SNMP_DPI_RELEASE)
snmp_dpi_hdr * LINKAGE mkDPIhdr_version(/* Make DPIhdr for parse tree*/
int type, /* packet type; SNMP_DPI_xxxx */
char version, /* for this specific version */
char release); /* for this specific release */
snmp_dpi_reg_packet * LINKAGE mkDPIreg_packet(/* Make DPIreg_packet */
snmp_dpi_reg_packet *packet_p, /* ptr to REGISTER structure */
unsigned short timeout, /* in seconds (16-bit) */
int priority, /* requested priority */
char *group_p, /* ptr to group ID (subtree) */
char bulk_select, /* Bulk selection yes(1)/no(0)*/
char view_select); /* View selection yes(1)/no(0)*/
/* (for BNR DPI version 1.2 */
/* compatibility only) */
snmp_dpi_ureg_packet * LINKAGE mkDPIureg_packet(/* Make DPIureg packt*/
snmp_dpi_ureg_packet *packet_p, /* ptr to UNREGISTER structure*/
char reason_code, /* subagent specific code */
char *group_p); /* ptr to group ID (subtree) */
#ifndef DPI_MINIMAL_SUBAGENT
snmp_dpi_get_packet * LINKAGE mkDPIget_packet(/* Make DPIget packet */
snmp_dpi_get_packet *packet_p, /* ptr to GET structure */
char *group_p, /* ptr to group ID (subtree) */
char *instance_p); /* ptr to instance OID string */
#endif /* ndef DPI_MINIMAL_SUBAGENT */
#ifndef DPI_MINIMAL_SUBAGENT
snmp_dpi_next_packet * LINKAGE mkDPInext_packet(/* Make DPInext packt*/
snmp_dpi_next_packet *packet_p, /* ptr to NEXT structure */
char *group_p, /* ptr to group ID (subtree) */
char *instance_p); /* ptr to instance OID string */
#endif /* ndef DPI_MINIMAL_SUBAGENT */
snmp_dpi_set_packet * LINKAGE mkDPIset_packet(/* Make DPIset packet */
snmp_dpi_set_packet *packet_p, /* ptr to SET structure */
char *group_p, /* ptr to group ID (subtree) */
char *instance_p, /* ptr to instance OID string */
int value_type, /* value type (SNMP_TYPE_xxx) */
int value_len, /* length of value */
void *value_p); /* ptr to value */
/*********************************************************************/
/* The following functions are defined as part of the DPI interface */
/* for DPI subagents. They are system specific functions though, so */
/* they may or may not be available in the exact same form on all */
/* platforms or in all vendor provided DPI implementations. Check */
/* you platform/vendor documentation for exact specification. */
/*********************************************************************/
/* Prototypes for SNMP-DPI communication (to/from agent) related */
/* functions. They invoke system dependent code that knows how to */
/* actually make/close the connections and how to send/receive data */
/* over these connections. */
/* - The connect functions: */
/* - If success, return a positive handle that uniquely identifies */
/* the connection. To be passed when calling send/await function.*/
/* - If failure, return a negative error code (DPI_RC_xxxx) */
/* - The send/await/disconnect functions need the handle that */
/* identifies the connection. */
/* - The send/await functions: */
/* - If success, return a zero (DPI_RC_OK) */
/* - If failure, return a negative error code (DPI_RC_xxxx) */
/* - The qDPIport/lookup_host functions are for DPI 1.x compatibility*/
/* and for those who want to do communications themselves instead */
/* of using DPIxxxx functions to connect/send/wait etc. */
/*********************************************************************/
#define dpiPortForTCP 1 /* for use with qDPIport() */
#define dpiPortForUDP 2 /* porttype argument */
#define dpiPathForUnixSocket 3 /* .... */
#define DPIconnect DPIconnectTCP /* default is TCP port */
#define DPI_RC_OK 0 /* all OK, no error */
#define DPI_RC_NOK -1 /* some other error */
#define DPI_RC_NO_PORT -2 /* cannot figure out DPI port */
#define DPI_RC_NO_CONNECTION -3 /* no connection to DPI agent */
#define DPI_RC_EOF -4 /* EOF received on connection */
#define DPI_RC_IO_ERROR -5 /* Some I/O error on connect. */
#define DPI_RC_INVALID_HANDLE -6 /* unknown/invalid handle */
#define DPI_RC_TIMEOUT -7 /* timeout occured */
#define DPI_RC_PACKET_TOO_LARGE -8 /* packed too large, dropped */
#define DPI_RC_UNSUPPORTED_DOMAIN -9 /* unsupported transportDomain*/
#define DPI_RC_INVALID_ARGUMENT -10 /* invalid argument detected */
int LINKAGE DPIconnect_to_agent_TCP( /* Connect to DPI TCP port */
char *hostname_p, /* target hostname/IPaddress */
char *community_p); /* communityname */
#ifndef DPI_MINIMAL_SUBAGENT
int LINKAGE DPIconnect_to_agent_UDP( /* Connect to DPI UDP port */
char *hostname_p, /* target hostname/IPaddress */
char *community_p); /* communityname */
int LINKAGE DPIconnect_to_agent_UNIXstream( /* Connect to DPI via */
/* a UNIX stream */
char *hostname_p, /* target hostname/IPaddress */
char *community_p); /* communityname */
int LINKAGE DPIconnect_to_agent_NMQ( /* Connect to DPI Named Queue */
char *t_qname_p, /* target (agent) queue name */
char *s_qname_p); /* source (subagent) q name */
int LINKAGE DPIconnect_to_agent_SHM( /* Connect to DPI Shared Mem */
int queue_id); /* target (agent) queue id */
#endif /* ndef DPI_MINIMAL_SUBAGENT */
int LINKAGE DPIget_fd_for_handle( /* get the filedescriptor for */
int handle); /* this handle */
void LINKAGE DPIdisconnect_from_agent( /* disconnect from DPI (agent)*/
int handle); /* close this connection */
int LINKAGE DPIawait_packet_from_agent( /* await a DPI packet */
int handle, /* on this connection */
int timeout, /* timeout in seconds. */
unsigned char **message_p, /* receives ptr to data */
unsigned int *length); /* receives length of data */
int LINKAGE DPIsend_packet_to_agent( /* send a DPI packet */
int handle, /* on this connection */
CONST unsigned char *message_p, /* the packet to send */
unsigned int length); /* length of packet */
#ifndef DPI_MINIMAL_SUBAGENT
int LINKAGE qDPIport( /* Query (GET) SNMP_DPI port */
char *hostname_p, /* target hostname/IPaddress */
char *community_p, /* communityname for GET */
int porttype); /* port instance, one of: */
/* dpiPortForTCP */
/* dpiPortForUDP */
#endif /* ndef DPI_MINIMAL_SUBAGENT */
#ifndef SNMP_VERY_MINIMAL_AGENT
unsigned int LINKAGE lookup_host( /* find IPaddress in network */
char *hostname_p); /* byte order for this host */
struct sockaddr_in6 *lookup_host6( /* IPv6-only equivalent */
char *hostname_p); /* @Q1A*/
#endif /* ndef SNMP_MINIMAL_AGENT */
#if defined(__cplusplus) /* close up the C++ scope */
#ifndef DPI_NO_EXTERN_C
}
#endif
#endif /* __cplusplus) */
#if defined(OS2) | defined(__OS2__) /* used on OS/2 only */
#pragma pack()
#endif /* OS2 */
#endif /* snmp_dpiH */
/*
\end{verbatim}
*/