net-snmp的片段源码分析

爱被打了一巴掌 2022-08-25 08:29 227阅读 0赞

snmp 代理端扩展源码分析

2008-05-05 17:53

\#include  
\#include  
\#include  
  
\#if HAVE\_STDLIB\_H  
\#include  
\#endif  
  
\#if TIME\_WITH\_SYS\_TIME  
  
\# ifdef WIN32  
\# include  
\# else  
\# include  
\# endif  
\# include  
  
\#else  
\# if HAVE\_SYS\_TIME\_H  
\# include  
\# else  
\# include  
\# endif  
  
\#endif  
  
  
\#include "util\_funcs.h"  
包含自己的头文件  
\#include "Display\_time.h"  
  
\#define EXAMPLE\_STR\_LEN 300  
\#define EXAMPLE\_STR\_DEFAULT "life the universe andeverything"  
int

example\_int = 42;  
char                      example\_str\[EXAMPLE\_STR\_LEN\];  
  
void                      example\_parse\_config\_exampleint(const char \*token, char\*cptr);  
void                      example\_parse\_config\_examplestr(const char \*token, char\*cptr);  
void                      example\_free\_config\_exampleint(void);  
void                      example\_free\_config\_examplestr(void);  
  
这个数组的类型是struct variableN， 其中N是这个数组中OID号的最长的数，  
即：结构体最后一个成员（这个成员是个数组）定义了MIB Tree OID的底层数字。  
       N定义了MIB TreeOID的底层的层数（也就是这个数组的长度）。  
      所有有效的N数字都定义在了文件中。  
  
struct variableN类型成员的说明：  
      1）：FoxmailINT：这个magic number是在自己的头文件Display\_time.h中宏定义，  
                                    这个参数被用来传递给CallBack 例程，用来决定那个object被查询。  
      2）：ASN\_INTEGER：这个参数说明了object的类型，所有有效的类型在snmp\_impl.h文件中列表说明。  
      3）：RONLY：这个参数说明了object是否能够被set。  
      4）：var\_foxmail：当有object被查询时，这个CallBack 例程被调用。  
                              一般的情况下，同一个文件中的所有的object使用相同的allBack 例程。  
       5）：1：MIBTree OID的底层数字的层数。（这个数字决定了struct variableN中的N）  
       6）：\{1\}：MIBTree OID的底层数字。  
  
struct variable2 example\_variables\[\] = \{  
      \{EXAMPLESTRING, ASN\_OCTET\_STR, RONLY, var\_example, 1, \{1\}\},  
      \{EXAMPLEINTEGER, ASN\_INTEGER, RWRITE, var\_example, 2, \{2,1\}\},  
      \{EXAMPLEOBJECTID, ASN\_OBJECT\_ID, RONLY, var\_example, 2, \{2,2\}\},  
      \{EXAMPLETIMETICKS, ASN\_TIMETICKS, RONLY, var\_example, 1,\{3\}\},  
      \{EXAMPLEIPADDRESS, ASN\_IPADDRESS, RONLY, var\_example, 1,\{4\}\},  
      \{EXAMPLECOUNTER, ASN\_COUNTER, RONLY, var\_example, 1, \{5\}\},  
      \{EXAMPLEGAUGE, ASN\_GAUGE, RONLY, var\_example, 1, \{6\}\},  
      \{EXAMPLETRIGGERTRAP, ASN\_INTEGER, RWRITE, var\_example, 1,\{7\}\},  
      \{EXAMPLETRIGGERTRAP2, ASN\_INTEGER, RWRITE, var\_example, 1,\{8\}\}  
\};  
  
下面这个数组定义了MIB Tree OID的顶层数字。  
oid                        example\_variables\_oid\[\] = \{ 1, 3, 6, 1, 4, 1, 2021, 254 \};  
  
  
  
