SNMP++2.8中文文档

目前有许多可以创建网络管理应用的SNMP的API。大多数API都提供了一个很大的函数库，调用这些函数的程序员需要熟悉SNMP内部的工作原理和它的资源管理机制。这些API大多都是平台相关的，导致了SNMP的代码也成了操作系统相关的或者网络系统平台有关的，难以移植。另一方面由于C++有丰富的、可复用的标准类库，用C++开发应用成了目前的主流，然而C++标准类库所缺少的正是一套封装好的处理网络管理的类。如果基于面向对象的方法来进行SNMP网络编程，可以提供以下诸多好处：易用、安全、可移植、能扩展。因此SNMP++灵活有效的解决了其他类似API执行和管理起来都很痛苦的问题。

1.1. 什么是SNMP++

SNMP++是一套C++类的集合，它为网络管理应用的开发者提供了SNMP服务。SNMP++并非是现有的SNMP引擎的扩充或者封装。事实上为了效率和方便移植，它只用到了现有的SNMP库里面极少的一部分。SNMP++也不是要取代其他已有的SNMP API，比如WinSNMP。SNMP++只是通过提供强大灵活的功能，降低管理和执行的复杂性，把面向对象的优点带到了网络编程中。

1.2. SNMP++的本质

1.2.1. 简单易用的SNMP++

面向对象的SNMP编程应该是简单易用的。毕竟，SNMP原意就是“简单网络管理协议”，SNMP++只是将简单还给SNMP！应用的开发者不需要关心SNMP的底层实现机制，因为面向对象的方法已经将SNMP内部机制封装、并隐藏好了。SNMP++的简单易用表现在以下方面：

1.2.1.1. 为SNMP提供了简单易用的接口

使用SNMP++不需要精通SNMP，甚至不需要精通C++！因为SNMP++里面几乎没有C的指针，所以可以简单的通过API直接使用。

1.2.1.2. 可以方便的迁移至SNMPv2

SNMP++的主要目标之一就是开发一套API，使得迁移至SNMPv2的过程中尽可能少地影响现有代码。SnmpTarget class使之成为了可能。

1.2.1.3. 保留了对SNMP灵活的底层开发

这是为了方便那些不希望使用面向对象方法，而直接编写SNMP的底层机制的用户。虽然SNMP++快速而方便，但是有些时候程序员也许希望直接使用底层的SNMP API。

1.2.1.4. 鼓励程序员用功能强大的C++，不要因学得不够快而去指责它

使用SNMP++的用户不需要精通C++。基本的SNMP的知识是必要的，但是实际上也需要对C++初步的理解。

1.2.2. 编程安全的SNMP++

大多数SNMP API需要程序员去管理大量的资源。不恰当的装载或卸载这些资源，会导致内存崩溃或泄漏。SNMP++提供的安全机制，可以实现对这些资源的自动管理。SNMP++的用户可以体验到自动管理资源与对话所带来的好处。SNMP++在编程上的安全突出表现在下面的领域：

1.2.2.1. 为SNMP资源提供安全的管理

这包括对SNMP的结构、会话以及传输层的管理。SNMP class被设计成所谓的抽象数据类型（ADT），隐藏了私有数据，而通过提供公有的成员函数来访问或修改这些隐藏了的实例变量。

1.2.2.2. 提供查错、自动超时重发的机制

SNMP++的用户不需要关心如何为不可靠的网络传输机制提供可靠性。可能出现的通信错误包括：数据包丢失、数据包重复以及反复提取数据包。SNMP++消除了所有这些问题出现的可能性，为用户提供了传输层的可靠性。

1.2.3. 可移植的SNMP++

SNMP++的主要目的之一就是提供一套可移植的API，进而穿越各种操作系统（Os）、网络系统（NOS）以及网络管理平台。由于SNMP++隐藏了内部机制，所以从各个平台的角度来看SNMP++的公用接口都是一样的。使用SNMP++的程序员不需要为平台迁移去修改代码。另一个移植方面的问题是在多种协议上运行的能力。目前，SNMP++能运行在IP协议和IPX协议上，或者两者都可以。

1.2.4. 可扩充的SNMP++

扩充不应该只是多一种选择，而是更深层次的。SNMP++不仅是可扩充，而且是很容易扩充。SNMP++的扩充囊括了对下列领域的支持：新的操作系统、网络系统、网络管理平台、网络协议、SNMPv2及其新特性。通过派生C++的类，SNMP++的用户可以根据自己的喜好继承、重载。

1.2.4.1. 重载SNMP++的基础类

应用的开发者可以通过派生出SNNP++的子类来提供所需的操作和属性，这正是面向对象的核心主题。SNMP++的基础类被打造成通用的、没有包含任何具体的数据结构和操作。通过C++派生类以及重新定义虚函数，可以很容易的添加新属性。

2. 一个介绍性的例子

在开始介绍SNMP++的各种特性之前，这里先举个简单的例子来展现它的强大和简单。该例子是从指定的代理端上获取SNMP MIB的系统描述符（System Descriptor object）。包含了创建一个SNMP++会话、获取系统描述符，并打印显示出来的所需的所有代码。其中重发和超时机制已经被SNMP++自动管理了。以下属于SNMP++的代码，采用粗体显示。

2.1. 一个简单的SNMP++例子

#include “snmp_pp.h”

#define SYSDESCR “1.3.6.1.2.1.1.1.0” // Object ID for System Descriptor

void get_system_descriptor()

{

int status; // return status

CTarget ctarget( (IpAddress) “10.4.8.5”); // SNMP++ community target

Vb vb( SYSDESCR); // SNMP++ Variable Binding Object

Pdu pdu; // SNMP++ PDU

//-------[ Construct a SNMP++ SNMP Object ]---------------------------------------

Snmp snmp( status); // Create a SNMP++ session

if ( status != SNMP_CLASS_SUCCESS) { // check creation status

cout << snmp.error_msg( status); // if fail, print error string

return; }

//-------[ Invoke a SNMP++ Get ]-------------------------------------------------------

pdu += vb; // add the variable binding to the PDU

if ( (status = snmp.get( pdu, ctarget)) != SNMP_CLASS_SUCCESS)

cout << snmp.error_msg( status);

else {

pdu.get_vb( vb,0); // extract the variable binding from PDU

cout << “System Descriptor = ”<< vb.get_printable_value(); } // print out the value

}; // Thats all!

2.2. 对介绍性例子的分析

真正属于SNMP++的语句就10行代码。首先用代理端的IP地址建立一个CTarget对象；然后用MIB对象所定位的系统描述符创建一个变量绑定（Vb）；接着就把这个Vb纳入一个Pdu对象；最后生成一个Snmp对象来执行SNMP的get操作。一旦找到了所需的数据，对应的应答消息就被打印出来。另外，所有的处理错误代码也都包含在内了。

3. SNMP++特性

3.1. 完整的一套SNMP C++类

SNMP++是以一套C++类作为基石的。这些类是：对象描述符（Oid）类、变量绑定（Vb）类、协议数据单元（Pdu）类、Snmp类。并且，其他各种用抽象语法表示（ASN.1）来描述的管理信息结构（SMI），也被抽象成了简单的、面向对象的类型。

3.2. SNMP内存的自动管理

当SNMP++的对象被实例化或销毁的时候, 其相关的类可以自动管理着各种各样的SNMP结构和资源。这就使得应用的开发者不用再担心数据结构和资源的卸载，不然就得为防止内存的崩溃或者泄漏提供有效的保护措施。SNMP++的对象的实例化可以是静态的，也可以是动态的。静态的实例化可以在对象脱离它的作用域时卸载掉；动态分配则需要使用C++的new和delete。在SNMP++内部，有许多被隐藏和保护在公用接口后面的SMI结构。所有的SMI结构都是在内部管理的，程序员不需要定义或管理SMI的结构和它的值。因为在SNMP++内绝大部分地方是不存在C的指针的。

3.3. 简单易用的

由于隐藏并管理了所有SMI结构和它们的值，SNMP++的类使用起来即简单又安全。外部程序员无法破坏到隐藏和保护在作用域后面的东东。

3.4. 强大灵活的

SNMP++提供了强大灵活的功能，降低了管理和执行的复杂性。每个SNMP++对象都通过建立一个会话来和一个代理端联系。即由一个SNMP++的对话类的实例，就能处理所有与特定代理端的连接。另外自动重发和超时控制的机制，为每个SNMP++对象都带来了可靠性。一个应用可能会包含许多SNMP++的对象的实例，每个实例都可能与相同或不同的代理端通话。有了这个功能强大的特性，网络管理程序就可以为每个管理单元建立起不同的会话。另一方面，就算单一的SNMP会话也可以解决问题。例如：一个应用可以通过一个SNMP++对象来处理图形统计，另一个SNMP++对象监控trap，也许还有第三个SNMP++对象用以浏览SNMP。SNMP++自动并行处理了同一时刻来自不同SNMP++实例的请求。

3.5. 可移植对象的

SNMP++的主体是可以移植的C++代码。其中只有Snmp Class的实现与不同的目标操作系统有关。如果你的程序中包含了SNMP++的代码，那么导出这部分代码的时候，就可以不做任何修改。

3.6. 自动超时和重发机制

SNMP++提供了自动超时和重发机制，程序员不用去实现超时或重发机制的代码。重发机制是在SnmpTarget Class里面定义的，这就使得每一个目标（Target）都具有了它自己的超时/重发机制。

3.7. 阻塞模式

SNMP++提供了阻塞方式。MS-Windows上的阻塞方式可以并发的阻塞从每个SNMP类的实例发出的请求。

3.8. 异步的非阻塞模式

SNMP++还为应答提供了异步的非阻塞的方式。超时和重发机制同时支持阻塞和异步两种模式。

3.9. Notification、Trap的收发

SNMP++允许在多种传输层上（包括IP和IPX）收发trap。而且SNMP++还允许使用非标准的IP端口和IPX套接口来收发trap。

3.10. 通过双效的API支持SNMPv1和SNMPv2

SNMP++的设计可同时支持SNMPv1和SNMPv2的使用。所有API的操作都被设计成了双效的，也即操作是SNMP版本无关的。通过使用SnmpTarget类，与SNMP的版本相关的操作被抽象出来了。

3.11. 支持SNMP的Get, Get Next, Get Bulk, Set, Inform和Trap的操作

SNMP++完整的支持SNMP的6种操作。这6个SNMP++的成员函数使用相同的参数表，也都支持阻塞和非阻塞（异步）方式。

3.12. 通过继承实现重定义

SNMP++是用C++实现的，所以允许程序员重载或重定义那些不适合他们的操作。举个例子：如果一个应用需要特定的Oid对象，那就需要建立一个Oid Class的子类，用以继承所有Oid类的属性和操作，同时在派生类种加入新的属性和操作。

4. 在Microsoft Windows 系列操作系统上使用SNMP++

SNMP++已经在MS-Windows 3.1, MS-Windows For Work Groups 3.11, MS-Windows NT 3.51, and MS-Windows ’95上实现了。

4.1. WinSNMP Version 1.1的使用

在MS-Windows上可以用WinSNMP Version 1.1来运行SNMP++。这就使得其他用WinSNMP代码直接写的SNMP应用可以与SNMP++的应用兼容。注意，目前HP的MS-Windows设备使用WinSNMP，其他设备不需要使用WinSNMP来进行ANS.1的编码和解码。但那些没有使用WinSNMP的设备也需要与WinSNMP的应用兼容，才能和SNMP++的应用兼容。

4.2. 对IP和IPX的支持

可以通过一个WinSock compliant stack，来实现对IP的操作。同时为了在IPX协议上运行，还需要兼容Novell网络的客户程序和驱动。目前SNMP++已经通过了在广泛多样的协议栈下的运行测试，这些协议栈包括：FTP，Netmanage，LanWorkPlace，MS-WFWG 3.11，以及Windows NT。

4.3. 对Notification、Trap收发的支持

SNMP++ 包含了对WinSNMP trap机制的支持。这同时包括了trap的发送和收取。在接收trap的时候，还提供了过滤trap的功能。

4.4. 与HP OpenView for Windows 兼容

已经有大量使用SNMP++创建的应用，实现了HP OpenView for Windows的兼容。

5. 在UNIX上使用SNMP++

5.1. 统一的类的接口

用在UNIX设备上的SNMP++类的接口和MS-Windows是一样的。

5.2. Windows到UNIX的仿真与移植

通过编译、连接对应的SNMP++类，SNMP++就可以实现在UNIX上运行。SNMP++/UNIX的设计决定了它可以同时运行在原始的UNIX字符模式、X-Window模式，或者Windows-to-UNIX的仿真工具上。

5.3. 与HP OpenView for UNIX 兼容

已经有大量使用SNMP++创建的应用，实现了与HP OpenView for UNIX的兼容。

6. SNMP Syntax Classes

SNMP++之SNMP Syntax的对象模型（Object Modeling Technique）视图

SNMP++的SNMP syntax classe描绘了一个具有C++面向对象风格的视图。即用于描述SNMP的SMI之ASN.1的数据类型视图。它包含了映射到对应的SMI类型的一组类的集合。而且为了方便使用，还引入了一些非SMI的类。SNMP++为这些SNMP数据类型提供了强大、简单易用的接口。下表概要地描述了各种SNMP++ syntax classes：

SNMP++ Syntax Class Name	Class Description	SMI or ASN.1 Counter part
SnmpSyntax	Parent of all syntax classes.	No ASN.1 counter part, used for OO structure.
Oid	Object identifier class.	ASN.1 Object Identifier.
OctectStr	Octet string class.	ASN.1 Octet string.
Uint32	Unsigned 32 bit integer class.	SMI unsigned 32 bit integer.
TimeTicks	TimeTicks class.	SMI time ticks.
Counter32	32 bit counter class.	SMI 32 bit counter.
Gauge32	32 bit gauge class.	SMI 32 bit gauge.
Int32	Signed 32 bit integer.	SMI 32 bit signed integer.
Counter64	64 bit counter class.	SMI 64 bit counter.
Address	Abstract address class.	No ASN.1 counter part used for OO structure.
IpAddress	IP address class.	SMI IP address.
UdpAddress	UdpAddress class	SMI IP address with port specification.
IpxAddress	IPX address class.	No ASN.1 or SMI counter part
IpxSockAddress	IPX Address class with socket number.	No ASN.1 or SMI counter part
MacAddress	MAC address class.	SMI counter part
GenAddress	Generic Address	No ASN.1 or SMI counter part.

7. Object Id Class

SNMP++之Oid Class的对象模型（Object Modeling Technique）视图

7.1. 对象标识符类

对象标识符类（Oid）封装了SMI的对象标识。信息管理库（MIB）中所定义的SMI的对象是一种在MIB中找到的数据元素的数据标识。与SMI Oid相关的结构和函数，自然都是面向对象的。事实上Oid class与C++的String class有许多共同之处。如果你熟悉C++的String class或者MFC的CString class，那么你就会感觉Oid class用起来很亲切、简单。Oid class被设计成了快速有效的类；它可以定义和操作对象标识；不依赖现有的 SNMP API，完全是可移植的；可以在任何ANSI C++编译器上进行编译。

