开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 代理服务器 > 查看源码
snmp_vars.c
资源名称：squid-2.2.devel3-src.tar.gz　[点击查看]
上传用户：liugui
上传日期：2007-01-04
资源大小：822k
文件大小：14k
源码类别：

代理服务器

开发平台：

Unix_Linux

snmp_vars.c：源码内容
  2. /*
  3.  * SNMP Variable Binding.  Complies with:
  4.  *
  5.  * RFC 1905: Protocol Operations for SNMPv2
  6.  *
  7.  */
  9. /**********************************************************************
  10.  *
  11.  *           Copyright 1997 by Carnegie Mellon University
  12.  * 
  13.  *                       All Rights Reserved
  14.  * 
  15.  * Permission to use, copy, modify, and distribute this software and its
  16.  * documentation for any purpose and without fee is hereby granted,
  17.  * provided that the above copyright notice appear in all copies and that
  18.  * both that copyright notice and this permission notice appear in
  19.  * supporting documentation, and that the name of CMU not be
  20.  * used in advertising or publicity pertaining to distribution of the
  21.  * software without specific, written prior permission.
  22.  * 
  23.  * CMU DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  24.  * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  25.  * CMU BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  26.  * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  27.  * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  28.  * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  29.  * SOFTWARE.
  30.  * 
  31.  * Author: Ryan Troll <ryan+@andrew.cmu.edu>
  32.  * 
  33.  **********************************************************************/
  35. #include "config.h"
  37. #include <stdio.h>
  39. #if HAVE_UNISTD_H
  40. #include <unistd.h>
  41. #endif
  42. #if HAVE_STDLIB_H
  43. #include <stdlib.h>
  44. #endif
  45. #if HAVE_SYS_TYPES_H
  46. #include <sys/types.h>
  47. #endif
  48. #if HAVE_CTYPE_H
  49. #include <ctype.h>
  50. #endif
  51. #if HAVE_GNUMALLOC_H
  52. #include <gnumalloc.h>
  53. #elif HAVE_MALLOC_H && !defined(_SQUID_FREEBSD_) && !defined(_SQUID_NEXT_)
  54. #include <malloc.h>
  55. #endif
  56. #if HAVE_MEMORY_H
  57. #include <memory.h>
  58. #endif
  59. #ifdef HAVE_STRING_H
  60. #include <string.h>
  61. #endif
  62. #ifdef HAVE_STRINGS_H
  63. #include <strings.h>
  64. #endif
  65. #if HAVE_BSTRING_H
  66. #include <bstring.h>
  67. #endif
  68. #if HAVE_SYS_SOCKET_H
  69. #include <sys/socket.h>
  70. #endif
  71. #if HAVE_NETINET_IN_H
  72. #include <netinet/in.h>
  73. #endif
  74. #if HAVE_ARPA_INET_H
  75. #include <arpa/inet.h>
  76. #endif
  77. #if HAVE_SYS_TIME_H
  78. #include <sys/time.h>
  79. #endif
  80. #if HAVE_NETDB_H
  81. #include <netdb.h>
  82. #endif
  84. #include "snmp.h"
  85. #include "asn1.h"
  86. #include "snmp_vars.h"
  87. #if 0
  88. #include "mibii.h"
  89. #endif
  90. #include "snmp_api_error.h"
  91. #include "snmp_pdu.h"
  92. #include "snmp_msg.h"
  94. #include "util.h"
  97. /* #define DEBUG_VARS 1 */
  98. /* #define DEBUG_VARS_MALLOC 1 */
  99. /* #define DEBUG_VARS_DECODE 1 */
  100. /* #define DEBUG_VARS_ENCODE 1 */
  102. #define ASN_PARSE_ERROR(x) { return(x); }
  104. /* Create a new variable_list structure representing oid Name of length Len.
  105.  *
  106.  * Returns NULL upon error.
  107.  */
  109. struct variable_list *
  110. snmp_var_new(oid * Name, int Len)
  111. {
  112.     struct variable_list *New;
  114. #ifdef DEBUG_VARS
  115.     printf("VARS: Creating.n");
  116. #endif
  118.     New = (struct variable_list *) xmalloc(sizeof(struct variable_list));
  119.     if (New == NULL) {
  120. snmp_set_api_error(SNMPERR_OS_ERR);
  121. return (NULL);
  122.     }
  123.     memset(New, '', sizeof(struct variable_list));
  124.     /*  New->next_variable = NULL; */
  126.     New->type = ASN_NULL;
  127.     New->name_length = Len;
  129.     if (New->name_length == 0) {
  130. New->name = NULL;
  131. return (New);
  132.     }
  133.     New->name = (oid *) xmalloc(Len * sizeof(oid));
  134.     if (New->name == NULL) {
  135. xfree(New);
  136. snmp_set_api_error(SNMPERR_OS_ERR);
  137. return (NULL);
  138.     }
  139. #ifdef DEBUG_VARS
  140.     printf("VARS: Copying name, size (%d)n", Len);
  141. #endif
  143.     /* Only copy a name if it was specified. */
  144.     if (Name)
  145. xmemcpy((char *) New->name, (char *) Name, Len * sizeof(oid));
  147.     return (New);
  148. }
  150. /* Clone a variable list.
  151.  *
  152.  * Returns NULL upon error.
  153.  */
  155. struct variable_list *
  156. snmp_var_clone(struct variable_list *Src)
  157. {
  158.     struct variable_list *Dest;
  160. #ifdef DEBUG_VARS
  161.     printf("VARS: Cloning.n");
  162. #endif
  164.     Dest = (struct variable_list *) xmalloc(sizeof(struct variable_list));
  165.     if (Dest == NULL) {
  166. snmp_set_api_error(SNMPERR_OS_ERR);
  167. return (NULL);
  168.     }
  169. #ifdef DEBUG_VARS
  170.     printf("VARS: Copying entire variable list.  (Size %d)n",
  171. sizeof(struct variable_list));
  172. #endif
  174.     xmemcpy((char *) Dest, (char *) Src, sizeof(struct variable_list));
  176.     if (Src->name != NULL) {
  177. Dest->name = (oid *) xmalloc(Src->name_length * sizeof(oid));
  178. if (Dest->name == NULL) {
  179.     snmp_set_api_error(SNMPERR_OS_ERR);
  180.     xfree(Dest);
  181.     return (NULL);
  182. }
  183. #ifdef DEBUG_VARS
  184. printf("VARS: Copying name OID. (Size %d)n", Src->name_length);
  185. #endif
  186. xmemcpy((char *) Dest->name, (char *) Src->name,
  187.     Src->name_length * sizeof(oid));
  188.     }
  189.     /* CISCO Catalyst 2900 returns NULL strings as data of length 0. */
  190.     if ((Src->val.string != NULL) &&
  191. (Src->val_len)) {
  192. Dest->val.string = (u_char *) xmalloc(Src->val_len);
  193. if (Dest->val.string == NULL) {
  194.     snmp_set_api_error(SNMPERR_OS_ERR);
  195.     xfree(Dest->name);
  196.     xfree(Dest);
  197.     return (NULL);
  198. }
  199. #ifdef DEBUG_VARS
  200. printf("VARS: Copying value (Size %d)n", Src->val_len);
  201. #endif
  202. xmemcpy((char *) Dest->val.string, (char *) Src->val.string, Src->val_len);
  203.     }
  204. #ifdef DEBUG_VARS
  205.     printf("VARS: Cloned %x.n", (unsigned int) Dest);
  206. #endif
  207. #ifdef DEBUG_VARS_MALLOC
  208.     printf("VARS: Cloned  (%x)n", (unsigned int) Dest);
  209.     printf("VARS: Name is (%x)n", (unsigned int) Dest->name);
  210. #endif
  212.     return (Dest);
  213. }
  215. /* Free a variable_list.
  216.  */
  217. void 
  218. snmp_var_free(struct variable_list *Ptr)
  219. {
  220.     if (Ptr->name && Ptr->name_length > 0)
  221. xfree((char *) Ptr->name);
  223.     if (Ptr->val.string && Ptr->val_len > 0)
  224. xfree((char *) Ptr->val.string);
  225.     else if (Ptr->val.integer && Ptr->val_len > 0)
  226. xfree((char *) Ptr->val.integer);
  228.     xfree(Ptr);
  229. }
  231. /**********************************************************************/
  233. /* Build a variable binding.
  234.  *
  235.  * RFC 1905: Protocol Operations for SNMPv2
  236.  *
  237.  * VarBind ::= 
  238.  *   SEQUENCE {
  239.  *     name ObjectName
  240.  *     CHOICE {
  241.  *       value ObjectSyntax
  242.  *       unSpecified NULL
  243.  *       noSuchObject[0] NULL
  244.  *       noSuchInstance[1] NULL
  245.  *       endOfMibView[2] NULL
  246.  *     }
  247.  *   }
  248.  */
  249. u_char *
  250. snmp_var_EncodeVarBind(u_char * Buffer, int *BufLenP,
  251.     variable_list * VarList,
  252.     int Version)
  253. {
  254.     struct variable_list *Vars;
  255.     u_char *bufp;
  256.     u_char *HeaderStart;
  257.     u_char *HeaderEnd;
  258.     int FakeArg = *BufLenP;
  260.     bufp = Buffer;
  262.     for (Vars = VarList; Vars; Vars = Vars->next_variable) {
  264. /* Build the header for this variable
  265.  *
  266.  * Use Maximum size.
  267.  */
  268. HeaderStart = bufp;
  269. HeaderEnd = asn_build_header(HeaderStart, BufLenP,
  270.     (u_char) (ASN_SEQUENCE | ASN_CONSTRUCTOR),
  271.     FakeArg);
  272. if (HeaderEnd == NULL)
  273.     return (NULL);
  275. /* Now, let's put the Object Identifier into the buffer */
  276. bufp = asn_build_objid(HeaderEnd, BufLenP,
  277.     (u_char) (ASN_UNIVERSAL |
  278. ASN_PRIMITIVE |
  279. ASN_OBJECT_ID),
  280.     Vars->name, Vars->name_length);
  281. if (bufp == NULL)
  282.     return (NULL);
  284. /* Now put the data in */
  285. switch (Vars->type) {
  287. case ASN_INTEGER:
  288.     bufp = asn_build_int(bufp,
  289. BufLenP, Vars->type,
  290. (int *) Vars->val.integer, Vars->val_len);
  291.     break;
  293. case SMI_COUNTER32:
  294. case SMI_GAUGE32:
  295.     /*  case SMI_UNSIGNED32: */
  296. case SMI_TIMETICKS:
  297.     bufp = asn_build_unsigned_int(bufp, BufLenP,
  298. Vars->type,
  299. (u_int *) Vars->val.integer, Vars->val_len);
  300.     break;
  302. case ASN_OCTET_STR:
  303. case SMI_IPADDRESS:
  304. case SMI_OPAQUE:
  305.     bufp = asn_build_string(bufp, BufLenP, Vars->type,
  306. Vars->val.string, Vars->val_len);
  307.     break;
  309. case ASN_OBJECT_ID:
  310.     bufp = asn_build_objid(bufp, BufLenP, Vars->type,
  311. (oid *) Vars->val.objid, Vars->val_len / sizeof(oid));
  312.     break;
  314. case SMI_NOSUCHINSTANCE:
  315. case SMI_NOSUCHOBJECT:
  316. case SMI_ENDOFMIBVIEW:
  317.     if (Version == SNMP_VERSION_1) {
  318. /* SNMP Version 1 does not support these error codes. */
  319. bufp = asn_build_null(bufp, BufLenP, SMI_NOSUCHOBJECT);
  320.     } else {
  321. bufp = asn_build_exception(bufp, BufLenP, Vars->type);
  322.     }
  323.     break;
  325. case ASN_NULL:
  326.     bufp = asn_build_null(bufp, BufLenP, Vars->type);
  327.     break;
  329. case SMI_COUNTER64:
  330.     snmplib_debug(2, "Unable to encode type SMI_COUNTER64!n");
  331.     /* Fall through */
  333. default:
  334.     snmp_set_api_error(SNMPERR_UNSUPPORTED_TYPE);
  335.     return (NULL);
  336. }
  338. /* ASSERT:  bufp should now point to the next valid byte. */
  339. if (bufp == NULL)
  340.     return (NULL);
  342. /* Rebuild the header with the appropriate length */
  343. HeaderEnd = asn_build_header(HeaderStart, &FakeArg,
  344.     (u_char) (ASN_SEQUENCE | ASN_CONSTRUCTOR),
  345.     (bufp - HeaderEnd));
  347. /* Returns NULL */
  348. if (HeaderEnd == NULL)
  349.     return (NULL);
  351.     }
  353.     /* or the end of the entire thing */
  354.     return (bufp);
  355. }
  360. /* Parse all Vars from the buffer */
  361. u_char *
  362. snmp_var_DecodeVarBind(u_char * Buffer, int *BufLen,
  363.     struct variable_list ** VarP,
  364.     int Version)
  365. {
  366.     struct variable_list *Var, **VarLastP;
  367.     u_char *bufp, *tmp;
  368.     u_char VarBindType;
  369.     u_char *DataPtr;
  370.     int DataLen;
  371.     oid TmpBuf[MAX_NAME_LEN];
  373.     int AllVarLen = *BufLen;
  374.     int ThisVarLen = 0;
  376.     VarLastP = VarP;
  377. #ifdef DEBUG_VARS_DECODE
  378.     printf("VARS: Decoding buffer of length %dn", *BufLen);
  379. #endif
  381.     /* Now parse the variables */
  382.     bufp = asn_parse_header(Buffer, &AllVarLen, &VarBindType);
  383.     if (bufp == NULL)
  384. ASN_PARSE_ERROR(NULL);
  386.     if (VarBindType != (u_char) (ASN_SEQUENCE | ASN_CONSTRUCTOR)) {
  387. snmp_set_api_error(SNMPERR_PDU_PARSE);
  388. ASN_PARSE_ERROR(NULL);
  389.     }
  390. #ifdef DEBUG_VARS_DECODE
  391.     printf("VARS: All Variable length %dn", AllVarLen);
  392. #endif
  394.     /* We know how long the variable list is.  Parse it. */
  395.     while ((int) AllVarLen > 0) {
  397. /* Create a new variable */
  398. Var = snmp_var_new(NULL, MAX_NAME_LEN);
  399. if (Var == NULL)
  400.     return (NULL);
  402. /* Parse the header to find out the length of this variable. */
  403. ThisVarLen = AllVarLen;
  404. tmp = asn_parse_header(bufp, &ThisVarLen, &VarBindType);
  405. if (tmp == NULL)
  406.     ASN_PARSE_ERROR(NULL);
  408. /* Now that we know the length , figure out how it relates to 
  409.  * the entire variable list
  410.  */
  411. AllVarLen = AllVarLen - (ThisVarLen + (tmp - bufp));
  412. bufp = tmp;
  414. /* Is it valid? */
  415. if (VarBindType != (u_char) (ASN_SEQUENCE | ASN_CONSTRUCTOR)) {
  416.     snmp_set_api_error(SNMPERR_PDU_PARSE);
  417.     ASN_PARSE_ERROR(NULL);
  418. }
  419. #ifdef DEBUG_VARS_DECODE
  420. printf("VARS: Header type 0x%x (%d bytes left)n", VarBindType, ThisVarLen);
  421. #endif
  423. /* Parse the OBJID */
  424. bufp = asn_parse_objid(bufp, &ThisVarLen, &VarBindType,
  425.     Var->name, &(Var->name_length));
  426. if (bufp == NULL)
  427.     ASN_PARSE_ERROR(NULL);
  429. if (VarBindType != (u_char) (ASN_UNIVERSAL |
  430. ASN_PRIMITIVE |
  431. ASN_OBJECT_ID)) {
  432.     snmp_set_api_error(SNMPERR_PDU_PARSE);
  433.     ASN_PARSE_ERROR(NULL);
  434. }
  435. #ifdef DEBUG_VARS_DECODE
  436. printf("VARS: Decoded OBJID (%d bytes). (%d bytes left)n",
  437.     Var->name_length, ThisVarLen);
  438. #endif
  440. /* Keep a pointer to this object */
  441. DataPtr = bufp;
  442. DataLen = ThisVarLen;
  444. /* find out type of object */
  445. bufp = asn_parse_header(bufp, &ThisVarLen, &(Var->type));
  446. if (bufp == NULL)
  447.     ASN_PARSE_ERROR(NULL);
  448. ThisVarLen = DataLen;
  450. #ifdef DEBUG_VARS_DECODE
  451. printf("VARS: Data type %dn", Var->type);
  452. #endif
  454. /* Parse the type */
  456. switch ((short) Var->type) {
  458. case ASN_INTEGER:
  459.     Var->val.integer = (int *) xmalloc(sizeof(int));
  460.     if (Var->val.integer == NULL) {
  461. snmp_set_api_error(SNMPERR_OS_ERR);
  462. return (NULL);
  463.     }
  464.     Var->val_len = sizeof(int);
  465.     bufp = asn_parse_int(DataPtr, &ThisVarLen,
  466. &Var->type, (int *) Var->val.integer,
  467. Var->val_len);
  468. #ifdef DEBUG_VARS_DECODE
  469.     printf("VARS: Decoded integer '%d' (%d bytes left)n",
  470. *(Var->val.integer), ThisVarLen);
  471. #endif
  472.     break;
  474. case SMI_COUNTER32:
  475. case SMI_GAUGE32:
  476.     /*  case SMI_UNSIGNED32: */
  477. case SMI_TIMETICKS:
  478.     Var->val.integer = (int *) xmalloc(sizeof(u_int));
  479.     if (Var->val.integer == NULL) {
  480. snmp_set_api_error(SNMPERR_OS_ERR);
  481. return (NULL);
  482.     }
  483.     Var->val_len = sizeof(u_int);
  484.     bufp = asn_parse_unsigned_int(DataPtr, &ThisVarLen,
  485. &Var->type, (u_int *) Var->val.integer,
  486. Var->val_len);
  487. #ifdef DEBUG_VARS_DECODE
  488.     printf("VARS: Decoded timeticks '%d' (%d bytes left)n",
  489. *(Var->val.integer), ThisVarLen);
  490. #endif
  491.     break;
  493. case ASN_OCTET_STR:
  494. case SMI_IPADDRESS:
  495. case SMI_OPAQUE:
  496.     Var->val_len = *&ThisVarLen; /* String is this at most */
  497.     Var->val.string = (u_char *) xmalloc((unsigned) Var->val_len);
  498.     if (Var->val.string == NULL) {
  499. snmp_set_api_error(SNMPERR_OS_ERR);
  500. return (NULL);
  501.     }
  502.     bufp = asn_parse_string(DataPtr, &ThisVarLen,
  503. &Var->type, Var->val.string,
  504. &Var->val_len);
  505. #ifdef DEBUG_VARS_DECODE
  506.     printf("VARS: Decoded string '%s' (length %d) (%d bytes left)n",
  507. (Var->val.string), Var->val_len, ThisVarLen);
  508. #endif
  509.     break;
  511. case ASN_OBJECT_ID:
  512.     Var->val_len = MAX_NAME_LEN;
  513.     bufp = asn_parse_objid(DataPtr, &ThisVarLen,
  514. &Var->type, TmpBuf, &Var->val_len);
  515.     Var->val_len *= sizeof(oid);
  516.     Var->val.objid = (oid *) xmalloc((unsigned) Var->val_len);
  517.     if (Var->val.integer == NULL) {
  518. snmp_set_api_error(SNMPERR_OS_ERR);
  519. return (NULL);
  520.     }
  521.     /* Only copy if we successfully decoded something */
  522.     if (bufp) {
  523. xmemcpy((char *) Var->val.objid, (char *) TmpBuf, Var->val_len);
  524.     }
  525. #ifdef DEBUG_VARS_DECODE
  526.     printf("VARS: Decoded OBJID (length %d) (%d bytes left)n",
  527. Var->val_len, ThisVarLen);
  528. #endif
  529.     break;
  531. case ASN_NULL:
  532. case SMI_NOSUCHINSTANCE:
  533. case SMI_NOSUCHOBJECT:
  534. case SMI_ENDOFMIBVIEW:
  535.     break;
  537. case SMI_COUNTER64:
  538.     snmplib_debug(2, "Unable to parse type SMI_COUNTER64!n");
  539.     snmp_set_api_error(SNMPERR_UNSUPPORTED_TYPE);
  540.     return (NULL);
  541.     break;
  543. default:
  544.     snmplib_debug(2, "bad type returned (%x)n", Var->type);
  545.     snmp_set_api_error(SNMPERR_PDU_PARSE);
  546.     return (NULL);
  547.     break;
  548. } /* End of var type switch */
  550. if (bufp == NULL)
  551.     return (NULL);
  553. #ifdef DEBUG_VARS_DECODE
  554. printf("VARS:  Adding to list.n");
  555. #endif
  556. /* Add variable to the list */
  557. *VarLastP = Var;
  558. VarLastP = &(Var->next_variable);
  559.     }
  561.     return (bufp);
  562. }