这个例程在Agent程序开始的时候被调用，用来初始化可能被查询的Object。  
void init\_example(void)  
\{  
             注册我们自己的MIBTree，以便Agent查询的时候能够处理。  
             参数：  
                  1）descr:      描述这个MIB Tree  
                  2）var:          变量结构体，类型struct variableN。  
                   3）vartype:类型struct variableN  
                  4）theoid:     MIB Tree的顶层数字  
      REGISTER\_MIB("example", example\_variables, variable2,  
                                example\_variables\_oid);  
  
            把example\_str变量设上默认字符串。example\_int已经在上面初始化了。  
      strncpy(example\_str, EXAMPLE\_STR\_DEFAULT, EXAMPLE\_STR\_LEN);  
  
       \* Registerconfig handlers for the two objects that can be set  
        \* via configuration file directive  
      snmpd\_register\_config\_handler("exampleint",  
                                                                  example\_parse\_config\_exampleint,  
                                                                  example\_free\_config\_exampleint,  
                                                                  "exampleint value");  
      snmpd\_register\_config\_handler("examplestr",  
                                                                  example\_parse\_config\_examplestr,  
                                                                  example\_free\_config\_examplestr,  
                                                                  "examplestr value");  
      snmpd\_register\_config\_handler("examplestring",  
                                                                  example\_parse\_config\_examplestr,  
                                                                  example\_free\_config\_examplestr,  
                                                                  "examplestring value");  
  
            我们经常需要读取内核中的数据，我们需要在这里进行一些必要的初始化。  
            以加快我们读取这些内核信息的速度，快速反应查询请求。  
       
  
\}  
  
  
配置文件处理函数  
void  
example\_parse\_config\_exampleint(const char \*token, char\*cptr)  
\{  
       example\_int= atoi(cptr);  
\}  
void  
example\_parse\_config\_examplestr(const char \*token, char\*cptr)  
\{  
            必须确保字符串长度小于分配的空间。  
       if(strlen(cptr) < EXAMPLE\_STR\_LEN)  
              strcpy(example\_str, cptr);  
       else \{  
            如果需要的话，截断这个字符串。  
              strncpy(example\_str, cptr, EXAMPLE\_STR\_LEN - 4);  
              example\_str\[EXAMPLE\_STR\_LEN - 4\] = 0;  
              strcat(example\_str, "...");  
              example\_str\[EXAMPLE\_STR\_LEN - 1\] = 0;  
           \}  
\}  
  
当关闭Agent时需要的清除工作。  
void  
example\_free\_config\_exampleint(void)  
\{  
\}  
  
void  
example\_free\_config\_examplestr(void)  
\{  
\}  
  
  
当有请求访问这个MIB Tree的object时，就会调用这个处理函数。  
参数：  
      1）vp          被请求访问的object的example\_variables的入口地址  
      2）name      被请求访问的object的OID  
       3）lengthOID的长度  
      4）exact    指示这个request是“exact”（GET/SET）请求，还是“inexact”（GETNEXT/GETBULK）请求  
四个参数被用来返回信息：  
      1）name                        被请求访问的object的OID  
       2）length                   OID的长度  
       3）var\_len                  返回应答的长度  
      4）write\_method    被请求访问的object的SET函数的指针  
  
u\_char \*  
var\_example(struct variable \*vp,  
                      oid \* name,  
                      size\_t \* length,  
                      int exact, size\_t \* var\_len, WriteMethod \*\* write\_method)  