7.2. Oid Class的成员函数列表

Oid Class Member Functions	说明
Constructors
Oid::Oid( void);	构造一个空的的Oid
Oid::Oid( const char *dotted_string);	用带点的字符串构造新的Oid
Oid::Oid( const Oid &oid);	用已有的Oid构造新的Oid
Oid::Oid( const unsigned long *data, int len);	通过一个指针和长度来构造一个新的Oid
Destructor
Oid::~Oid( );	销毁一个Oid，释放所有的堆
Overloaded Operators
Oid & operator = ( const char *dotted_string);	将一个带点的字符串付给一个Oid
Oid & operator = ( const Oid &oid);	将一个Oid付给另一个Oid
int operator == ( const Oid &lhs, const Oid& rhs);	判断两个Oid是否相等
int operator == ( const Oid& lhs, const char*dotted_string);	判断一个Oid是否和一个带点的字符串相等
int operator != ( const Oid &lhs, const Oid& rhs);	判断两个Oid是否不等
int operator != ( const Oid & lhs, const char *dotted_string);	判断一个Oid是否和一个带点的字符串不相等
int operator < ( const Oid &lhs, const Oid& rhs);	判断一个Oid是否比另一个小
int operator < ( const Oid &lhs, const char *dotted_string);	判断一个Oid是否比一个带点的字符串小
int operator <=( const Oid &lhs,const Oid &rhs);	判断一个Oid是否“小于等于”另一个
int operator <= ( const Oid &lhs, const char *dotted_string);	判断一个Oid是否“小于等于”一个带点的字符串
int operator > ( const Oid &lhs, const Oid &rhs);	判断一个Oid是否比另一个大
int operator > ( const Oid &lhs, const char * dotted_string);	判断一个Oid是否比一个带点的字符串大
int operator >= ( const Oid&lhs, const Oid &rhs);	判断一个Oid是否“大于等于”另一个
int operator >= ( const Oid &lhs, const char* dotted_string);	判断一个Oid是否“大于等于”一个带点的字符串
Oid& operator += ( const char *dotted_string);	将一个带点的字符串加到一个Oid后面
Oid& operator +=( const unsigned long i);	将一个整数加到一个带点的Oid字符串后面
Oid& operator+=( const Oid& oid);	将一个Oid加到另一个Oid后面
unsigned long &operator [ ] ( int position);	访问Oid的一个独立子单元
Output Member Functions
char * get_printable( const unsigned int n);	返回一个Oid的n个带点格式的子单元
char *get_printable( const unsigned long s, const unsigned long n);	返回从s开始，以点号分割的n个子单元
char *get_printable();	返回以点号分割的Oid字符串
operator char *();	同上
Miscellaneous Member Functions
set_data (const unsigned long *data,const unsigned long n);	用指针和长度来设置一个Oid
unsigned long len( );	返回Oid中子单元的个数（长度）
trim( const unsigned long n=1);	删除Oid最右边的n个子单元，默认删除1个
nCompare( const unsigned long n, const Oid& oid);	从左至右比较Oid的前n个子单元
RnCompare( const unsigned long n, const Oid& oid);	从右至左比较Oid的后n个子单元
int valid( );	返回Oid的有效性

7.3. 一些Oid Class的例子

下面的例子展示了Oid Class的不同用法。Oid Class不需要依赖其他库和模块。下列代码在ANSI/ISO C++上编译通过

#include “oid.h”

void oid_example()