\{  
            从这个函数返回的值必须是一个static data的指针，这样才能够从函数外来访问。  
             
       staticchar        string\[EXAMPLE\_STR\_LEN\];       
       staticoid          oid\_ret\[8\];  
       staticlong        long\_ret;     
  
            在进行应答请求之前，需要检查这个请求object OID是否是一个有效的OID。  
            header\_generic()函数能够用来检查scalar objects。  
            header\_simple\_table（）函数能够用来检查simple table。  
            这些函数也当检查正确时，设置默认的返回值。  
       \* The nameand length are set suitably for the current object,  
        \* var\_len assumes that the result is an integer of some form,  
        \* and write\_method assumes that the object cannot be set.  
  
      DEBUGMSGTL(("example", "var\_example entered\\n"));  
       if(header\_generic(vp, name, length, exact, var\_len, write\_method)==  
              MATCH\_FAILED)  
              return NULL;  
  
  
             我们使用structvariableN结构体中的magicnumber来决定那个object被请求。             
       switch(vp->magic) \{  
       caseEXAMPLESTRING:  
              sprintf(string, example\_str);  
                  在上面时假设返回值是integer，但是并不是，所以需要重新设置var\_len。  
              \*var\_len = strlen(string);  
              return (u\_char \*) string;  
  
       caseEXAMPLEINTEGER:  
                  这种情况，上面的假设的长度是正确的，但是这个object是可以写的，所以需要设置write\_method。  
              long\_ret = example\_int;  
              \*write\_method = write\_exampleint;  
              return (u\_char \*) & long\_ret;  
  
       caseEXAMPLEOBJECTID:  
              oid\_ret\[0\] = 1;  
              oid\_ret\[1\] = 3;  
              oid\_ret\[2\] = 6;  
              oid\_ret\[3\] = 1;  
              oid\_ret\[4\] = 4;  
              oid\_ret\[5\] = oid\_ret\[6\] = oid\_ret\[7\] = 42;  
                  这种情况，上面的假设的长度是错误的。  
              \*var\_len = 8 \* sizeof(oid);  
              return (u\_char \*) oid\_ret;  
  
       caseEXAMPLETIMETICKS:  
                  这种情况，上面的假设的长度是正确的，直接返回。  
              long\_ret = 363136200;     
              return (u\_char \*) & long\_ret;  
  
       caseEXAMPLEIPADDRESS:  
              long\_ret = ntohl(INADDR\_LOOPBACK);  
              return (u\_char \*) & long\_ret;  
  
       caseEXAMPLECOUNTER:  
              long\_ret = 42;  
              return (u\_char \*) & long\_ret;  
  
       caseEXAMPLEGAUGE:  
              long\_ret =42;                   
              return (u\_char \*) & long\_ret;  
  
       caseEXAMPLETRIGGERTRAP:  
                  这个object是只能够写的“write-only”。  
                  它的作用是只能够产生一个“trap”，当读它的时候只能够返回0。  
              long\_ret = 0;  
              \*write\_method = write\_exampletrap;  
              return (u\_char \*) & long\_ret;  
  
       caseEXAMPLETRIGGERTRAP2:  
                  这个object是只能够写的“write-only”。  
                  它的作用是只能够产生一个SNMP v2版本的“trap”，当读它的时候只能够返回0。  
  
              long\_ret = 0;  
              \*write\_method = write\_exampletrap2;  
              return (u\_char \*) & long\_ret;  
  
      default:  
                  这种情况，报告一个错误，并把错误写入log。  
              DEBUGMSGTL(("snmpd", "unknown sub-id %d inexamples/var\_example\\n",  
                                      vp->magic));  
       \}  
       returnNULL;  
\}  
  
当某个object是可写的时候，需要设置SET处理例程。  
  
int  
write\_exampleint(int action,  
                                u\_char \* var\_val,  
                                u\_char var\_val\_type,  
                                size\_t var\_val\_len,  
                                u\_char \* statP, oid \* name, size\_t name\_len)  
\{  
      定义一个允许访问的最大数值，它是任意的。  
\#define MAX\_EXAMPLE\_INT 100  
       staticlong        intval;  
       staticlong        old\_intval;  
  
       switch(action) \{  
       caseRESERVE1:  
                        检查要设置的值是否符合条件。  
              if (var\_val\_type != ASN\_INTEGER) \{  
                      DEBUGMSGTL(("example", "%x not integer type", var\_val\_type));  
                      return SNMP\_ERR\_WRONGTYPE;  
                           \}  
              if (var\_val\_len > sizeof(long)) \{  
                      DEBUGMSGTL(("example", "wrong length %x", var\_val\_len));  
                      return SNMP\_ERR\_WRONGLENGTH;  
                                \}  
  
              intval = \*((long \*) var\_val);  
              if (intval > MAX\_EXAMPLE\_INT) \{  
                      DEBUGMSGTL(("example", "wrong value %x", intval));  
                      return SNMP\_ERR\_WRONGVALUE;  
                           \}  
              break;  
  
       caseRESERVE2:  
              break;  
  
       caseFREE:  
              break;  
  
       caseACTION:  
                  按照请求设置数值，但是这个请求可能被撤销，所以需要保存原来的值。  
              old\_intval = example\_int;  
              example\_int = intval;  
              break;  
  
       caseUNDO:  
                  撤销上一个请求，恢复原来的值。  
              example\_int = old\_intval;  
              break;  
  
       caseCOMMIT:  
              break;  
  
       \}  
       returnSNMP\_ERR\_NOERROR;  
\}  
  
  
  
  
int  
write\_exampletrap(int action,  
                                  u\_char \* var\_val,  
                                  u\_char var\_val\_type,  
                                  size\_t var\_val\_len,  
                                  u\_char \* statP, oid \* name, size\_t name\_len)  
\{  
      long                      intval;  
  
      DEBUGMSGTL(("example", "write\_exampletrap entered:action=%d\\n",  
                              action));  
       switch(action) \{  
       caseRESERVE1:  
              if (var\_val\_type != ASN\_INTEGER) \{  
                      DEBUGMSGTL(("example", "%x not integer type", var\_val\_type));  
                      return SNMP\_ERR\_WRONGTYPE;  
                           \}  
              if (var\_val\_len > sizeof(long)) \{  
                      DEBUGMSGTL(("example", "wrong length %x", var\_val\_len));  
                      return SNMP\_ERR\_WRONGLENGTH;  
                           \}  
  
              intval = \*((long \*) var\_val);  
              if (intval != 1) \{  
                      DEBUGMSGTL(("example", "wrong value %x", intval));  
                      return SNMP\_ERR\_WRONGVALUE;  
                               \}  
              break;  
  
       caseRESERVE2:  
              break;  
  
       caseFREE:  
              break;  
  
       caseACTION:  
              break;  
  
       caseUNDO:  
              break;  
  
       caseCOMMIT:  
                  产生一个“trap”  
              DEBUGMSGTL(("example", "write\_exampletrap sending thetrap\\n",  
                                      action));  
              send\_easy\_trap(SNMP\_TRAP\_ENTERPRISESPECIFIC, 99);  
              DEBUGMSGTL(("example", "write\_exampletrap trap sent\\n",action));  
              break;  
  
       \}  
       returnSNMP\_ERR\_NOERROR;  
\}  
  
  
  
int  
write\_exampletrap2(int action,  
                                    u\_char \* var\_val,  
                                    u\_char var\_val\_type,  
                                    size\_t var\_val\_len,  
                                    u\_char \* statP, oid \* name, size\_t name\_len)  