{

// construct an Oid with a dotted string and print it out

Oid o1("1.2.3.4.5.6.7.8.9.1");

cout << “o1= “ << o1.get_printable ();

// construct an Oid with another Oid and print it out

Oid o2(o1);

cout << “o2= ” << o2.get_printable();

// trim o2’s last value and print it out

o2.trim(1);

cout << “o2= ” << o2.get_printable();

// add a 2 value to the end of o2 and print it out

o2+=2;

cout << “o2= ” << o2.get_printable();

// create a new Oid, o3

Oid o3;

// assign o3 a value and print it out

o3="1.2.3.4.5.6.7.8.9.3";

cout << “o3= ” << o3.get_printable();

// create o4

Oid o4;

// assign o4 o1’s value

o4=o1;

// trim off o4 by 1

o4.trim(1);

// concat a 4 onto o4 and print it out

o4+=”.4”;

cout << “o4= ” << o4.get_printable();

// make o5 from o1 and print it out

Oid o5(o1);

cout << “o5= ” << o5.get_printable();

// compare two not equal oids

if (o1==o2) cout << "O1 EQUALS O2";

else cout << "o1 not equal to o2";

// print out a piece of o1

cout << "strval(3) of O1 = “ << o1.get_printable(3);

// print out a piece of o1

cout << "strval(1,3) of O1 = “ << o1.get_printable(1,3);

// set o1's last subid

o1[ o1.len()-1] = 49;

cout << "O1 modified = “ << o1.get_printable();

// set o1's 3rd subid

o1[2]=49;

cout << "O1 modified = “ << o1.get_printable();

// get the last subid of 02

cout << "last of o2 = “ << o2[o2.len()-1];

// get the 3rd subid of 02

cout << "3rd of o2 = “ << o2[2];

// ncompare

if (o1.nCompare(3,o2))

cout << "nCompare o1,o2,3 ==";

else

cout << "nCompare o1,o2,3 !=";

// make an array of oids

Oid oids[30]; int w;

for ( w=0;w<30;w++)

{

oids[w] = "300.301.302.303.304.305.306.307";

oids[w] += (w+1);

}

for (w=0;w<25;w++)

{

sprintf( msg,"Oids[%d] = %s",w, oids[w].get_printable());

printf(“%s”,msg, strlen(msg));

}

8. OctetStr Class

SNMP++之OctetStr Class的对象模型（Object Modeling Technique）视图

8.1. 八位字节类

通过SNMP++的Octet class，可以简单且安全地操作SMI的8位字节。有了Octet class，就不需要通过内部指针和长度来操作8位字节了。使用SNMP++的Octet class来实例化、操作、销毁一个8位字节对象是很简单的，不用担心如何管理内存以及内存是否会泄漏。与ANSI C++的string class类似，OctetStr class可以通过多种方法构造8位字节，还可以对它们进行赋值操作，与其他SNMP++ classes一起使用。

8.2. OctetStr Class的成员函数列表

OctetStr Class Member Functions	说明
Constructors
OctetStr::OctetStr( void);	构造一个空的OctetStr
OctetStr::OctetStr( const char* string);	用一个没有结束符的字符串构造OctetStr
OctetStr::OctetStr( const unsigned char *s, unsigned long int i);	通过一个指针和长度来构造OctetStr
OctetStr::OctetStr( const OctetStr &octet);	用已有的OctetStr构造新的OctetStr
Destructor
OctetStr::~OctetStr( );	销毁一个OctetStr
Overloaded Operators
OctetStr& operator = ( const char *string);	将一个没有结束符的字符串付给一个OctetStr
OctetStr& operator = ( const OctetStr& octet);	将一个OctetStr付给另一个OctetStr
int operator == ( const OctetStr &lhs, const OctetStr &rhs);	判断两个OctetStr对象是否相等
int operator == ( const OctetStr & lhs, const char *string);	判断OctetStr是否和一个char*字符串相等
int operator != ( const OctetStr& lhs, const OctetStr& rhs);	判断两个OctetStr对象是否不相等
int operator != ( const OctetStr& lhs, const char *string);	判断OctetStr是否和一个char*字符串不相等
int operator < ( const OctetStr&lhs, const OctetStr& rhs);	判断一个OctetStr是否比另一个小
int operator < ( const OctetStr &lhs, const char * string);	判断一个OctetStr是否比另一个char *字符串小
int operator <= ( const OctetStr &lhs, const OctetStr &rhs);	判断一个OctetStr是否“小于等于”另一个
int operator <= ( const OctetStr &lhs, const char * string);	判断一个OctetStr是否“小于等于”一个char *的字符串
int operator > ( const OctetStr& lhs, const OctetStr &rhs);	判断一个OctetStr是否比另一个大
int operator > ( const OctetStr& lhs, const char * string);	Test if one OctetStr is greater than a char . 判断一个OctetStr是否比一个char 的字符串大
int operator >= ( const OctetStr& lhs, const OctetStr &rhs);	判断一个OctetStr是否“大于等于”另一个
int operator >= ( const OctetStr& lhs, const char *);	判断一个OctetStr是否“大于等于”一个char*的字符串
OctetStr& operator +=( const char * string);	在一个OctetStr后面连接一个字符串
OctetStr& operator +=( const unsigned char c);	在一个OctetStr后面连接一个单字符
OctetStr& operator+=( const OctetStr &octetstr);	将两个OctetStr连接在一起
unsigned char& operator[ ] ( int position i);	用数组的形式来访问一个OctetStr
Miscellaneous
void set_data( const unsigned char *s, unsigned long l);	用指针和长度来设置一个OctetStr
int nCompare( const unsigned long n, const OctetStr &o);	与另一个OctetStr比较前n个元素
unsigned long len();	返回一个OctetStr的长度
int valid();	返回一个OctetStr的有效性
unsigned char * data();	返回一个指向内部数据的指针
char * get_printable();	格式化输出，如果不是ASCII则按16进制处理
char * get_printable_hex();	按16进制格式，进行格式化输出

8.3. 注意

当输出一个OctetStr对象时，如果该8位字节所包含的字符不是ASCII码，对成员函数char *或者get_printable()的调用，就会自动转换成对成员函数get_printable_hex()的调用。这就使得使用者只需要简单地使用成员函数char *或get_printable()来进行输出。而成员函数get_printable_hex()是专门用来把OctetStr按16进制格式输出的。

8.4. 一些OctetStr Class的例子

// Octet Class Examples

#include “octet.h”

void octet_example()

{

OctetStr octet1; // create an invalid un- initialized octet object

OctetStr octet2( “Red Hook Extra Bitter Ale”); // create an octet with a string

OctetStr octet3( octet2); // create an octet with another octet

unsigned char raw_data[50]; // create some raw data

OctetStr octet4( raw_data, 50); // create an OctetStr using unsigned char data

octet1 = “Sierra Nevada Pale Ale”; // assign one octet to another

cout << octet1.get_printable(); // show octet1 as a null terminated string

cout << octet4.get_printable_hex(); // show octet4 as a hex string

cout << (char *) octet1; // same as get_printable()

if ( octet1 == octet2) // compare two octets

cout << “octet1 is equal to octet2”;

octet2 += “WinterFest Ale”; // concat a string to an Octet

if ( octet2 >= octet3)

cout << “octet2 greater than or equal to octet2”;

octet2[4] = ‘b’; // modify an element of an OctetStr using [ ]’s

cout << octet.len(); // print out the length of an OctetStr

unsigned char raw_data[100];

octet1.set_data( raw_data, 100); // set the data of an to unsigned char data

// get the validity of an OctetStr

cout << (octet1.valid() )? “Octet1 is valid” : “Octet1 is Invalid”;

}; // end octet example

9. TimeTicks Class

SNMP++之TimeTicks Class的对象模型（Object Modeling Technique）视图

9.1. 时间戳类

SNMP++的TimeTicks Class为使用SMI中的timeticks带来了方便。SMI的时间戳被定义成了一种存放无符号长整形的存储单元。为了成为无符号长整形，SMI timeticks被加工成了一种特殊的类型。因此SNMP++的TimeTicks类具有无符号长整形的所有功能和属性，但同时又是一个独立的类。对无符号长整形的任何操作，拿到TimeTicks的对象上一样有效。TimeTicks class与其他SNMP++的类，比如Vb class交互的时候，还可以有些额外的操作：在使用Vb class的时候，TimeTicks的对象可以被置入Vb对象（用Vb::set），也从Vb对象中取出（用Vb::get）。也即，对于SMI timeticks，开发者可以像对无符号长整形一样来操作，并且还提供了一对一的映射关系。

9.2. TimeTicks Class的成员函数列表

TimeTicks Class Member Functions	说明
Constructors
TimeTicks::TimeTicks( void);	构造一个空的TimeTicks对象
TimeTicks::TimeTicks( const unsigned long i );	用一个无符号长整形来构造一个TimeTicks对象
TimeTicks:;TimeTicks( const TimeTicks &t);	用一个已有的TimeTicks对象来构造一个新的
Destructor
TimeTicks::~TimeTicks( );	销毁一个TimeTicks对象
Overloaded Operators
TimeTicks& operator =( const TimeTicks &t);	重载赋值操作符
char * get_printable();	格式化输出，格式为：DD Days, HH:MM:SS.hh
operator unsigned long();	把TimeTicks转换为无符号长整形

9.3. 注意

TimeTicks对象用TimeTicks::get_printable()输出时，其值自动被格式化为“DD days, HH:MM:SS.hh”。其中DD代表天，HH代表小时（24时制的），MM代表分钟，SS是秒钟，hh则是百分之几秒。

9.4. 一些TimeTicks Class的例子

// TimeTicks Examples

#include “timetick.h”

void timeticks_example()

{

TimeTicks tt; // create an un-initialized timeticks instance

TimeTicks tt1( (unsigned long) 57); // create a timeticks using a number

TimeTicks tt2( tt1); // create a timeticks using another instance

tt = 192; // overloaded assignment to a number

tt2 = tt; // overloaded assignment to another timeticks

cout << tt.get_printable(); // print out in DD days, HH:MM:SS.hh

cout << ( unsigned long) tt; // print out unsigned long int value

}; // end timeticks example

10. Counter32 Class

SNMP++之Counter32 Class的对象模型（Object Modeling Technique）视图

10.1. 32位计数器类

当需要用到SMI中的32位计数器时，SNMP++的Counter32 Class为之带来了方便。SMI的计数器被定义成了一种存放无符号长整形的存储单元。为了成为无符号长整形，SMI counters被加工成了一种特殊的类型。因此SNMP++的Counter32类具有无符号长整形的所有功能和属性，但同时又是一个独立的类。对无符号长整形的任何操作，拿到Counter32的对象上一样有效。Counter32 class与其他SNMP++的类，比如Vb class交互的时候，还可以有些额外的操作：在使用Vb class的时候，Counter32的对象可以被置入Vb对象（用Vb::set），也从Vb对象中取出（用Vb::get）。也即，对于SMI counter，开发者可以像对无符号长整形一样来操作，并且还提供了一对一的映射关系。

10.2. Counter32 Class的成员函数列表

Counter32 Class Member Functions	说明
Constructors
Counter32::Counter32( void);	构造一个空的Counter32对象
Counter32::Counter32( const unsigned long i );	用一个无符号长整形来构造一个Counter32对象
Counter32::Counter32( const Counter32 &c);	用一个已有的Counter32对象来构造一个新的
Destructor
Counter32::~Counter32( );	销毁一个TimeTicks对象
Overloaded Operators
Counter32& operator = ( const Counter32& c);	重载赋值操作符
char * get_printable();	格式化输出Counter32对象
operator unsigned long( );	把Counter32转换为无符号长整形

10.3. 一些Counter32 Class的例子

// Counter Examples

#include “counter.h”

void counter_example()

{

Counter32 ctr; // create an un-initialized counter instance

Counter32 ctr1( (unsigned long) 57); // create a counter using a number

Counter32 ctr2(ctr1); // create a counter using another instance

ctr = 192; // overloaded assignment to a number

ctr1 = ctr; // overloaded assignment to another counter

cout << (unsigned long) ctr; // behave like an unsigned long int

}; // end counter example

11. Gauge32 Class

SNMP++之Gauge32 Class的对象模型（Object Modeling Technique）视图

11.1. 容量类

SNMP++的Gauge32 Class为使用SMI中的timeticks带来了方便。SMI的容量被定义成了一种存放无符号长整形的存储单元。为了成为无符号长整形，SMI gauges被加工成了一种特殊的类型。因此SNMP++的Gauge32类具有无符号长整形的所有功能和属性，但同时又是一个独立的类。对无符号长整形的任何操作，拿到Gauge32的对象上一样有效。Gauge32 class与其他SNMP++的类，比如Vb class交互的时候，还可以有些额外的操作：在使用Vb class的时候，TimeTicks的对象可以被置入Vb对象（用Vb::set），也从Vb对象中取出（用Vb::get）。也即，对于SMI gauge，开发者可以像对无符号长整形一样来操作，并且还提供了一对一的映射关系。

11.2. Gauge32 Class的成员函数列表

Gauge32 Class Member Functions	说明
Constructors
Gauge32::Gauge32( void);	构造一个空的Gauge32对象
Gauge32::Gauge32( const unsigned long i );	用一个无符号长整形来构造一个Gauge32对象
Gauge32::Gauge32( const Gauge32 &g);	用一个已有的Gauge32对象来构造一个新的
Destructor
Gauge32::Gauge32( );	销毁一个Gauge32对象
Overloaded Operators
Gauge32& operator = ( const Gauge32 &g);	重载赋值操作符
char * get_printable();	格式化输出Gauge32对象
operator unsigned long( );	把Gauge32转换为无符号长整形

11.3. 一些Gauge32的例子

// Gauge Examples

#include “gauge.h”

void gauge_example()

{

Gauge32 gge ; // create an un-initialized Gauge instance

Gauge32gge1( (unsigned long) 57); // create a Gauge using a number

Gauge32 ctr2(ctr1); // create a Gauge using another instance

gge = 192; // overloaded assignment to a number

gge1 = gge; // overloaded assignment to another counter

cout << (unsigned long) gge; // behave like an unsigned long int

}; // end gauge example

12. Counter64 Class

SNMP++之Counter64 Class的对象模型（Object Modeling Technique）视图

12.1. 64位计数器类

SNMP++的64bit counter class实现了SMI的64 bit counters。64位计数器是在SNMPv2中定义的一种变量，所以在SNMPv1中并不存在这种MIB变量。64 bit counters由两个无符号长整形（一高位、一低位）组成，Counter64 class很好的实现了它。因为Counter64 class提供了加减乘除操作符的重载，所以它使用起来感觉很自然。

12.2. Counter64 Class的成员函数列表

Counter64 Class Member Functions	说明
Constructors
Counter64::Counter64( void);	构造一个空的Counter64对象
Counter64::Counter64(const unsigned long hi, const unsigned long low );	用两个无符号长整形来构造一个Counter64对象
Counter64::Counter64( const Counter64 &ctr64);	拷贝构造函数
Counter64::Counter64( const unsigned long ul);	用一个无符号长整形来构造一个Counter64对象
Destructor
Counter64::~Counter64( );	销毁一个Counter64对象
Overloaded Operators
Counter64& operator = ( const Counter64 &ctr64);	将一个Counter64对象付给另一个
Counter64& operator = ( const unsigned long i );	用一个无符号长整形设置Counter64对象的低位，同时清除了它的高位
Counter64 operator + ( const Counter64 &ctr64);	两个Counter64对象相加
Counter64 operator - ( const Counter64 &ctr64);	两个Counter64对象相减
Counter64 operator * ( const Counter64 &ctr64);	两个Counter64对象相乘
Counter64 operator / ( const Counter64 &ctr64);	两个Counter64对象相除
int operator == ( Counter64 &lhs, Counter64 &rhs);	判断两个Counter64对象是否相等
int operator != ( Counter64 &lhs, Counter64 &rhs);	判断两个Counter64对象是否不相等
int operator < ( Counter64 &lhs, Counter64 &rhs);	判断一个Counter64是否比另一个小
int operator <= ( Counter64 &lhs, Counter64 &rhs);	判断一个Counter64是否“小于等于”另一个
int operator > ( Counter64 &lhs, Counter64 &rhs);	判断一个Counter64是否比另一个大
int operator >= ( Counter64 &lhs, Counter64 &rhs);	判断一个Counter64是否“大于等于”另一个
Member Functions
unsigned long high();	返回Counter64对象的高位
unsigned long low();	返回Counter64对象的低位
void set_high();	设置Counter64对象的高位
void set_low();	设置Counter64对象的低位

12.3. 一些的Counter64 Class例子

// Counter64 examples

#include “ctr64.h”

void counter64_example()

{

Counter64 c64; // instantiate a 64 bit counter object with no parms

Counter64 my_c64( 100, 100); // instantiate a 64 bit counter with a hi and low value

Counter64 your_c64( my_c64); // instantiate a 64 counter using another 64bit counter

cout << my_c64.high(); // print out the high portion of the c64

cout << my_c64.low(); // print out the low portion of the c64

c64 = my_c64 + your_c64; // overloaded addition

c64 = my_c64 * your_c64; // overloaded multiplication

c64 = my_c64 / your_c64; // overloaded division

c64 = my_c64 - your_c64; // overloaded subtraction

if ( c64 == my_c64) // overloaded equivalence test

cout << “c64 equals my_c64\n”;

if ( c64 != my_c64) // overloaded not equal test

cout << “c64 not equal to my_c64\n”;

if ( c64 < my_c64) // overloaded less than

cout << “c64 less than my_c64\n”;

}; // end Counter64 example

13. Address Class

SNMP++之Address Class的对象模型（Object Modeling Technique）视图

13.1. 什么是网络地址类？

网络地址类是一组C++类的集合，它提供了简单、安全、可移植、高效地使用网络地址的方法。许多网络管理应用需要通过网络地址来访问和管理设备，包括地址的确认、更改，以及用户接口的分配。Address class不但管理了所有指定的网络地址的内部细节，而且还通过封装和隐藏其内部机制，让得到解放的开发应用的程序员可以专注于解决实际问题。开发Address class的动机来源于95年 Interop SNMP++ Birds-of-A-Feather (BOF)上的讨论以及与Hewlett-Packard OpenView程序员的交流。

13.2. 为什么要使用网络地址类？

地址类提供了以下好处：自动内存管理、地址确认、移植到任何C++环境、简单易用，及可扩充性。目前的Address class由4个子类组成：IpAddress Class, IpxAddress Class, MacAddress class和GenAddress class。将来也许会有其他的子类加入，比如IP Next Generation (IPng)。

13.3. Address class

所有地址类都派生自同一个抽象基类：Address class。它是一个抽象类，即这个类不会产生实例对象。Address class通过使用虚成员函数，提供了公用接口。也就是说可以使用公用接口调用各个不同地址类的函数。这样的结果是：当需要修改使用了地址类的模块时，需要改动的代码就很少了。

13.4. Address Classes及其接口

作为基类的Address Classes是一个抽象类，它囊括了所有子类的通用操作。也即包含了以下统一的接口：构造、访问、修改地址。

Address Class Member Functions	说明
IpAddress Class Constructors
IpAddress::IpAddress( void);	构造一个空的IpAddress对象
IpAddress::IpAddress( const char *string);	用一个字符串构造一个IpAddress，当需要时一般用到DNS上
IpAddress::IpAddress( const IpAddress &ipa);	拷贝构造函数
IPAddress Member Functions
char * friendly_name( int & status);	让DNS的名字看起来更友好
UdpAddress Constructors
UdpAddress::UdpAddress( void);	构造一个无效的UdpAddress对象
UdpAddress::UdpAddress( const char *string);	用一个字符串构造一个UdpAddress
UdpAddress::UdpAddress( const UdpAddress &udpa);	用一个已有的UdpAddress来构造另一个
UdpAddress Member Functions
void UdpAddress:set_port( const unsigned int p);	设置UdpAddress对象的端口号
unsigned int UdpAddress::get_port();	获取UdpAddress对象的端口号
IpxAddress Class Constructors
IpxAddress::IpxAddress( void);	构造一个空的IPX地址
IpxAddress::IpxAddress( const char *string);	用一个字符串构造一个IPX地址
IpxAddress::IpxAddress( const IpxAddress &ipxa);	拷贝构造函数
IpxSockAddress Constuctors
IpxSockAddress::IpxSockAddress( void);	构造一个空的IpxSockAddress对象
IpxSockAddress::IpxSockAddress( const char *string);	用一个字符串构造一个IpxSockAddress
IpxSockAddress::IpxSockAddress( const IpxSockAddress &ipxs);	用一个已有的IpxSockAddress来构造另一个
IpxSockAddress Member Functions
IpxSockAddress::set_socket( const unsigned int s);	从一个IpxSockAddress获得套接字
unsigned int IpxSocketAddress::get_socket();	设置一个IpxSockAddress的套接字
MacAddress Constructors
MacAddress::MacAddress( void);	构造一个空的MacAddress对象
MacAddress::MacAddress( const char * string);	用一个字符串构造一个MacAddress
MacAddress::MacAddress( const MacAddress &mac);	拷贝构造函数
GenAddress Constructors
GenAddress::GenAddress( void);	构造一个无效的GenAddress对象
GenAddress::GenAddress( const char * addr);	用一个字符串构造一个GenAddress
GenAddress::GenAddress( const GenAddress &addr);	拷贝构造函数
Common Member Functions, applicable to all Address classes
int operator == ( const Address &lhs, const Address rhs);	判断两个地址是否相等
int operator != ( const Address &lhs, const Address &rhs);	判断两个地址是否不相等
int operator > ( const Address &lhs, const Address &rhs);	判断一个地址是否大于另一个
int operator >= (const Address &lhs, const Address &rhs);	判断一个地址是否大于等于另一个
int operator < ( const Address &lhs, const Address &rhs);	判断一个地址是否小于另一个
int operator<=( const Address &lhs, const Address &rhs);	判断一个地址是否小于等于另一个
int operator == ( const Address &lhs, cosnt char *inaddr);	判断一个地址是否等于一个字符串
int operator > ( const Address &lhs, const char *inaddr);	判断一个地址是否大于一个字符串
int operator < ( const Address &lhs, const char *inaddr);	判断一个地址是否小于一个字符串
virtual int valid( );	判断一个地址的有效性
unsigned char& operator[]( int position);	允许通过数组的下标操作符来访问一个地址
char * get_printable ( );	返回格式化输出的地址

13.5. IpAddress Class的特点

IpAddress Class可以通过调用成员函数Address::get_printable()自动以DNS显示出来。如果没有激活DNS或者无法识别地址，则返回以点号分割的字符。另一方面，一个IpAddress可以用一个友好的名字（字符串，而非以点号分割的数字）来构造，这样构造函数就可以激活DNS的显示。如果这个名字没被找到，那么该地址也就是无效的。这个强大的功能允许你在对外表现时，使用友好的名字方式。

13.6. GenAddress的特点

GenAddress class允许创建和使用通用的地址，即GenAddress拥有其他地址类（IpAddress, IpxAddress 和 MacAddress）的操作和属性，所以你可以使用GenAddress来操作任何地址。GenAddress class的构造函数允许用任何字符串来建立一个地址。构造函数通过匹配的字符串以及加载在GenAddress上的属性与操作，决定其地址的具体类型。这样就解放了程序员，因为面对不一样的地址，程序员不用再专门写代码来处理了。

GenAddress Examples

GenAddress address1(“10.4.8.5”); // make an IP GenAddress

GenAddress address2(“01020304-10111213141516”); // make an IPX GenAddress

GenAddress address3(“01:02:03:04:05:06”); // make a MAC GenAddress

cout << address3.get_printable(); // print out the GenAddress

if ( !address1.valid()) // check validity

cout << “address1 ! valid”;

13.7. Address Class的有效性

所有地址类都支持成员函数::valid()，它可以返回指定地址对象的有效性。有效性是在构造或给一个地址对象赋值时决定的。只有在赋值之后，成员函数::valid()才可以被用来判断其有效性。

Address Class Validation Examples

MacAddress mac;

mac = “01.010a0d”; // invalid MAC address

printf(“%s”, (mac.valid() ? “Valid” :”Invalid”));

13.8. UdpAddresses和IpxSockAddresses

大多数时候，SNMP++的用户会使用默认的端口号和套接字来进行SNMP操作。就IP协议而言， 161端口一般用来作为代理的目标端口， 162端口一般用作trap和Notification的接收端口。有些时候需要改变指定的端口号和套接字，UdpAddress class和IpxSockAddress class就允许定义端口和套接字的信息。

13.8.1. 用UdpAddresses发送请求

当向一个使用非标准默认端口的代理端发送请求信息时，就需要用到UdpAddresses class了。UdpAddresses class提供了两个成员函数分别来设置和获取自定义的端口信息。用一个加载了UdpAddresses的目标来发送请求，就可以实现SNMP++对自定义端口的使用。

13.8.2. 用IpxSockAddresses发送请求

当向一个使用非标准默认IPX套接字的代理端发送请求信息时，就需要用到IpxSockAddresses class了。IpxSockAddresses提供了两个成员函数分别来设置和获取自定义的IPX套接字信息。用一个加载了IpxSockAddress的目标来发送请求，就可以实现SNMP++对自定义套接字的使用。

13.8.3. 用UdpAddress和IpxSockAddress接收Notification

UdpAddress和IpxSockAddress还可以通过指定需要修改的端口和套接字来接收notification。即允许应用通过非标准的端口和套接字来接收trap和inform。

13.9. 有效的地址格式

目前的有效地址格式定义如下：

Valid IP format BNF Grammar XXX.XXX.XXX.XXX

ip-address : ip-token DOT ip-token DOT ip-token DOT ip-token

DOT : ‘.’

ip-token : [0-255]

Valid IPX format BNF GrammarXXXXXXXX:XXXXXXXXXXXX

ipx-address: net-id SEPARATOR mac-id

SEPARATOR : ‘ ‘ | ‘:’ | ‘-’ | ‘.’

net_id : 1{byte-token}4

mac-id: 1{byte-token}6

byte-token: 1{byte}2

byte: [0-9|a-f|A-F]

Valid MAC format BNF Grammar XX:XX:XX:XX:XX:XX

mac-id: byte_token colon byte_token colon byte_token colon byte_token colon byte_token

byte-token: 1{byte}2

byte: [0-9|a-f|A-F]

colon: ‘:’

13.10.Address Class例子

// address class examples

#include “address.h”

void address_examples()

{

//--------------[ IPAddress construction ]------------------------------------------------------

IpAddress ip1(); // makes an invalid IpAddress object

IpAddress ip2(“10.4.8.5”); // makes a IpAddress verifies dotted format

IpAddress ip3(ip2); // makes an IpAddress using another IpAddress

IpAddress ip4(“trout.rose.hp.com”); // makes an IpAddress does DNS on string

//-------------[ IPX Address construction ]-----------------------------------------------------

IpxAddress ipx1(); // makes an invalid IPX address

IpxAddress ipx2(”); // makes and verifies an IPX address

IpxAddress ipx3( ipx2); // makes an IPX from another IPX

//--------------[ MAC Address construction ]-----------------------------------------------------

MacAddress mac1(); // makes an invalid MAC address

MacAddress mac2(“08:09:12:34:52:12”); // makes and verifies a MAC address

MacAddress mac3( mac2); // makes a MAC from another MAC

//---------------[ Gen Address Construction ]-----------------------------------------------------

GenAddress addr1(“10.4.8.5”);

GenAddress addr2(“01020304:050607080900”);

//--------------[ printing addresses ]----------------------------------------------------------------

cout << (char *) ip2;

cout << (char *) ipx2;

cout << (char *) mac2;

//---------------[ assigning Addresses ]------------------------------------------------------------

ip1 = “15.29.33.10”;

ipx1 = “00000001-080912345212”;

mac1 = “08:09:12:34:52:12”;

//--------------[ comparing Addresses ]----------------------------------------------------------

if ( ip1 == ip2)

cout << “ip1 == ip2”;

if (ipx1 != ipx2)

cout << “ipx1 != ipx2”;

if ( mac1 <= mac2)

cout << “mac1 < mac2”;

//---------------[ modifying an address ]-----------------------------------------------------------

mac1[4] = 15;

cout << mac2[2];

}; // end address examples

14. The Variable Binding Class

SNMP++之Variable Binding ( Vb)Class的对象模型（Object Modeling Technique）视图

Variable Binding ( Vb) class 是SNMP“绑定变量”的封装。一个“绑定变量”是由SNMP的object ID及其SMI的value组合而成的。用面向对象的概念来看，这只是一个简单的关联关系：一个Vb对象含有一个Oid对象及其SMI的value。Vb class允许应用的开发者实例化Vb对象，然后为其分配Oid部分（用Vb::set_value()），并分配value部分（用Vb::get_value()）。相反的，Oid和value部分可以通过成员函数Vb::get_oid()和Vb::get_value()提取出来。通过重载了的公有成员函数Vb::set_value()和Vb::get_value()，可以把不同的SMI的value针对“绑定变量”进行“设置”与“取出”。“绑定变量表”在SNMP++中表现为Vb对象的数组。所有的SMI类型都与Vb Class兼容。Vb class隐藏了所有内部数据。使用者不需要知道SMI的value的类型，Oid的内部表示方法，以及其他SNMP相关的结构。如果使用的是标准ANSI C++编译器，Vb class是完全可移植的。

14.1. Variable Binding Class成员函数列表

Variable Binding Class Member Functions	说明
Constructors
Vb( void);	构造一个空的Vb对象
Vb( const Oid &oid);	用Oid部分构造一个Vb
Vb( const Vb &vb);	拷贝构造函数
Destructor
~Vb();	销毁一个Vb，释放所有的资源
Set Oid / Get Oid
void set_oid( const Oid &oid);	设置一个Vb的Oid部分
void get_oid( Oid &oid) const;	获得Oid部分
Set Value
void set_value( const SMIValue &val);	设置任一SmiValue
void set_value( const int i);	设置一整形value
void set_value( const long int i);	设置一长整形value
void set_value( const unsigned long int i);	设置一无符号长整形value
void set_value( const char WINFAR * ptr);	设置一有结束标志符的字符串value
Get Value
int get_value( SMIValue &val);	获得任一SmiValue
int get_value( int &i);	获得一整形value
int get_value( long int &i);	获得一长整形value
int get_value( unsigned long int &i);	获得一无符号长整形value
int get_value( unsigned char WINFAR * ptr, unsigned long &len);	获得一无符号字符数组，返回数据及其长度
int get_value( unsigned char WINFAR * ptr, unsigned long &len, unsigned long maxlen);	获得一指定长度的无符号字符数组，指定长度不超过最大长度。
int get_value( char WINFAR *ptr);	获得一有结束标志符的字符串
Miscellaneous
SmiUINT32 get_syntax();	返回SMI描述
char *get_printable_value();	返回格式化value
char *get_printable_oid();	返回格式化Oid部分
void set_null();	给Vb对象设置一个空value
int valid();	返回一个Vb的有效性
Overloaded Operators
Vb& operator=( const Vb &vb);	把一个Vb付给另一个

14.2. Vb Class的公有成员函数

Vb class提供了许多公有成员函数来访问和修改Vb对象。

// A Vb object may be constructed with no arguments. In this case, the Oid and

// value portions must be set with subsequent member function calls.

// constructor with no arguments

// makes an Vb, un-initialized

Vb::Vb( void);

14.2.1. Vb Class的构造和析构函数

Vb对象可以用一个Oid对象作为构造函数的参数来构造，即把Vb对象的Oid部分初始化为以参数方式传进来的Oid。Vb对象生成了一个传进来的Oid的拷贝，所以程序员不用担心Oid参数的执行期问题。

// constructor to initialize the Oid

// makes a Vb with Oid portion initialized

Vb::Vb( const Oid oid);

Vb对象的析构函数释放了所有占用过的内存和资源。对于定义的静态对象，析构函数是在对象作用域结束时自动调用的。动态分配的实例对象需要用delete来析构。

// destructor

// if the Vb has a Oid or an octet string then

// the associated memory needs to be freed

Vb::~Vb();

14.2.2. Vb Class的Get Oid / Set Oid成员函数

成员函数Get Oid / Set Oid允许获取/设置Vb对象的Oid部分。当SNMP发出gets或者sets操作的时候，变量的指定是通过Vb::set_oid( Oid oid).设置Vb的Oid值来的。相反，Oid部分可以通过成员函数Vb::get_oid( Oid &oid)来获取。成员函数get_oid在SNMP的get next操作中的非常有用。

Vb对象的Oid部分可以用一个已存在的Oid对象来设置

// set value Oid only with another Oid

void Vb::set_oid( const Oid &oid);

Oid部分可以通过提供一个目标Oid对象来检索。这将销毁原先的Oid对象的值。

// get Oid portion

void Vb::get_oid( Oid &oid);

14.2.3. Vb Class的Get Value / Set Value成员函数

成员函数get_value，set_value允许获取或设置Vb对象的value部分。这些成员函数通过重载支持对不同类型的获取和设置。隐藏了获取或设置Vb的内部机制，管理了所有内存的分配和释放。这样，程序员就不用担心SMI-value的结构以及它们的管理。通常在SNMP执行了get后，用成员函数get value来获取Vb对象的value。如果希望在SNMP执行set操作时设置Vb的value的话，成员函数set value就有用了。如果获取的value与Vb所包含的不匹配，则成员函数get_value返回-1。

向Vb对象设置一整形value，作为SMI INT的映射。

// set the value with an int

void Vb::set_value( const int i);

向Vb对象设置一长整形value，作为SMI INT32的映射。

// set the value with a long signed int

void Vb::set_value( const long int i);

向Vb对象设置一无符号长整形value，作为SMI UNIT32的映射。

// set the value with an unsigned long int

void Vb::set_value( const unsigned long int i);

向Vb对象设置一Gauge32对象作为value，该value是SMI 32 bit的映射。

// set the value with a 32 bit gauge

void Vb::set_value( const Gauge32 gauge);

向Vb对象设置一TimeTicks对象作为value，该value是SMI timeticks的映射。

// set the value with a TimeTicks

void Vb::set_value( const TimeTicks timeticks);

向Vb对象设置一Counter32对象作为value，该value是SMI 32 bit counter的映射。

// set value with a 32 bit counter

void Vb::set_value( const Counter32 counter);

向Vb对象设置一Counter64对象作为value，该value用以构成SMI 64 bit counter的32bit的高位部分与低位部分。

// set value to a 64 bit counter

void Vb::set_value( const Counter64 c64);

用一个Oid设置Vb对象的value部分。

// set value for setting an Oid

// creates own space for an Oid which

// needs to be freed when destroyed

void Vb::set_value( const Oid &varoid);

用一个char型的字符串设置一个Vb对象的value部分。事实上，这在内部是用8位字符串作为SMI的value部分，但是当它是一个ASCII字符串（比如系统标识符）时，这种表示却会显得更简单。

// set value on a string

// makes the string an octet

// this must be a null terminates string

void Vb::set_value( const char * ptr);

用一个IP address对象设置Vb的value部分。该成员函数使用了Address class。IP address是SMI value类型的一种。

// set an IPAddress object as a value

void Vb::set_value ( const IpAddress ipaddr);

用一个IPX address对象设置Vb的value部分。该成员函数使用了Address class。IPX address是8位SMI value类型的一种。

// set an IPXaddress object as a value

void Vb::set_value ( const IpxAddress ipxaddr);

用一个MAC address对象设置Vb的value部分。该成员函数使用了Address class。MAC address是8位SMI value类型的一种。

// set an MAC address object as a value

void Vb::set_value ( const MacAddress macaddr);

14.2.4. 用一个GenAdress对象设置value

// set an GenAddress object as a value

void Vb::set_value ( const GenAddress genaddr);

14.2.5. 用一个UdpAdress对象设置value

// set an UdpAddress object as a value

void Vb::set_value ( const UdpAddress udpaddr);

14.2.6. 用一个IpxSockAdress对象设置value

// set an IpxSockAddress object as a value

void Vb::set_value ( const IpxSockAddress ipxsockaddr);

14.2.7. 用一个Octet对象设置value部分

// set the value portion to a SNMP++ Octet object

void Vb::set_value( const OctetStr octet);

14.2.8. Vb Class成员函数：Get Value

所有的成员函数Vb::get_value都会修改传进来的参数。如果一个Vb对象不包含被请求的参数类型，该参数不会被修改，并且将返回SNMP_CLASS_INVALID。否则，如果成功将会返回SNMP_CLASS_SUCCESS的状态。

从Vb对象获得一个整形value

// get value int

// returns 0 on success and value

int Vb::get_value( int &i);

从Vb对象获得一个长整形value

// get the signed long int

int Vb::get_value( long int &i);

从Vb对象获得一个无符号长整形value

// get the unsigned long int

int Vb::get_value( unsigned long int &i);

// get a Gauge32

int Vb::get_value( Gauge32 &gauge);

从Vb对象获得一个Gauge32

从Vb对象获得一个TimeTicks

// get a TimeTicks from a Vb

int Vb:get_value( TimeTicks &timeticks);

从Vb对象获得一个Counter32

// get a counter from a Vb

int Vb::get_value(Counter32 &counter);

从Vb对象获得一个64 bit counter

// get a 64 bit counter

int Vb::get_value( Counter64 &counter64);

从Vb对象获得一个Oid对象

// get the Oid value

// free the existing Oid value

// copy in the new Oid value

int Vb::get_value( Oid &varoid);

从Vb对象获得一个无符号char型字符串（Octet string）

// get a unsigned char string value

// destructive, copies into given ptr of up

// to len length

int Vb::get_value( unsigned char * ptr, unsigned long &len);

从Vb对象获得一个char型字符串。该操作获得octet string部分，并在其后加一空值。

// get a char * from an octet string

// the user must provide space or

// memory will be stepped on

int Vb::get_value( char *ptr);

从Vb对象获得一个IP address对象。IP address是一种Address对象。

// get an IPAddress

int Vb::get_value( IpAddress &ipaddr);

从Vb对象获得一个IPX Address对象。IpxAddress是一种Address对象。

// get an IPXAddress

int Vb::get_value( IpxAddress &ipxaddr);

从Vb对象获得一个MAC Address对象。MacAddress是一种Address对象。

// get an MAC address

int Vb::get_value( MacAddress &MACaddr);

从Vb对象获得一个GenAddress对象。GenAddress是一种Address对象。

// get an gen address

int Vb::get_value( GenAddress &genaddr);

从Vb对象获得一个UdpAddress对象。UdpAddress是一种Address对象

// get an Udp address

int Vb::get_value( UdpAddress &Udpaddr);

从Vb对象获得一个IpxSockAddress对象。IpxSockAddress是一种Address对象

// get an IpxSockAddress

int Vb::get_value( IpxSockAddress &IpxSockAddr);

从Vb对象获得一个Octet对象

// get an Octet object from a Vb

int Vb::get_value( OctetStr, &octet);

14.2.9. Vb 对象的成员函数：Get Syntax

该函数并未遵循面向对象规则。如果要知道对象代表的事物，可以通过该函数返回对象内部的id，但同时也破坏了内部数据的隐藏。如果不考虑数据隐藏的话，有些时候可能还是需要知道Vb内部的value，以便抽取出那些隐藏的value。比如，当实现一个浏览器时需要获取Vb，询问Vb有什么数据并取出Vb包含的数据。该操作所返回的syntax values就是SMI syntax value。

// return the current syntax

// This method violates the OO paradigm but may be useful if

// the caller has a Vb object and does not know what it is.

// This would be useful in the implementation of a browser.

SmiUINT32 get_syntax();

14.2.10.检查Vb对象的有效性

通过调用成员函数Vb::valid()可以检查一个Vb对象的实例的有效性。有效的Vb是那些已经获得了Oid的。

// determine if a Vb object is valid

int Vb::valid();

14.2.11.把Vb对象付给另一个Vb对象

通过重载赋值操作符“＝”，Vb对象可以相互赋值。这种简单的相互赋值避免以下操作：查询一个Vb对象的内容，然后手工将其赋给另一个目标Vb对象。

// overloaded Vb assignment

// assignment to another Vb object overloaded

Vb& operator=( const &Vb vb);

14.2.12.Vb对象的错误信息

当用Vb::get_value()从一个Vb对象获取数据时，由于Vb数据类型与你所请求的数据类型的不一致将导致一个错误的出现。例如，假设一个Vb对象有一个OctetStr对象，你却要求提取TimeTicks对象。由于无法返回TimeTicks ，Vb::get_value()会失败。当错误事件发生时，相应的调用模块使用Vb::get_syntax()来询问Vb的实际值或者错误值。

Vb::get_value() return value	说明
SNMP_CLASS_SUCCESS	成功，返回所请求的值
SNMP_CLASS_INVALID	失败，Vb value没有包含请求的值

14.3. Vb Class例子

下面的例子展示了使用Vb class的不同方法。除了Oid class，Vb class不需要依赖于其他库或模块。以下C++代码是ANSI兼容的。

#include “oid.h”

#include “vb.h”

vb_test()

{

// -------[Ways to construct Vb objects ]-------

// construct a single Vb object

Vb vb1;

// construct a Vb object with an Oid object

// this sets the Oid portion of the Vb

Oid d1(“1.3.6.1.4.12”);

Vb vb2(d1);

// construct a Vb object with a dotted string

Vb vb3( (Oid) “1.2.3.4.5.6”);

// construct an array of ten Vbs

Vb vbs[10];

//------[Ways to set and get the Oid portion of Vb objects ]

// set and get the Oid portion

Oid d2((Oid)“1.2.3.4.5.6”);

vb1.set_oid(d2);

Oid d3;

vb1.get_oid(d3);

if (d2==d3) cout << “They better be equal!!\n”;

Vb ten_vbs[10];

int z;

for (z=0;z<10;z++)

ten_vbs[0].set_oid((Oid)“1.2.3.4.5”);

//-------[ ways to set and get values ]

// set & get ints

int x,y;

x=5;

vb1.set_value(x);

vb1.get_value(y);

if ( x == y) cout << “x equals y\n”;

// set and get long ints

long int a,b;

a=100;

//-------[ ways to set and get values ]

if ( a == b) cout << “a equals b\n”;

// set & get unsigned long ints

unsigned long int c,d;

c = 1000;

vbs[0].set_value( c); vbs[0].get_value( d);

if ( c == d) cout << “c equals d\n”;

// set a 64 bit counter

Counter64 c64(1000,1001);

vbs[1].set_value( c64);

// get and set an oid as a value

Oid o1, o2;

o1 = “1.2.3.4.5.6”;

vbs[2].set_value( o1); vbs[2].get_value( o2);

if ( o1 == o2) cout << “o1 equals o2\n”;

// set and get an octet string

unsigned char data[4],outdata[4];

unsigned long len,outlen;

len =4; data[0] = 10; data[1] = 12; data[2] = 12; data[3] = 13;

OctetStr octetstr(data,len);

vbs[3].set_value( octetstr);

vbs[3].get_value( octetstr);

// get & set a string

char beer[80]; char good_beer[80];

strcpy( beer,”Sierra Nevada Pale Ale”);

vbs[4].set_value( beer);

vbs[4].get_value( good_beer);

printf(“Good Beer = %s\n”,good_beer);

// get and set an ip an address

IpAddress ipaddress1, ipaddress2;

ipaddress1 = “10.4.8.5”;

vbs[5].set_value( ipaddress1);

vbs[5].get_value( ipaddress2);

cout << ipaddress2;

} // end vb example

15. Pdu Class

SNMP++之Pdu Class的对象模型（Object Modeling Technique）视图

SNMP++的Pdu class是SMI Protocol Data Unit (PDU)的C++封装。PDU是管理端和代理端进行SNMP通讯的基本概念。通过Pdu class，SNMP++使得对PDU的操作变得简单、安全。Pdu class允许简单的构造、析构，以及在Pdu对象上加载、卸载Vb对象。因为SNMP++是双效的API，所以Pdu class也是抽象化的，并没有包含SNMPv1或者SNMPv2的特征性的信息。所有发出请求的Snmp class成员函数都可以只使用一个Pdu对象。Pdu class作为Snmp class的接口，处理SNMP请求，同时还可作为异步请求和接收notification的回调函数的参数。注意，关于对Vb的存储，Pdu对象是从0开始的（Pdu中第一个vb是Vb #0）。

大多数地方，SNMP++中的所有Pdu对象都是一样的。即，所有的Pdu对象都有同一性（identity）。唯一的例外是当Pdu对象被用作发送otifications , traps和informs的时候。为了支持notifications，有3个附加的Pdu Class成员函数来用作：设置同一性（identity）、时间信息，及Pdu对象的enterprise。

15.1. Pdu Class成员函数列表

Pdu Class Member Functions	说明
Constructors
Pdu::Pdu( void);	构造一个空的Pdu
Pdu::Pdu( Vb* pvbs, const int pvb_count);	用一个数组类型的Vb及其长度构造一个Pdu
Pdu::Pdu( const Pdu &pdu);	用一个Pdu构造另一个
Member Functions
int get_vblist( Vb* pvbs, const int pvb_count);	把Vb拷贝到调用的参数列表中（vblist）
int set_vblist( Vb* pvbs, const int pvb_count);	设置Pdu调用的参数列表中的Vb
int get_vb( Vb &vb, const int index);	获取Pdu中一个指定的Vb
int set_vb( Vb &vb, const int index);	为Pdu设置一个指定的Vb
int get_vb_count();	获取Pdu中Vb的个数
int get_error_status();	获取Pdu的错误状态
int get_error_index();	获取Pdu的错误索引
unsigned long get_request_id();	获取Pdu的请求标示
unsigned short get_type();	获取Pdu的类型
int valid();	判断Pdu的有效性
Int delete_vb( const int position);	删除Pdu指定位置上的Vb
int trim(const int i=1);	删除Pud最后位置上的Vb，默认删除1个
Member Functions For Inform and Trap Usage
void set_notify_timestamp( const TimeTicks ×tamp);	为trap或inform的Pdu设置时间信息
void get_notify_timestamp( TimeTicks & timestamp);	从trap或inform的Pdu获取时间信息
void set_notify_id( const Oid id);	设置trap或inform的Pdu的ID
void get_notify_id( Oid &id);	获取trap或inform的Pdu的ID
void set_notify_enterprise( const Oid &enterprise);	设置trap或inform的Pdu的enterprise ID
void get_notify_enterprise( Oid & enterprise);	获取trap或inform的Pdu的enterprise ID
Overloaded Operators 重载操作符
Pdu& operator=( const Pdu &pdu);	将一个Pdu付给另一个
Pdu& operator+=( Vb &vb);	给一个Pdu增加一个Vb

15.2. Pdu Class的构造和析构

有多种方法构造Pdu对象，可以有也可以没有构造参数

// constructor, no args

Pdu::Pdu( void);

// constructor with Vbs and count

Pdu::Pdu( Vb *vbs, const int vb_count);

// constructor with another Pdu instance

Pdu::Pdu( const Pdu &pdu);

// destructor

Pdu::~Pdu();

15.3. 访问Pdu的成员函数

Pdu class通过多种成员函数来支持获取和设置Pdu成员变量。包括获取和设置“绑定变量”、错误信息、请求信息，和类型信息。

// extract all the Vbs from a Pdu

int Pdu::get_vblist( Vb* vbs, const int vb_count);

// deposit Vbs to a Pdu

int Pdu::set_vblist( Vb* vbs, const int vb_count);

// get a particular vb

// where index 0 is the 1st vb

int Pdu::get_vb( Vb &vb, const int index);

// set a particular Vb

// where index 0 is the 1st Vb

int Pdu::set_vb( Vb &vb, const int index);

// return the number of Vbs

int Pdu::get_vb_count();

// return the error index

int Pdu::get_error_index();

// get the error status

int Pdu::get_error_status();

// return the request id

unsigned long Pdu::get_request_id();

// get the Pdu type

unsigned short Pdu::get_type();

// return the validity of a Pdu

int Pdu::valid();

15.4. Pdu Class重载操作符

Pdu class可通过重载操作符，赋值或串连Vb对象到Pdu。

// assignment operator for assigning one Pdu to another

Pdu& operator=( const Pdu &pdu);

// append a Vb object to the Pdu’s var bind list

Pdy& operator+=( Vb vb);

15.5. Pdu Class处理Traps和Informs的成员函数

当处理notifications, traps和informs的时候，SNMP++提供了成员函数来获取和设置指定的notification value。当使用这些成员函数时，请查阅发送traps和informs的部分。

// set notify timestamp

void Pdu::set_notify_timestamp( const TimeTicks & timestamp);

// get notify timestamp

void Pdu::get_notify_timestamp( TimeTicks & timestamp);

// set the notify id

void Pdu::set_notify_id( const Oid id);

// get the notify id

void Pdu::get_notify_id( Oid &id);

// set the notify enterprise

void Pdu::set_notify_enterprise( const Oid &enterprise);

// get the notify enterprise

void Pdu::get_notify_enterprise( Oid & enterprise);

15.6. 加载Pdu对象

为了在管理应用中使用Pdu对象，必须在Pdu实例中加载“绑定变量表”（vblist）。这可以通过从多种方法中选择你需要的来处理。一般在发送SNMP请求前加载Pdu。

// set notify timestamp

void Pdu::set_notify_timestamp( const TimeTicks & timestamp);

// get notify timestamp

void Pdu::get_notify_timestamp( TimeTicks & timestamp);

// set the notify id

void Pdu::set_notify_id( const Oid id);

// get the notify id

void Pdu::get_notify_id( Oid &id);

// set the notify enterprise

void Pdu::set_notify_enterprise( const Oid &enterprise);

// get the notify enterprise

void Pdu::get_notify_enterprise( Oid & enterprise);

15.7. 加载Pdu对象

// example of how to load a Pdu object

void load_pdu_examples()

{

Pdu pdu; // create a Pdu object

Vb vb; // create a Vb object

vb.set_oid( SYSDECR); // set the oid portion of the Vb to System Descriptor

pdu += vb; // loads the Vb to the Pdu

Pdu my_pdu; // create another Pdu object

Vb vbs[5]; // create 5 vbs

pdu.set_vblist( vbs,5); // load all 5 to the pdu

}

15.8. 卸载Pdu对象

从阻塞或异步请求中得到请求的Pdu后，都需要将Vb卸载下来才能把SMI values取出。

// example of how to unload a Pdu

void unload_pdu_example( Pdu &pdu)

{

ins staus;

Pdu pdu; // create a Pdu object

Vb vb; // create a Vb object

vb.set_oid( SYSDECR); // set the oid portion of the Vb to System Descriptor

pdu += vb; // loads the Vb to the Pdu

char message[100]; // for the system descriptor printable octet

Snmp snmp( status);

if ( status != SNMP_CLASS_SUCCESS) {

cout < “SNMP++ error = “ << snmp.error_msg( status) ;

return;

}

pdu.get_vb( vb,0); // unload the vb

vb.get_value( message); // pull the message out of the vb

cout << message; // print it out

};

16. SnmpMessage Class

SnmpMessage Class允许对SNMP++对象使用抽象编码规则（ASN.1）和基础编码规则（BER）来编码和解码，进而生成可以在线路上传送的SNMP消息。该class可以方便的串行化Pdu对象，以便于后期的各种使用。大多数SNMP++的用户不需要使用这个类，因为Snmp class已经完成了这项任务，包括管理超时和重发。但是如果程序员想对消息编码，这里也为其提供一种选择，例如很多代理系统就在使用它们自己的传输层。SnmpMessage class提供的各种成员函数如下表所示：

SnmpMessage Class Member Functions	说明
Constructors
SnmpMessage::SnmpMessage( void);	构造一个空的SnmpMessage对象
Member Functions
int load( Pdu pdu, OctetStr community, snmp_version version);	用Pdu、团体名、版本加载一个SnmpMessage对象。版本可以是SNMPv1或2。返回错误状态。
int load( unsigned char * data, unsigned long en);	用原始数据流加载一个SnmpMessage对象。当从线路上收取数据报并通过把它加载到一个SnmpMessage对象来实现解码时，该函数很有用。
int unload( Pdu &pdu, OctetStr &community, snmp_version &version);	卸载一个已经加载过的SnmpMessage对象。由此可以获得Pdu、团体名、版本
unsigned char * data();	通过原始的ASN.1/BER串行化数据缓冲区。该缓冲区的范围可以通过成员函数::len()获得
unsigned long len()	返回原始数据缓冲区的范围
int valid();	判断一个SnmpMessage对象的有效性

17. Target Class

Target class是一个C++类，在SNMP++中用它来定义和使用target。一个target在SNMP通讯中，可以想象成一个代理端的管理层的概念，它由多个网络地址组成。Targets包含了重发和超时机制的信息，还有SNMP协议类型（SNMPv1和SNMPv2）等等。目前已有的Targets唯一的子类是Community-based CTarget。CTarget class可用在SNMPv1和SNMPv2的通讯上，由此可以重用你已有的代码到SNMPv2通讯中，不需要做修改。通过它，还可以使得一个SNMP++会话与某个特定的代理端的属性无关。

17.1. 抽象的Target

SNMP++支持抽象Target的概念。由该抽象Target可以操作所有实际的Target派生类。所有使用Target的SNMP++成员函数接收的都是抽象Target，而不是特指的派生Target对象。当需要支持新的Target时，这种抽象的接口可以减小代码的改动。

17.2. Target地址

每个target都与一个地址对象（Address object）相关联。该地址是一个GenAddress，因此可以处理所有SNMP++地址（IP, IPX或其他）。为指明被管理的代理端地址并与一个Target相关联，只需要简单地通过构造函数的参数或成员函数就可实现。

17.3. 重发机制

每个Target都具有重发机制，在该机制中定义了超时和重发。由该重发机制可指定等待一个SNMP应答的周期，以及当没有收到一个SNMP应答时进行多少次重发。超时的最小单位被定义成百分之一秒，即当取值为100代表每个应答等待1秒。重发时记录了重发的次数，注意，第一次请求不属于重发，只是发送。所以重发值取3，表示当等待一个应答时最多可以重发3次。等待的总时间可以用下列式子计算：Total Wait Time = time-out * (retry+1)

如果一个SNMP++应答没有在上式所计算出来的等待总时间内到来，将会返回一个SNMP++超时的错误号。该操作在阻塞和异步两种调用中都可使用。

17.4. Target Class接口

Target Class Member Functions	说明
Constructors
CTarget::CTarget( void);	构造一个无效的CTarget。重发机制的默认值：community names ＝“public”， retry=1，time_out=1。
CTarget::CTarget(const Address &address , const char read_community_name, const char write_community_name,	用community names和Address object构造一个CTarget。重发机制的默认值：retry=1，time-out =100ms。
CTarget( const Address &address const OctetStr &read_community_name, const OctetStr &write_community_name);	用OctetStr Communities和Address构造一个CTarget
CTarget::CTarget( Address &address);	用Address object构造一个CTarget。重发机制的默认值：community names ＝“public”， retry=1，time_out=1。
CTarget::CTarget( const CTarget &target);	拷贝构造函数
Destructor
CTarget::~CTarget();	删除CTarget对象，释放所有资源。
Member Functions
char * get_readcommunity();	返回读权限的community名称
void get_readcommunity( OctetStr& read_community_oct);	获取OctetStr格式的读权限community
void set_readcommunity( const char * get_community);	设置读权限community
void set_readcommunity( const OctetStr& read_community);	用一个OctetStr设置读权限community
char * get_writecommunity();	获取写权限community
void get_writecommunity( OctetStr &write_community_oct);	获取OctetStr格式的写权限community
void set_writecommunity( const char * new_set_community);	设置写权限community
void set_writecommunity( const OctetStr& write_community);	用一个OctetStr设置写权限community
int get_address( GenAddress &address);	获取Address object.
void set_address( Address &address);	设置Address部分
CTarget& operator=( const CTarget& target);	把一个CTarget赋给另一个。
snmp_version get_version();	返回SNMP版本（version1或version2）
void set_version( const snmp_version v);	设置版本（version1或version2）
int operator==( const CTarget &lhs, const CTarget &rhs);	比较两个CTargets
Abstract Class Member Functions
int valid();	返回一个Target的有效性
void set_retry( const int r);	设置重发值
int get_retry();	获取重发值
void set_timeout( const unsigned long t);	设置超时值
unsigned long get_timeout();	获取超时值

17.5. CTarget Class (以Community为基础的Target)

CTargetclass允许显示地定义以Community为基础的Target。一个CTarget用以SNMP Community为基础的Target定义了一个SNMP代理端。这包含了“读权限、写权限”的community names and an address。地址是用SNMP++ Addressclass来表示的，所以该地址可以是IP或者IPX address（Addressclass是个抽象基类，所以可以实现多态操作）。CTarget class使用前提应该是：应用开发者明确地知道代理端所支持的以SNMP community为基础的访问方式，即SNMPv1或SNMPv2。

17.5.1. CTarget对象可通过3种不同的方式构建

// ----------[ instantiating CTarget Objects ]-----------------------------

// valid complete instantiation

CTarget ct((IpAddress)”10.10.10.10”, // Address

“public”, // read community name

“public”); // write community name

// valid complete using “public” defaults

CTarget ct( (IpAddress) “1.2.3.4”);

// invalid CTarget

CTarget ct;

17.5.2. 修改CTargets

//----[ modifying CTargets ]------------------------------------

ct.set_readcommunity(“private); // modifying the read community

ct.set_writecommunity(“private”); // modifying the write community

ct.set_address( (IpAddress) “15.29.33.210”);

17.5.3. 访问CTargets

//-----[ Accessing CTarget member variables ]-------------------------

// get the write community name

cout << “Write community” << ct.get_writecommunity();

// get the read community name

cout << “Read community ” << ct.get_readcommunity();

// get the address

GenAddress address;

ct.get_address( address);

// check the validity of a target

if ( ct.valid())

cout << “Target is valid”;

17.5.4. CTargets例子

//------------[CTarget class examples ]-----------------------------------------------------------------

// create a valid CTarget using a GenAddress

CTarget ct( (GenAddress) “10.20.30.40”);

// create a valid CTarget using an IpxAddress

IpxAddress ipxaddress(“01010101-010101010101”);

CTarget my_target( ipxaddress); // use default “public” for communities

// create an invalid CTarget object

CTarget ct; // no construction params therefor invalid

if ( !ct.valid())

cout << “Invalid CTarget instance!”;

// get the read community

cout << “Read Community =” << ct.get_readcommunity();

// get the write community

cout << “Write Community = ” << ct.get_writecommunity();

// modify the get community

ct.set_readcommunity( “pilsner”);

// modify the write community

ct.set_writecommunity(“pale ale”);

18. Snmp Class

SNMP++之Snmp Class的对象模型（Object Modeling Technique）视图

Snmp class是SNMP++中最为重要的类。Snmp class封装了SNMP的会话。通过处理与指定代理端的会话，SNMP++实现了对网络管理应用的逻辑绑定。会话所控制的是PDU的构建、分发、接受。其他大多数API需要程序员直接操作会话，也即需要提供可靠的传输机制来控制超时、重发、查重。Snmp class管理了大部分的会话，得到解放的程序员只需要关注于代理端的管理，方便了代码的开发和测试。如果不这样（没有SNMP++），你就只有去设计、实现、测试你自己的SNMP引擎。那么Snmp class是如何管理通信的呢：1、在UDP或IPX连接基础上管理传输层；2、负责打包和解包PDU中的绑定变量；3、分发和接收PDU；4、管理所有SNMP所需的资源。

Snmp class使用简单。它为网络管理应用提供了6种基本操作：Snmp::get, Snmp::set, Snmp::get_next, Snmp::get_bulk, Snmp::inform() 和 Snmp::trap()，每种操作都可分为阻塞和非阻塞（异步）两种方式。当有多个异步的操作同时申请通信时，需要采用多重通信。发送Notification的处理是通过Snmp::trap() 和 Snmp::inform()，即“陷阱”和“通知”的发送；接收标志信息的处理是通过Snmp::notify_register() 和 Snmp::notify_unregister()，即“陷阱”和“通知”的接收。

Snmp class使用安全。构造函数和析构函数完成了对所有资源的加载和卸载，从而减小了内存的崩溃和泄漏的可能性。所有SNMP的内部机制都隐藏起来了，也就避免了不小心而修改到这些内部机制。

Snmp class可移植。对操作系统和网络系统而言，Snmp class的接口是可移植的。绝大多数SNMP++的类都可以在任何ANSI / ISO C++编译器上编译和使用。只需要修改少量代码，就可以实现对SNMP++的平台切换。

18.1. Snmp Class成员函数列表

Snmp Class Member Functions	说明
Constructor
Snmp::Snmp( int &status);	构造一个Snmp对象，status定义的是成功状态
Destructor
Snmp::~Snmp( );	销毁，释放所有资源，关闭会话
Member Functions
char * error_msg( const int status);	返回所给错误状态的文本字符串
int get( Pdu &pdu, SnmpTarget &target);	调用阻塞方式的SNMP get。从target获取Pdu
int set( Pdu &pdu, SnmpTarget &target);	调用阻塞方式的SNMP set。对target设置Pdu
int get_next( Pdu &pdu, SnmpTarget &target);	调用阻塞方式的SNMP get next。针对target上的Pdu
int get_bulk( Pdu &pdu, SnmpTarget &target, const int non_repeaters, const int max_reps);	调用阻塞方式的SNMP get bulk（但是V2 targets只使用get-next）
int inform( Pdu &pdu, SnmpTarget &target);	调用阻塞方式的inform
int get( Pdu &pdu, SnmpTarget &target, snmp_callback callback, void * callback_data=0);	调用SNMP异步get。从target获取Pdu，需要用到用户定义的回调和回调的参数
int set( Pdu &pdu, SnmpTarget &target, snmp_callback callback, void * callback_data=0);	调用SNMP异步set。对target设置Pdu，需要用到用户定义的回调和回调的参数
int get_next( Pdu &pdu, SnmpTarget &target, snmp_callback callback, void * callback_data=0);	调用SNMP异步get next。从target获取下一个Pdu，需要用到用户定义的回调和回调的参数
int get_bulk( Pdu &pdu, SnmpTarget &target, const int non_repeaters, const int max_reps snmp_callback callback, void * callback_data=0);	调用SNMP异步get bulk。从target获取批量Pdu，需要用到用户定义的回调和回调的参数
int inform( Pdu &pdu, SnmpTarget &target, snmp_callback callback, void * callback_data=0);	调用异步inform。需要用到notify的回调。
int trap( Pdu &pdu, SnmpTarget &target);	向指定的target发送一个trap
int notify_register( TargetCollection &targets, OidCollection &trapids, snmp_callback callback, void * callback_data=0);	对接收trap和inform的操作注册
int notify_register( TargetCollection &targets, OidCollection &trapids, AddressCollection &listen_addresses, snmp_callback callback, void * callback_data=0);	对接收trap和inform的操作注册，并用AddressCollection指出监听的接口。
int notify_unregister();	撤消对接收trap和inform的操作注册
int cancel( const unsigned long rid);	取消针对所给请求id的异步请求的等待

18.2. 双效的API

所有的Snmp class成员函数都是双效的。这就是说对于SNMP version 1或version 2c，他们可以使用统一的参数表。这解放了程序员，因为程序员不用为了与SNMP version 2的代理端通讯而去修改代码。

18.3. Snmp Class的公共成员函数

通过Snmp Class提供的许多成员函数可以创建、管理、终结一个会话。多个Snmp对象可以在同一时间建立。

18.3.1. Snmp Class的构造和析构函数

Snmp Class的构造和析构函数允许开启和关闭会话。通过构建一个Snmp对象来开启一个Snmp会话。由此可对UDP或IPX套接口实现构建和管理，直到对象被销毁。Snmp对象可选择被动态或静态的实例化。

18.3.2. Snmp Class构造函数

该构造函数以参数方式返回状态（status）。因为C++的构造函数没有返回值，调用者必须提供一个状态值（status）以供实例化对象后针对状态的检查。调用者需要检查返回值是否是“SNMP_CLASS_SUCCESS”。如果构造函数的状态不表示成功，该会话也就不可用。

// constructor, blocked SNMP object

Snmp::Snmp( int &status); // construction status

18.3.3. Snmp Class析构函数

Snmp Class的析构函数关闭相应的会话，并释放所有资源和内存

// destructor

Snmp::~Snmp();

18.3.4. Snmp Class发送请求的成员函数

为了访问或修改代理端的MIB，请求必须通过Snmp::get(), Snmp::set(), Snmp::get_next(), Snmp::get_bulk(), Smnp::inform()以及Snmp::trap()来发送。所有这些成员函数接受同样的参数表。

18.3.5. Snmp Class的阻塞方式成员函数： Get

阻塞方式的成员函数get允许从指定target的代理端获取对象。调用者必须指定目标target以及要请求的Pdu。

//--------[ get ]-------------------------------------------

int Snmp::get( Pdu &pdu, // Pdu to get

SnmpTarget &target); // specified target

18.3.6. Snmp Class的阻塞方式成员函数： Get Next

阻塞方式的成员函数get next可以用来遍历代理端的MIB。

//---------[ get next ]--------------------------------------

int Snmp::get_next( Pdu &pdu, // Pdu to get next

SnmpTarget &target); // specified target

18.3.7. Snmp Class的阻塞方式成员函数： Set

阻塞方式的成员函数set允许设置代理端的对象

//---------[ set ]--------------------------------------------

int Snmp::set( Pdu &pdu, // Pdu to set

SnmpTarget &target); // specified target

18.3.8. Snmp Class的阻塞方式成员函数： Get Bulk

SNMP++为SNMP version 1和version 2的Target提供了一个获取批量数据的接口。在SNMP version 1中的相应操作对应到成员函数get next。

//--------[ get bulk ]-------------------------------------------

int Snmp::get_bulk( Pdu &pdu, // pdu to get_bulk

Target &target, // destination target

const int non_repeaters, // non repeaters

const int max_reps); // maximum reps

18.3.9. Snmp Class的阻塞方式成员函数：Inform

SNMP++提供了一个Inform接口，由此可直接在V2的代理端和网管端内部之间发送消息。

//-----------[ inform ]----------------------------------------------------------

int Snmp::inform( Pdu &pdu, // pdu to send

SnmpTarget &target); // destination target

为一个Inform指定其Id

Inform ID的指定方法与trap ID一样。可通过用成员函数Pdu::set_notify_id()来为一个inform的PDU指定其ID。Inform标识符ID代表了其使用的Oid。为了建立Inform ID，可以用需要的Inform ID值来直接建立一个Oid对象，然后用成员函数Pdu::set_notify_id()把一个Pdu加载在其上。反过来，一个inform的ID可以用成员函数Pdu::get_notify_id()来获取。

在Inform上指定TimeStamp时间信息

要给一个inform PDU指定时间信息，可用成员函数Pdu::set_notify_timestamp()。如果一个Pdu没有用该成员函数就发出去了，那么会使用一个来自SNMP++引擎默认的timestamp。

18.4. Snmp Class的异步方式成员函数

一个Snmp实例可以支持阻塞与异步两种方式的请求。异步请求将会立即返回所控制的线程，并不需要等待呼叫者的应答。为了达到该目的，使用了所谓的回调程序机制。当发出异步请求时，调用者必须指定回调函数，还可选择性的指定一个回调函数的参数。

18.4.1. SNMP++异步回调函数的类型定义

typedef void (*snmp_callback)( int, // reason

Snmp*, // session handle

Pdu &, // Pdu passed in

SnmpTarget &, // source target

void * ); // callback data

18.4.1.1. 回调的参数说明

Reason(s) , int

该整形的原因参数描述了调用回调的原因。回调被调用的原因包括以下几种：

SNMP_CLASS_ASYNC_RESPONSE：收到了一个SNMP应答。这可以是一个来自get, set, get-next, get-bulk或inform的应答。用Pdu参数保存实际应答的PDU，用SnmpTarget参数保存发送应答的target。

SNMP_CLASS_TIMEOUT：一个SNMP++请求超时，该请求由target实例提供的超时与重发信息的机制来处理。为了重用，用 Pdu参数保存Pdu请求的原值，用SnmpTarget参数保存target的原值。

SNMP_CLASS_SESSION_DESTROYED：会话被销毁，此时所有正在等待的异步请求都不会完成。

SNMP_CLASS_NOTIFICATION：收到一个notification, trap或inform请求。Pdu对象会保存实际的notify，通过Pdu成员函数Pdu::get_notify_id(), Pdu::get_notify_timestamp()和Pdu::get_notifty_enterprise()来获得notification id, timestamp和enterprise。

Snmp++ Session, Snmp*

该参数保存发送请求的会话的值。由此可以在time-out或get-next情况下实现会话的重用。

Response PDU, Pdu&

该参数为esponse, notifie和trap保存了“应答 Pdu”。当“原因”（ reason参数）为“失败”时，Pdu参数保存了“请求 Pdu”的原值。一旦Pdu对象越界，其值就不可得了。

Target , SnmpTarget&

该参数为response, notifie和trap保存了Pdu的来源。如果“原因”（ reason参数）为“失败”，当有请求发出时，target的原值就会被用到。

Callback data ,void *

当有请求发出时，回调的参数可以作为一个可选的参数提供。如果指定了该参数，将会返回相关信息。如果没有指定，该值取空（null）。

18.4.2. 取消一个异步请求

SNMP++允许在完成之前取消相应的异步请求。这很有用，尤其当你需要在代码中提前退出或指定的回调已经失效的时候。当Snmp对象发出的请求被销毁时，异步请求会自动取消，这时指定的回调会收到一个“SNMP_CLASS_SESSION_DESTROYED”的原因。另一方面，可以用成员函数Snmp::cancel()来取消单个的异步请求。该成员函数通过参数request_id无影响的取消对应的异步请求。

//-------------[ cancel a request ]-----------------------------------

int Snmp::cancel( const unsigned long rid);

18.4.3. Snmp Class的异步成员函数：Get

异步get允许从指定的代理端获取SNMP对象。当“请求PDU”发出后，异步get调用就会返回，它不会等待“应答PDU”。当收到“应答PDU”时，会调用程序员定义的回调。在回调中，可以用任何喜欢的方式实现有效的应答。

//------------------------[ get async ]----------------------------------

int Snmp::get ( Pdu &pdu, // Pdu to get async

SnmpTarget &target, // destination target

snmp_callback callback, // async callback

void * callback_data=0); // callback data

18.4.4. Snmp Class的异步成员函数：Set

异步成员函数set的工作方式与get雷同。

//------------------------[ set async ]----------------------------------

int Snmp::set( Pdu &pdu, // Pdu to set async

SnmpTarget &target, // destination target

snmp_callback callback, // async callback

void * callback_data=0); // callback data

18.4.5. Snmp Class的异步成员函数：Get Next

异步成员函数get-next的工作方式与异步get和set雷同。

//------------------------[ get next async ]-----------------------------

int Snmp::get_next( Pdu &pdu, // Pdu to get_next

SnmpTarget &target, // destination

snmp_callback callback, // async callback

void * callback_data=0); // callback data

18.4.6. Snmp Class的异步成员函数：Get Bulk

异步成员函数get- bulk的工作方式与异步get和set雷同。

//------------------------[ get bulk async ]-----------------------------

int Snmp::get_bulk(Pdu &pdu, // Pdu to get_bulk async

Target &target, // destination target

const int non_repeaters, // non repeaters

const int max_reps, // max repetitions

snmp_callback callback, // async callback

void * callback_data=0); // callback data

18.4.7. Snmp Class的异步成员函数：Inform

//--------------------[ inform async ]----------------------------------------

int Snmp::inform( Pdu &pdu, // pdu to send

SnmpTarget &target, // destination target

snmp_callback callback, // callback function

void * callback_data=0); // callback data

18.5. SNMP++通知的方法

SNMP++ API支持收发trap的成员函数

18.5.1. 发送Trap

发送trap的函数是一个有用的管理程序（manager）API。可用函数与其他管理端进行通讯。

//-----------------------[ send a trap ]----------------------------------

int Snmp::trap( Pdu &pdu, // Pdu to send

SnmpTarget &target); // destination target

18.5.1.1. 发送Trap的成员函数的参数说明

Pdu &pdu

要发送的Pdu，它是trap所包含的有效负载。

SnmpTarget &target

发送Trap的目的地

指定一个Trap的Id

Trap Id的指定方式与Inform Id一样。可用成员函数Pdu::set_notify_id()来指定trap PDU的ID。Trap标识符ID在SMI SNMPv2中是以Oid表示的。SNMP++预定义了以下6种通用的trap Oid。只需用想要的trap id值来赋给一个Oid对象就可以生成一个trap id。相反的，可用成员函数Pdu::get_notify_id()来获取trap id。

SNMP++为通用Trap ID定义的Oid对象

coldStart ("1.3.6.1.6.3.1.1.5.1”)

warmStart ("1.3.6.1.6.3.1.1.5.2”)

linkDown ("1.3.6.1.6.3.1.1.5.3”)

linkUp ("1.3.6.1.6.3.1.1.5.4”)

authenticationFailure ("1.3.6.1.6.3.1.1.5.5”)

egpNeighborLoss ("1.3.6.1.6.3.1.1.5.6”)

如果要发送某个企业指定的trap，调用者可能需要指定一个除上面以外的Oid。

指定Trap的时间信息

可用成员函数Pdu::set_notify_timestamp()来指定trap PDU的时间信息。如果一个Pdu没调用这个成员函数就发送了，那么会使用一个来自SNMP++引擎的时间信息。

18.5.1.2. 指定Trap Enterprise

不用被企业指定的trap困扰，任何trap的企业都代表了产生trap的代理端的MIB。对trap的发送者来说它是系统标识符（System Object Identifier），但是从理论上讲它可以表示任何Oid的值。为了设置该参数，SNMP++允许使用成员函数Pdu::set_notify_enterprise()来设置enterprise，而且这个参数是可选的。如果使用了所提供的enterprise，该enterprise会加载在对应的Pdu对象上。

18.5.1.3. 给SNMPv1 Trap指定特殊的Trap值

为了给SNMPv1 Trap指定特殊的Trap值，trapid的Oid应该构造如下：trapid 的最末子id（subid）代表指定的要使用的值；倒数第二个子id应该是零。即，为了指定特殊的Trap值，需要添加两个额外的子id，一个是零、一个是值（“0.X”）。这个约定与规定SNMPv1和SNMPv2trap映射的RFC 1452的描述一致。

18.5.2. 接收Notification

接收SNMP++ trap和inform的时候，允许应用程序使用指定的过滤器来接收trap和inform。不像其他的SNMP操作，trap和inform是在任何可能出现的时候主动发出的。因此informs和traps属于异步的动作。通过SNMP++提供的成员函数，调用者可以指定informs和traps的过滤器。可用informs和traps的类型、来源和目标来过滤informs和traps。

//-----------------------[ register to receive traps and informs]-------------------------------------------

// default form listens on all local interfaces using well known port/ socket #’s

int Snmp::notify_register(OidCollection &ids, // types to listen for

TargetCollection &targets, // targets to listen for

snmp_callback callback, // callback to use

void *callback_data=0); // optional callback data

//------------------------[ register to receive traps and informs ]----------------------------------------

// alternate form, AddressCollection allows local listen interface specification

int Snmp::notify_register(OidCollection &ids, // types to listen for

TargetCollection &targets, // targets to listen for

AddressCollection &local_interfaces, // interfaces to listen on

snmp_callback callback, // callback to use

void *callback_data=0); // optional callback data

//-----------------------[ un-register to get traps and informs]------------------------------------------

int Snmp::notify_unregister();

18.5.2.1. 注册Trap和Inform

每个Snmp class实例可以为它们自己的traps / informs注册。也就是说，一个Snmp对象可以有它自己的一套过滤器和回调，当收到的trap或inform满足过滤条件时就会调用。当每个新的呼叫清理了先前的过滤器设置时，成员函数Snmp::notify_register()可能会多次被调用。当调用成员函数Snmp:notify_unregister()或Snmp实例撤消时，相应的接收Trap / inform的会话将会终止。

18.5.2.2. Snmp::notify_register()的基本形式

notification的注册基本形式中包括：notification类型、notification来源、过滤参数、OidCollection和TargetCollection。使用该形式的notify_register()会在所有本地端口上触发notification的监听。所以如果本地机器有多重初始地址，即它会有多重网络接口，所有的接口将会被开启，并使用已知的port / socket来接收notify。例如：如果我的机器是双网卡的，两个卡都支持IP（Internet Protocol）协议，其中一个还支持IPX（Internet Exchange Protocol）协议；如果调用基本形式的notify_register()，则会在两个IP接口上使用已知的SNMP trap端口，在IPX接口上使用已知的trap IPX套接字（socket number）。

18.5.2.3. Snmp::notify_register()的备用形式

作为备用，重载形式的notify_register()可接受一个附加参数，进而允许指定本地接口来监听inform或AddressCollection。AddressCollection参数包含了一组需要监听的Address对象列表，包括：IpAddresses, IpxAddresses, UdpAddresses 和 IpxSockAddresses。下表描述了AddressCollection以及notify_register()的运作方式：

AddressCollection Element Behavior Definition

Address Class	Value	说明
IpAddress	Any value except 0.0.0.0	用已知的IP端口监听指定的IP接口
IpAddress	0.0.0.0	用已知的IP端口监听所有IP接口
UdpAddress	Any value except 0.0.0.0	用已知的UDP端口监听指定的UDP接口
UdpAddress	0.0.0.0	用已知的UDP端口监听所有UDP接口
IpxAddress	Any value except 00000000:000000000000	用已知的IPX端口监听指定的IPX接口
IpxAddress	00000000:000000000000	用已知的IPX端口监听所有IPX接口
IpxSockAddress	Any value except 00000000:000000000000	用已知的IPX套接字监听指定的IPX接口
IpxSockAddress	00000000:000000000000	用已知的IPX套接字监听所有IPX接口

18.5.2.4. notify_regsiter()的过滤功能

当需要过滤时，过滤器的行为如下：如果收到的inform或trap与OidCollection中的id单元（item）一致，并且收到的inform或trap与TargetCollection中的单元一致，则相应的inform / trap会被送到调用者指定的回调中。注意，如果OidCollection为空，则所有的inform都将通过id检查，同样的，如果TargetCollection为空，则所有的inform都将通过Target检查。

18.5.3. 使用OidCollection, TargetCollection和AddressCollections过滤

SNMP++提供了3种有序集合的collection classe，共同来收集Oids, Targets和Addresses。所有collection classe操作形式都一样，因为它们是从同样的C++模板类SnmpCollection派生来的。统一的集合操作如下：

Target and Oid Collection Class Member Functions	说明
Constructors
SnmpCollection::SnmpCollection(void);	构造一个空的集合
SnmpCollection::SnmpCollection(const T &t );	用单一元素构造一个集合
Destructors
SnmpCollection::SnmpCollection();	销毁集合，释放所有资源
Member Functions
int size();	返回集合的大小
SnmpCollection & operator += ( T &t);	增加一个元素到集合
SnmpCollection & operator = (SnmpCollection &collection);	将一个集合赋给另一个
T& operator[]( int p);	访问集合中的一个元素
int set_element( const T& i, const int p);	在集合种设置一个已有的元素
int get_element( T& i, const int p);	从集合获取一个元素

18.5.3.1. 生成并使用集合作为过滤器

生成并使用SnmpCollections作为接收一个trap / inform的过滤器是简单而直接的。Notify的注册函数有3个参数：TargetCollection, OidCollection和AddressCollection。要构造这些过滤器，首先得实例化一个集合，然后用重载的操作符“+=”把元素加入其中。

// example of making trap reception filters

// target collection

TargetCollection my_targets;

my_targets += cisco_router;

my_targets += fore_switch;

// Oid collection

OidCollection my_trapids;

my_trapids += coldStart;

my_trapids += warmStart;

// Address collection

AddressCollection my_addresses;

my_addresses += (IpAddress) “10.4.8.5”;

my_addresses += (GenAddress) “01020304:010203040506”;

18.6. SNMP++ Class返回的错误号

使用SNMP++时，可返回多种错误编号。这些错误号可穿越平台，进而帮助应用的开发者发现并检查错误条件。

18.6.1. Snmp Class的错误消息成员函数

如果在使用Snmp成员函数过程中出现了一个错误，成员函数Snmp::error_msg( )可以用来检索出一个友好的错误字符串。

//------------------------[ error message]-----------------------------

char * Snmp::error_msg( const int status); // returns string for provided status

19. 运行模式

SNMP++的设计决定了它支持多种运行模式。这些运行模式允许用户创建图形用户接口（GUI）以及控制台模式的应用。GUI运行模式与现有的GUI事件驱动系统协同工作；而控制台运行模式允许使用自定义的事件驱动系统，甚至不需要事件驱动系统。

19.1. Microsoft Windows事件驱动系统的运作

为了在MS-Windows上使用，SNMP++与MS-Windows消息系统协同工作。调用阻塞模式可以允许处理其他消息。

19.2. Open Systems Foundation (OSF) X11 Motif的运作

X11接口与MS-Windows接口一样。在MS-Windows和X11各种版本上的SNMP++都支持阻塞和异步方式的使用。为了用SNMP++对X11应用注册X11的上下文（context）需要一个额外的函数（该操作是为了在X11的事件系统上使用SNMP++）。这就要用到XtAppMainLoop()或类似的函数来显式地认可并分发所有异步的SNMP++事件。

· 需要传入的上下文参数会由XtAppInitialize()的调用返回

· 如果对X11注册成功，则该函数返回零

//----------------[ initialize SNMP++ X11 Context ]--------------------------

int SNMPX11Initialize( XtAppContext context);

19.3. 不以GUI为基础的应用的运作

SNMP++的第三种运作模式是用文本形式构造的控制台应用。这些类型的应用上的操作也可以调用阻塞或异步的模式。SNMP++提供了一组函数调用来读取当前用到的文件描述符（socket handles）。调用者在它们各自的“select”调用中用到这些文件描述符。如果SNMP++文件描述符有一个挂起的事件，调用者将激活例行程序来处理所有挂起的事件。

SNMPGetFdSets

用以决定需要潜在地激活的文件描述符。该函数会填充读、写、异常模块，以便传递到“select”。

//-------[ get file descriptor set from SNMP++ ]------------------------------------

void SNMPGetFdSets( int &maxfds, // max # of fds represented

fd_set &read_fds, // mask representing read actions

fd_set &write_fds, // mask representing write actions

fd_set &exceptfds); // mask representing exception actions

SNMPGetNextTimeout

用以决定下次出现超时事件的时间。该值可在阻塞操作中被用作最大间隔值。比如select在控制权返回之前必须等待该间隔时间。超时的计算的基础是：所有用户注册超时（user-registered time-outs）以及SNMP重发的时间间隔中最近的一次。

//---------[ Get the next time-out value ]----------------------------------------------------

unsigned long int SNMPGetNextTimeout( ); // returns value in 1/100 of seconds

SNMPProcessPendingEvents

用以处理目前所有的突出的（outstanding）事件。该函数会调用所有与已完成的超时、文件描述符或突出的（outstanding）SNMP消息相关的回调。该函数是非阻塞的，在同一时候它只处理突出的（outstanding）事件。

//------[ process pending events ]----------------------------------------------------------

int SNMPProcessPendingEvents();

20. 状态＆错误编号

当使用Snmp class操作的时候SNMP++提供了两种级别的错误信息。所有的Snmp class成员函数都返回一个状态值。“SNMP_CLASS_ERR_STATUS_SET”这个特别的错误值表明了Pdu发生了一个内部错误，必须用成员函数Pdu::get_error_status()来检索该错误信息。所有的SNMP++错误值都可传进成员函数Snmp::err_msg()以打印出该错误的文本描述。

SNMP++ General Errors	Value	说明
SNMP_CLASS_SUCCESS	0	成功状态
SNMP_CLASS_ERROR	-1	普通错误
SNMP_CLASS_RESOURCE_UNAVAIL	-2	内存分配失败（New或malloc）
SNMP_CLASS_INTERNAL_ERROR	-3	未知的内部错误
SNMP_CLASS_UNSUPPORTED	-4	不支持的函数
Callback Reasons
SNMP_CLASS_TIMEOUT	-5	明显的请求超时
SNMP_CLASS_ASYNC_RESPONSE	-6	收到应答
SNMP_CLASS_NOTIFICATION	-7	收到notification (trap/inform)
SNMP_CLASS_SESSION_DESTROYED	-8	销毁Snmp对象
Snmp Class Errors
SNMP_CLASS_INVALID	-10	在无效的实例上调用了Snmp成员函数
SNMP_CLASS_INVALID_PDU	-11	向映像函数传递了无效的PDU
SNMP_CLASS_INVALID_TARGET	-12	向映像函数传递了无效的target
SNMP_CLASS_INVALID_CALLBACK	-13	向映像函数传递了无效的回调函数
SNMP_CLASS_INVALID_REQID	-14	要取消的请求ID无效
SNMP_CLASS_INVALID_NOTIFYID	-15	trap/inform Oid丢失
SNMP_CLASS_INVALID_OPERATION	-16	指定的target不允许进行Snmp操作
SNMP_CLASS_INVALID_OID	-17	向映像函数传递了无效的Oid
SNMP_CLASS_INVALID_ADDRESS	-18	向映像函数传递了无效的address
SNMP_CLASS_ERR_STATUS_SET	-19	代理端返回带有错误信息的应答PDU
SNMP_CLASS_TL_UNSUPPORTED	-20	不支持的传输
SNMP_CLASS_TL_IN_USE	-21	传输被占用
SNMP_CLASS_TL_FAILED	-22	传输失败

21. 错误状态值

当SNMP++的成员函数返回值是“SNMP_CLASS_ERR_STATUS_SET”时，可以由成员函数Pdu::get_error_status()获取一个额外的错误状态。该值表示的是RFC 1905中实际的SMI PDU错误状态值。这些值可以传进成员函数Snmp::err_msg()以友好的方式描述。

Pdu Error Status Macro	Value	说明
SNMP_ERROR_TOO_BIG	1	Pdu太大，查看错误索引
SNMP_ERROR_NO_SUCH_NAME	2	没有对应的帮定变量名称，查看返回的错误索引
SNMP_ERROR_BAD_VALUE	3	错误的帮定变量，查看返回的错误索引
SNMP_ERROR_READ_ONLY	4	帮定变量是只读的，查看返回的错误索引
SNMP_ERROR_GENERAL_VB_ERR	5	普通帮定变量错误，查看返回的错误索引
SNMP_ERROR_NO_ACCESS	6	操作失败，拒绝访问
SNMP_ERROR_WRONG_TYPE	7	操作失败，类型错误
SNMP_ERROR_WRONG_LENGTH	8	操作失败，长度错误
SNMP_ERROR_WRONG_ENCODING	9	操作失败，译码错误
SNMP_ERROR_WRONG_VALUE	10	操作失败，值错误
SNMP_ERROR_NO_CREATION	11	操作失败，拒绝创建
SNMP_ERROR_INCONSIST_VAL	12	操作失败，值不相容
SNMP_ERROR_RESOURCE_UNAVAIL	13	操作失败，无法使用资源
SNMP_ERROR_COMITFAIL	14	操作失败，提交失败
SNMP_ERROR_UNDO_FAIL	15	操作失败，撤销失败
SNMP_ERROR_AUTH_ERR	16	操作失败，权限错误
SNMP_ERROR_NOT_WRITEABLE	17	操作失败，拒绝更改
SNMP_ERROR_INCONSIS_NAME	18	操作失败，名字不相容

22. Snmp Class例子

关于这个部分的附加例子，请查阅下表所列的文档，以获得可用作命令的完整实用程序。

Program Name and 说明	File Name
SnmpGet, performs SNMP++ get to v1 and v2 agents.	snmpget.cpp
SnmpNext, peforms SNMP++ getNext to v1 and v2 agents.	snmpnext.cpp
SnmpBulk, performs SNMP++ getBulk to v1 and v2 agents.	snmpbulk.cpp
SnmpSet, performs SNMP++ set to v1 and v2 agents.	snmpset.cpp
SnmpTrap, sends v1 or v2 trap to a manager.	snmptrap.cpp
SnmpWalk, walks an agent's MIB using v1 or v2 via GetBulk.	snmpwalk.cpp

22.1. Getting a Single MIB Variable Example

#include “snmp_pp.h”

#define SYSDESCR “1.3.6.1.2.1.1.1.0” // Object ID for System Descriptor

void get_system_descriptor()

{

int status; // return status

CTarget ctarget( (IpAddress) “10.4.8.5”); // SNMP++ v1 target

Vb vb( SYSDESCR); // SNMP++ Variable Binding

Pdu pdu; // SNMP++ PDU

//-------[ Construct a SNMP++ SNMP Object ]---------------------------------------

Snmp snmp( status); // Create a SNMP++ session

if ( status != SNMP_CLASS_SUCCESS) { // check creation status

cout << snmp.error_msg( status); // if fail, print error string

return; }

//-------[ Invoke a SNMP++ Get ]-------------------------------------------------------

pdu += vb; // add the variable binding

if ( (status = snmp.get( pdu, ctarget)) != SNMP_CLASS_SUCCESS)

cout << snmp.error_msg( status);

else {

pdu.get_vb( vb,0); // extract the variable binding

cout << “System Descriptor = ”<< vb.get_printable_value(); } // print out

};

22.2. Getting Multiple MIB Variables Example

#include “snmp_pp.h”

#define SYSDESCR “1.3.6.1.2.1.1.1.0” // Object ID for system descriptor

#define SYSOBJECTID "1.3.6.1.2.1.1.2.0" // Object ID for system object ID

#define SYSUPTIME "1.3.6.1.2.1.1.3.0" // Object ID for system up time

#define SYSCONTACT "1.3.6.1.2.1.1.4.0" // Object ID for system contact

#define SYSNAME "1.3.6.1.2.1.1.5.0" // Object ID for system name

#define SYSLOCATION "1.3.6.1.2.1.1.6.0" // Object ID for system location

#define SYSSERVICES "1.3.6.1.2.1.1.7.0" // Object ID for system services

void get_system_group()

{

int status; // return status

CTarget ctarget( (IpAddress) “10.4.8.5”); // SNMP++ v1 target

Vb vb[7]; // a vb for each object to get

Pdu pdu; // SNMP++ PDU

//-------[ Construct a SNMP++ SNMP Object ]---------------------------------------

Snmp snmp( status); // Create a SNMP++ session

if ( status != SNMP_CLASS_SUCCESS) { // check creation status

cout << snmp.error_msg( status); // if fail, print error string

return; }

//-------[ build up the vbs to get]-----------------------------------------------------------------

vb[0].set_oid( SYSDESCR);

vb[1].set_oid( SYSOBJECTID);

vb[2].set_oid( SYSUPTIME);

vb[3].set_oid(SYSCONTACT);

vb[4].set_oid( SYSNAME);

vb[5].set_oid( SYSLOCATION);

vb[6].set_oid( SYSSERVICES);

//----[ append all the vbs to the pdu ]-----------------------------------------------------

for ( int z=0;z<7;z++)

pdu += vb[z];

//-------[ Invoke a SNMP++ Get ]-------------------------------------------------------

if ( (status = snmp.get( pdu, ctarget)) != SNMP_CLASS_SUCCESS)

cout << snmp.error_msg( status);

else {

pdu.get_vbs( vb,7); // extract the variable bindings

for ( int w=0;w<7;w++)

cout << vb[w].get_printable_value() << “\n”; } // print out the value

};

22.3. Setting a Single MIB Variable Example

#include “snmp_pp.h”

#define SYSLOCATION “1.3.6.1.2.1.1.6.0” // Object ID for System location

void set_system_location()

{

int status; // return status

CTarget ctarget( (IpAddress) “10.4.8.5”); // SNMP++ v1 target

Vb vb( SYSLOCATION); // SNMP++ Variable Binding

Pdu pdu; // SNMP++ PDU

//-------[ Construct a SNMP++ SNMP Object ]---------------------------------------

Snmp snmp( status); // Create a SNMP++ session

if ( status != SNMP_CLASS_SUCCESS) { // check creation status

cout << snmp.error_msg( status); // if fail, print error string

return;

}

//-------[ Invoke a SNMP++ Set ]-------------------------------------------------------

vb.set_value(“Upstairs Mezzanine”); // add location string to vb

pdu += vb; // add the variable binding

status = snmp.set( pdu, ctarget);

cout << snmp.error_msg(status);

}

22.4. Setting Multiple MIB Variables Example

#include “snmp_pp.h”

#define SYSCONTACT "1.3.6.1.2.1.1.4.0" // Object ID for system contact

#define SYSNAME "1.3.6.1.2.1.1.5.0" // Object ID for system name

#define SYSLOCATION "1.3.6.1.2.1.1.6.0" // Object ID for system location

void multi_set()

{

int status; // return status

CTarget ctarget( (IpAddress) “10.4.8.5”); // SNMP++ v1 target

Vb vb[3]; // a vb for each object to get

Pdu pdu; // SNMP++ PDU

//-------[ Construct a SNMP++ SNMP Object ]---------------------------------------

Snmp snmp( status); // Create a SNMP++ session

if ( status != SNMP_CLASS_SUCCESS) { // check creation status

cout << snmp.error_msg( status); // if fail, print error string

return; }

//-------[ build up the vbs to get]-----------------------------------------------------------------

vb[0].set_oid( SYSCONTACT);

vb[0].set_value(“Alan Turing”);

vb[1].set_oid( SYSNAME);

vb[1].set_value(“ The Turing Machine”);

vb[2].set_oid( SYSLOCATION );

vb[2].set_value(“ Cambridge, UK”);

//----[ append all the vbs to the pdu ]-----------------------------------------------------

for ( int z=0;z<3;z++)

pdu += vb[z];

//-------[ Invoke a SNMP++ Set ]-------------------------------------------------------

status = snmp.set( pdu, ctarget);

cout << snmp.error_msg( status);

}

22.5. Walking a MIB using Get-Next Example

#include “snmp_pp.h” // include snmp++ header file

void mib_walk()

{

int status; // return status

CTarget target( (IpAddress) “10.4.8.5”); // SNMP++ v1 target

Vb vb; // a SNMP++ vb

Pdu pdu; // SNMP++ PDU

//-------[ Construct a SNMP++ SNMP Object ]---------------------------------------

Snmp snmp( status); // Create a SNMP++ session

if ( status != SNMP_CLASS_SUCCESS) { // check creation status

cout << snmp.error_msg( status); // if fail, print error string

return; }

//-------[ set up the first vb ]---------------------------------------------------------------

vb.set_oid(“1”); // get next starting seed

pdu += vb; // add vb to the pdu

status = SNMP_CLASS_SUCCESS;

while ( status == SNMP_CLASS_SUCCESS)

{

if ( (status = snmp.get_next( pdu, ctarget)) == SNMP_CLASS_SUCCESS) {

pdu.get_vb( vb,0); // extract the vb

cout << “Mib Object = “ << vb.get_printable_oid() << “\n”;

cout << “Mib Value = “ << vb.get_printable_value() << “\n”;

pdu.set_vb( vb,0); // use last vb as the next one

}

else

cout << “SNMP++ Error = “ << snmp.error_msg( status);

}

};

22.6. Sending a Trap Example

#include “snmp_pp.h”

void send_trap()

{

int status; // return status

CTarget target( (IpAddress) “10.4.8.5”); // SNMP++ v1 target

Pdu pdu; // SNMP++ PDU

//-------[ Construct a SNMP++ SNMP Object ]---------------------------------------

Snmp snmp( status); // Create a SNMP++ session

if ( status != SNMP_CLASS_SUCCESS) { // check creation status

cout << snmp.error_msg( status); // if fail, print error string

return; }

status = snmp.trap( pdu, target,coldStart);

cout << “ Trap Send Status = “ << snmp.error_msg( status);

};

22.7. Receiving Traps Example

#include “snmp_pp.h”

//-----------------[ trap callback function definition ]-------------------------------------------------------------------

void my_trap_callback ( int reason, // reason

Snmp* session, // session handle

Pdu & pdu, // trap pdu

TimeTicks ×tamp, // timestamp

SnmpTarget &target, // source of the trap

void * cbd) // optional callback data

{

Address *address;

unsigned char get_cummunity[80], set_community[80];

unsigned long timeout;

int retry;

if ( reason == SNMP_CLASS_TRAP) {

target.resolve_to_C( get_community, // get community

set_community, // set community

&address, // address object

timeout, // timeout

retry); // retry

cout << “Trap Received from << address->get_printable() << “Trap Id = “ << trapid.get_printable();

}

else

cout << “Trap Receive Error = “ << session->error_msg( reason);

};

//---------------[ trap receive register ]---------------------------------------------------------------------

Snmp *snmp; // dynamic Snmp object

void trap_register()

{

//----------------[ instantiate an Snmp object, delete when no longer receiving traps ]------------

int status;

snmp = new Snmp( status);

if (( snmp == NULL) || ( status != SNMP_CLASS_SUCCESS))

cout << “Error constructing Snmp Object\n”;

else

{

//-------[ set up two empty collections, empty denotes receive all ]-------------------------------

TargetCollection targets;

OidCollection trapids;

//------[ invoke the regsiter ]----------------------------------------------------------------------------

if ( status = snmp->notify_register( trapids, targets, & my_trap_callback)) != SNMP_CLASS_SUCCESS)

cout << “ Snmp Trap Register Error “ << snmp->error_msg( status);

}

};

23. 参考书目

[Banker, Mellquist ]

Banker Kim, Mellquist Peter E., SNMP++, Connexions, The Interoperability Report, Volume 9, No. 3, March 1995.

[Comer]

Comer, Douglas E. , Internetworking with TCP/IP, Principles, Protocols and Architecture, Volume I Prentice Hall, 1991.

[Gama, Helm, Johnson, Vlissides]

Erich Gama, Richard Helm , Ralph Johnson, John Vlissides , Design Patterns, Addison Wesley, 1995.

[Meyers]

Meyers, Scott, Effective C++, Addison Wesley, 1994.

[Petzold]

Petzold Charles, Programming MS-Windows, Microsoft Press

[RFC 1452]

J. Case, K. McCloghrie, M. Rose, S. Waldbusser, Coexistence between version 1 and version 2 of the Internet-standard Network Management Framework, May 03, 1993.

[RFC 1442]

J. Case, K. McCloghrie, M. Rose, S. Waldbusser, Structure of Management Information for version 2 of the Simple Network Management Protocol (SNMPv2), May 03 , 1993.

[Rose]

Rose, Marshall T. , The Simple Book, An Introduction to Internet Management , Second Edition, Prentice Hall Series 1994.

[Rumbaugh]

Rumbaugh, James, Object-Oriented Modeling and Design, Prentice Hall, 1991.

[Saks]

Saks, Dan, C++ Programming Guidelines, Thomas Plum & Dan Sacks, 1992.

[Stallings]

Stallings, William, SNMP, SNMPv2 and CMIP The Practical Guide to Network Management Standards, Addison Wesley, 1993.

[Stroustrup]

Stroustrup , Bjarne, The C++ Programming Language, Edition #2 Addison Wesley, 1991.

[WinSNMP]

WinSNMP, Windows SNMP An Open Interface for Programming Network Management Application under Microsoft Windows. Version 1.1.

[WinSockets]

WinSockets, Windows Sockets, An Open Interface for Network Programming under Microsoft Windows.

圆月弯刀丶

关注

0
点赞
踩
5

收藏

觉得还不错? 一键收藏
0
评论
SNMP++2.8中文文档

SNMP++用C++构建的，处理简单网络管理协议(SNMP)的APISNMP++. 1用C++构建的，处理简单网罗管理协议(SNMP)的API11. 介绍... 61.1. 什么是SNMP++. 61.2. SNMP++的本质... 61.2.1. 简单易用的SNMP++. 61.2.2. 编程安全的SNMP++. 71.2.3. 可移植的SNMP++. 8
复制链接

扫一扫