\{  
      long                      intval;  
  
      oid                        objid\_snmptrap\[\] = \{ 1, 3, 6, 1, 6, 3, 1, 1, 4, 1, 0\};         
      oid                        demo\_trap\[\] = \{ 1, 3, 6, 1, 4, 1, 2021, 13, 990 \};  
      oid                        example\_string\_oid\[\] =  
              \{ 1, 3, 6, 1, 4, 1, 2021, 254, 1, 0 \};  
       staticnetsnmp\_variable\_list var\_trap;  
       staticnetsnmp\_variable\_list var\_obj;  
  
      DEBUGMSGTL(("example", "write\_exampletrap2 entered:action=%d\\n",  
                              action));  
       switch(action) \{  
       caseRESERVE1:  
              if (var\_val\_type != ASN\_INTEGER) \{  
                      DEBUGMSGTL(("example", "%x not integer type", var\_val\_type));  
                      return SNMP\_ERR\_WRONGTYPE;  
                           \}  
              if (var\_val\_len > sizeof(long)) \{  
                      DEBUGMSGTL(("example", "wrong length %x", var\_val\_len));  
                      return SNMP\_ERR\_WRONGLENGTH;  
                           \}  
  
              intval = \*((long \*) var\_val);  
              if (intval != 1) \{  
                      DEBUGMSGTL(("example", "wrong value %x", intval));  
                      return SNMP\_ERR\_WRONGVALUE;  
                               \}  
              break;  
  
       caseRESERVE2:  
              break;  
  
       caseFREE:  
              break;  
  
       caseACTION:  
              break;  
  
       caseUNDO:  
              break;  
  
       caseCOMMIT:  
                   产生一个 SNMPv2版本的“trap”  
  
              var\_trap.next\_variable =&var\_obj;           
              var\_trap.name = objid\_snmptrap;  
              var\_trap.name\_length = sizeof(objid\_snmptrap) /sizeof(oid);       
              var\_trap.type = ASN\_OBJECT\_ID;  
              var\_trap.val.objid = demo\_trap;  
              var\_trap.val\_len =sizeof(demo\_trap);     
  
  
              var\_obj.next\_variable =NULL;     
              var\_obj.name = example\_string\_oid;  
              var\_obj.name\_length = sizeof(example\_string\_oid) /sizeof(oid);  
              var\_obj.type =ASN\_OCTET\_STR;     
              var\_obj.val.string =example\_str;             
              var\_obj.val\_len = strlen(example\_str);  
              DEBUGMSGTL(("example", "write\_exampletrap2 sending the v2trap\\n",  
                                      action));  
              send\_v2trap(&var\_trap);  
              DEBUGMSGTL(("example", "write\_exampletrap2 v2 trap sent\\n",  
                                      action));  
  
              break;  
  
             \}  
       returnSNMP\_ERR\_NOERROR;  
\}  
  
  
  
  
  
  
REGISTER\_MIB()宏定义最终调用的是netsnmp\_register\_old\_api函数。  
  
里面用到了这个结构体。  
typedef struct netsnmp\_handler\_registration\_s \{  
  
       
              char                    \*handlerName;  
       
              char                    \*contextName;  
  
               
              oid                      \*rootoid;  
              size\_t                  rootoid\_len;  
               
              netsnmp\_mib\_handler \*handler;  
              int                        modes;  
  
               
              int                        priority;  
              int                        range\_subid;  
              oid                        range\_ubound;  
              int                        timeout;  
              int                        global\_cacheid;  
               
              void\*                  my\_reg\_void;  
  
\} netsnmp\_handler\_registration;  
  
  
  
在调用netsnmp\_register\_handler（reginfo）函数注册netsnmp\_handler\_registration类型的reginfo变量。  
  
netsnmp\_register\_handler（）在agent/agent\_handler.c文件中定义。  
有调用netsnmp\_register\_mib（）函数  
这个函数构建一个netsnmp\_subtree 类型的变量subtree进行注册。  
  
typedef struct netsnmp\_subtree\_s \{  
      oid              \*name\_a;  
      u\_char                  namelen;       
      oid                      \*start\_a;       
      u\_char                  start\_len;  
      oid                      \*end\_a;  
      u\_char                  end\_len;       
       structvariable \*variables;  
      int                        variables\_len;           
      int                        variables\_width;       
      char                    \*label\_a;       
      netsnmp\_session \*session;  
      u\_char                  flags;  
      u\_char                  priority;  
      int                        timeout;  
       structnetsnmp\_subtree\_s\*next;             
       structnetsnmp\_subtree\_s\*prev;             
       structnetsnmp\_subtree\_s\*children;     
      int                        range\_subid;  
      oid                        range\_ubound;  
      netsnmp\_handler\_registration\*reginfo;           
      int                        cacheid;  
      int                        global\_cacheid;  
\} netsnmp\_subtree;  
  
调用这个函数netsnmp\_subtree\_load（）进行注册。