home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1994 March / Source_Code_CD-ROM_Walnut_Creek_March_1994.iso / compsrcs / misc / volume40 / netramet / part18 < prev    next >
Encoding:
Text File  |  1993-11-07  |  63.8 KB  |  1,696 lines
  1. Newsgroups: comp.sources.misc
  2. From: nevil@ccu1.aukuni.ac.nz (J Nevil Brownlee)
  3. Subject: v40i106:  netramet - Network Traffic Accounting Meter, Part18/25
  4. Message-ID: <1993Nov7.221348.12493@sparky.sterling.com>
  5. X-Md4-Signature: 9142c693dfcf3aa7a22d10a4dff5b170
  6. Sender: kent@sparky.sterling.com (Kent Landfield)
  7. Organization: Sterling Software
  8. Date: Sun, 7 Nov 1993 22:13:48 GMT
  9. Approved: kent@sparky.sterling.com
  10.  
  11. Submitted-by: nevil@ccu1.aukuni.ac.nz (J Nevil Brownlee)
  12. Posting-number: Volume 40, Issue 106
  13. Archive-name: netramet/part18
  14. Environment: INET, UNIX, DOS
  15.  
  16. #! /bin/sh
  17. # This is a shell archive.  Remove anything before this line, then feed it
  18. # into a shell via "sh file" or similar.  To overwrite existing files,
  19. # type "sh file -c".
  20. # Contents:  netramet/src/manager/nmc_snmp.c
  21. #   netramet/src/snmplib/~snmp_vars.c.kip
  22. # Wrapped by kent@sparky on Tue Nov  2 18:17:10 1993
  23. PATH=/bin:/usr/bin:/usr/ucb:/usr/local/bin:/usr/lbin:$PATH ; export PATH
  24. echo If this archive is complete, you will see the following message:
  25. echo '          "shar: End of archive 18 (of 25)."'
  26. if test -f 'netramet/src/manager/nmc_snmp.c' -a "${1}" != "-c" ; then 
  27.   echo shar: Will not clobber existing file \"'netramet/src/manager/nmc_snmp.c'\"
  28. else
  29.   echo shar: Extracting \"'netramet/src/manager/nmc_snmp.c'\" \(27166 characters\)
  30.   sed "s/^X//" >'netramet/src/manager/nmc_snmp.c' <<'END_OF_FILE'
  31. X/* 1427, Wed 5 Oct 93
  32. X
  33. X   NMC_SNMP.C:  NMC's SNMP interface with the meter
  34. X
  35. X   Copyright (C) 1992,1993 by Nevil Brownlee,
  36. X   Computer Centre,  University of Auckland */
  37. X
  38. X/***********************************************************
  39. X    Copyright 1988 by Carnegie Mellon University
  40. X
  41. X                      All Rights Reserved
  42. X
  43. XPermission to use, copy, modify, and distribute this software and its 
  44. Xdocumentation for any purpose and without fee is hereby granted, 
  45. Xprovided that the above copyright notice appear in all copies and that
  46. Xboth that copyright notice and this permission notice appear in 
  47. Xsupporting documentation, and that the name of CMU not be
  48. Xused in advertising or publicity pertaining to distribution of the
  49. Xsoftware without specific, written prior permission.  
  50. X
  51. XCMU DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  52. XALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  53. XCMU BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  54. XANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  55. XWHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  56. XARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  57. XSOFTWARE.
  58. X******************************************************************/
  59. X#include <sys/param.h>
  60. X#include <sys/types.h>
  61. X#include <netinet/in.h>
  62. X#include <netdb.h>
  63. X
  64. X#include <stdio.h>
  65. X#include <ctype.h>
  66. X#include <sys/time.h>
  67. X#include <errno.h>
  68. X
  69. X#include <string.h>
  70. X#include <malloc.h>
  71. X
  72. X#include "ausnmp.h"
  73. X
  74. X#include "snmp.h"
  75. X#include "snmpimpl.h"
  76. X#include "asn1.h"
  77. X#include "snmpclnt.h"
  78. X#include "snmpapi.h"
  79. X#include "mib.h"
  80. X
  81. X#include "nmc.h"
  82. X
  83. X#ifndef BSD4_3
  84. X#define BSD4_2
  85. X#endif
  86. X
  87. X
  88. X#define  INT_ACCT    1, 3, 6, 1, 3, 99
  89. X#define  U_AUCKLAND  1, 3, 6, 1, 4, 1, 411
  90. X
  91. Xoid o_sysDescr[]      = {MIB, 1, 1, 0};
  92. Xoid o_sysUpTime[]      = {MIB, 1, 3, 0};
  93. Xoid o_ifNumber[]      = {MIB, 2, 1, 0};
  94. X
  95. Xoid o_HighWaterMark[]     = {INT_ACCT, 1,  1, 0};
  96. Xoid o_FloodMark[]         = {INT_ACCT, 1,  2, 0};
  97. Xoid o_InactivityTimeout[] = {INT_ACCT, 1,  3, 0};
  98. Xoid o_LastCollectTime[]   = {INT_ACCT, 1,  6, 0};
  99. Xoid o_riRuleSize[]        = {INT_ACCT, 1,  7, 1, 2, 0xFF};
  100. Xoid o_riActionSize[]      = {INT_ACCT, 1,  7, 1, 3, 0xFF};
  101. Xoid o_CurrentRuleSet[]    = {INT_ACCT, 1,  8, 0};
  102. Xoid o_EmergencyRuleSet[]  = {INT_ACCT, 1,  9, 0};
  103. X
  104. Xoid o_ftFlowIndex[]            = {INT_ACCT, 2, 1, 1,  1, 0xFFFF};
  105. Xoid o_ftFlowStatus[]           = {INT_ACCT, 2, 1, 1,  2, 0xFFFF};
  106. Xoid o_ftLowInterface[]         = {INT_ACCT, 2, 1, 1,  3, 0xFFFF};
  107. Xoid o_ftLowAdjacentType[]      = {INT_ACCT, 2, 1, 1,  4, 0xFFFF};
  108. Xoid o_ftLowAdjacentAddress[]   = {INT_ACCT, 2, 1, 1,  5, 0xFFFF};
  109. Xoid o_ftLowAdjacentMask[]      = {INT_ACCT, 2, 1, 1,  6, 0xFFFF};
  110. Xoid o_ftLowPeerType[]          = {INT_ACCT, 2, 1, 1,  7, 0xFFFF};
  111. Xoid o_ftLowPeerTypeMask[]      = {INT_ACCT, 2, 1, 1,  8, 0xFFFF};
  112. Xoid o_ftLowPeerAddress[]       = {INT_ACCT, 2, 1, 1,  9, 0xFFFF};
  113. Xoid o_ftLowPeerMask[]          = {INT_ACCT, 2, 1, 1, 10, 0xFFFF};
  114. Xoid o_ftLowDetailType[]        = {INT_ACCT, 2, 1, 1, 11, 0xFFFF};
  115. Xoid o_ftLowDetailTypeMask[]    = {INT_ACCT, 2, 1, 1, 12, 0xFFFF};
  116. Xoid o_ftLowDetailAddress[]     = {INT_ACCT, 2, 1, 1, 13, 0xFFFF};
  117. Xoid o_ftLowDetailMask[]        = {INT_ACCT, 2, 1, 1, 14, 0xFFFF};
  118. Xoid o_ftHighInterface[]        = {INT_ACCT, 2, 1, 1, 17, 0xFFFF};
  119. Xoid o_ftHighAdjacentType[]     = {INT_ACCT, 2, 1, 1, 18, 0xFFFF};
  120. Xoid o_ftHighAdjacentAddress[]  = {INT_ACCT, 2, 1, 1, 19, 0xFFFF};
  121. Xoid o_ftHighAdjacentMask[]     = {INT_ACCT, 2, 1, 1, 20, 0xFFFF};
  122. Xoid o_ftHighPeerType[]         = {INT_ACCT, 2, 1, 1, 21, 0xFFFF};
  123. Xoid o_ftHighPeerTypeMask[]     = {INT_ACCT, 2, 1, 1, 22, 0xFFFF};
  124. Xoid o_ftHighPeerAddress[]      = {INT_ACCT, 2, 1, 1, 23, 0xFFFF};
  125. Xoid o_ftHighPeerMask[]         = {INT_ACCT, 2, 1, 1, 24, 0xFFFF};
  126. Xoid o_ftHighDetailType[]       = {INT_ACCT, 2, 1, 1, 25, 0xFFFF};
  127. Xoid o_ftHighDetailTypeMask[]   = {INT_ACCT, 2, 1, 1, 26, 0xFFFF};
  128. Xoid o_ftHighDetailAddress[]    = {INT_ACCT, 2, 1, 1, 27, 0xFFFF};
  129. Xoid o_ftHighDetailMask[]       = {INT_ACCT, 2, 1, 1, 28, 0xFFFF};
  130. Xoid o_ftPDUScale[]             = {INT_ACCT, 2, 1, 1, 33, 0xFFFF};
  131. Xoid o_ftOctetScale[]           = {INT_ACCT, 2, 1, 1, 34, 0xFFFF};
  132. Xoid o_ftRuleSet[]              = {INT_ACCT, 2, 1, 1, 35, 0xFFFF};
  133. Xoid o_ftFlowType[]             = {INT_ACCT, 2, 1, 1, 36, 0xFFFF};
  134. Xoid o_ftUpOctets[]             = {INT_ACCT, 2, 1, 1, 37, 0xFFFF};
  135. Xoid o_ftUpPDUs[]               = {INT_ACCT, 2, 1, 1, 38, 0xFFFF};
  136. Xoid o_ftDownOctets[]           = {INT_ACCT, 2, 1, 1, 39, 0xFFFF};
  137. Xoid o_ftDownPDUs[]             = {INT_ACCT, 2, 1, 1, 40, 0xFFFF};
  138. Xoid o_ftFirstTime[]            = {INT_ACCT, 2, 1, 1, 41, 0xFFFF};
  139. Xoid o_ftLastTime[]             = {INT_ACCT, 2, 1, 1, 42, 0xFFFF};
  140. X
  141. Xoid o_ftCreateTime[]      = {INT_ACCT, 2, 2, 1, 1, 0xFFFFFFFF, 0xFFFF};
  142. Xoid o_ftCreateIndex[]      = {INT_ACCT, 2, 2, 1, 2, 0xFFFFFFFF, 0xFFFF};
  143. X
  144. Xoid o_ftActiveTime[]      = {INT_ACCT, 2, 3, 1, 1, 0xFFFFFFFF, 0xFFFF};
  145. Xoid o_ftActiveIndex[]      = {INT_ACCT, 2, 3, 1, 2, 0xFFFFFFFF, 0xFFFF};
  146. Xoid o_ftActiveFlowBlob[]  = {INT_ACCT, 2, 3, 1, 3, 0xFFFFFFFF, 0xFFFF};
  147. X
  148. Xoid o_ftColumnBlob[]  = {INT_ACCT, 2, 4, 1, 4, 0xFF, 0xFFFFFFFF, 0xFFFF};
  149. X
  150. Xoid o_rtSelector[]        = {INT_ACCT, 3, 1, 1, 3, 0xFF, 0xFFFF};
  151. Xoid o_rtRuleMask[]        = {INT_ACCT, 3, 1, 1, 4, 0xFF, 0xFFFF};
  152. Xoid o_rtMatchedValue[]    = {INT_ACCT, 3, 1, 1, 5, 0xFF, 0xFFFF};
  153. Xoid o_rtRuleAction[]      = {INT_ACCT, 3, 1, 1, 6, 0xFF, 0xFFFF};
  154. Xoid o_rtJumpIndex[]       = {INT_ACCT, 3, 1, 1, 7, 0xFF, 0xFFFF};
  155. X
  156. Xoid o_atLowInterface[]         = {INT_ACCT, 4, 1, 1,  3, 0xFF, 0xFFFF};
  157. Xoid o_atLowAdjacentType[]      = {INT_ACCT, 4, 1, 1,  4, 0xFF, 0xFFFF};
  158. Xoid o_atLowAdjacentAddress[]   = {INT_ACCT, 4, 1, 1,  5, 0xFF, 0xFFFF};
  159. Xoid o_atLowAdjacentMask[]      = {INT_ACCT, 4, 1, 1,  6, 0xFF, 0xFFFF};
  160. Xoid o_atLowPeerType[]          = {INT_ACCT, 4, 1, 1,  7, 0xFF, 0xFFFF};
  161. Xoid o_atLowPeerTypeMask[]      = {INT_ACCT, 4, 1, 1,  8, 0xFF, 0xFFFF};
  162. Xoid o_atLowPeerAddress[]       = {INT_ACCT, 4, 1, 1,  9, 0xFF, 0xFFFF};
  163. Xoid o_atLowPeerMask[]          = {INT_ACCT, 4, 1, 1, 10, 0xFF, 0xFFFF};
  164. Xoid o_atLowDetailType[]        = {INT_ACCT, 4, 1, 1, 11, 0xFF, 0xFFFF};
  165. Xoid o_atLowDetailTypeMask[]    = {INT_ACCT, 4, 1, 1, 12, 0xFF, 0xFFFF};
  166. Xoid o_atLowDetailAddress[]     = {INT_ACCT, 4, 1, 1, 13, 0xFF, 0xFFFF};
  167. Xoid o_atLowDetailMask[]        = {INT_ACCT, 4, 1, 1, 14, 0xFF, 0xFFFF};
  168. Xoid o_atHighInterface[]        = {INT_ACCT, 4, 1, 1, 17, 0xFF, 0xFFFF};
  169. Xoid o_atHighAdjacentType[]     = {INT_ACCT, 4, 1, 1, 18, 0xFF, 0xFFFF};
  170. Xoid o_atHighAdjacentAddress[]  = {INT_ACCT, 4, 1, 1, 19, 0xFF, 0xFFFF};
  171. Xoid o_atHighAdjacentMask[]     = {INT_ACCT, 4, 1, 1, 20, 0xFF, 0xFFFF};
  172. Xoid o_atHighPeerType[]         = {INT_ACCT, 4, 1, 1, 21, 0xFF, 0xFFFF};
  173. Xoid o_atHighPeerTypeMask[]     = {INT_ACCT, 4, 1, 1, 22, 0xFF, 0xFFFF};
  174. Xoid o_atHighPeerAddress[]      = {INT_ACCT, 4, 1, 1, 23, 0xFF, 0xFFFF};
  175. Xoid o_atHighPeerMask[]         = {INT_ACCT, 4, 1, 1, 24, 0xFF, 0xFFFF};
  176. Xoid o_atHighDetailType[]       = {INT_ACCT, 4, 1, 1, 25, 0xFF, 0xFFFF};
  177. Xoid o_atHighDetailTypeMask[]   = {INT_ACCT, 4, 1, 1, 26, 0xFF, 0xFFFF};
  178. Xoid o_atHighDetailAddress[]    = {INT_ACCT, 4, 1, 1, 27, 0xFF, 0xFFFF};
  179. Xoid o_atHighDetailMask[]       = {INT_ACCT, 4, 1, 1, 28, 0xFF, 0xFFFF};
  180. Xoid o_atPDUScale[]             = {INT_ACCT, 4, 1, 1, 33, 0xFF, 0xFFFF};
  181. Xoid o_atOctetScale[]           = {INT_ACCT, 4, 1, 1, 34, 0xFF, 0xFFFF};
  182. Xoid o_atRuleSet[]              = {INT_ACCT, 4, 1, 1, 35, 0xFF, 0xFFFF};
  183. X
  184. Xoid o_msStatsReset[]      = {U_AUCKLAND, 1,  1, 0};
  185. Xoid o_msStatsTime[]       = {U_AUCKLAND, 1,  2, 0};
  186. Xoid o_msNbrPackets[]      = {U_AUCKLAND, 1,  3, 0};
  187. Xoid o_msTotPktBacklog[]   = {U_AUCKLAND, 1,  4, 0};
  188. Xoid o_msMaxPktRate[]      = {U_AUCKLAND, 1,  5, 0};
  189. Xoid o_msMaxPktBacklog[]   = {U_AUCKLAND, 1,  6, 0};
  190. Xoid o_msNbrFlows[]        = {U_AUCKLAND, 1,  7, 0};
  191. Xoid o_msFlowsRecovered[]  = {U_AUCKLAND, 1,  8, 0};
  192. Xoid o_msRuleMatches[]     = {U_AUCKLAND, 1,  9, 0};
  193. Xoid o_msHashSearches[]    = {U_AUCKLAND, 1, 10, 0};
  194. Xoid o_msHashCompares[]    = {U_AUCKLAND, 1, 11, 0};
  195. Xoid o_msTotalHashSize[]   = {U_AUCKLAND, 1, 12, 0};
  196. Xoid o_msNbrHashEntries[]  = {U_AUCKLAND, 1, 13, 0};
  197. Xoid o_msGCInterval[]      = {U_AUCKLAND, 1, 14, 0};
  198. Xoid o_msMaxFlows[]        = {U_AUCKLAND, 1, 15, 0};
  199. Xoid o_msAvIdle1000[]      = {U_AUCKLAND, 1, 16, 0};
  200. Xoid o_msMinIdle1000[]     = {U_AUCKLAND, 1, 17, 0};
  201. X
  202. Xoid o_pcNearMem[]         = {U_AUCKLAND, 2, 1, 0};
  203. Xoid o_pcFarMem[]          = {U_AUCKLAND, 2, 2, 0};
  204. Xoid o_pcBadPackets[]      = {U_AUCKLAND, 2, 3, 0};
  205. Xoid o_pcNoBufPackets[]    = {U_AUCKLAND, 2, 4, 0};
  206. Xoid o_pcLostPackets[]     = {U_AUCKLAND, 2, 5, 0};
  207. X
  208. X
  209. Xint start_snmp_session(struct meter_status *ms)
  210. X{
  211. X   struct snmp_session session, *ssp;
  212. X
  213. X   bzero((char *)&session, sizeof(struct snmp_session));
  214. X   session.peername = ms->name;
  215. X   session.community = ms->community;
  216. X   session.community_len = strlen((char *)ms->community);
  217. X   session.retries = SNMP_DEFAULT_RETRIES;
  218. X   session.timeout = SNMP_DEFAULT_TIMEOUT;
  219. X   session.authenticator = NULL;
  220. X   snmp_synch_setup(&session);
  221. X   ssp = snmp_open(&session);
  222. X   if (ssp == NULL) {
  223. X      printf("Couldn't open snmp to %s\n", session.peername);
  224. X      return 0;
  225. X      }
  226. X   ms->ss = ssp;
  227. X   return 1;
  228. X   }
  229. X
  230. X#define ADD_VAR(v)            snmp_add_null_var(pdu, v, sizeof(v)/sizeof(oid))
  231. X#define ADD_X_VAR(v,n1)         { v[sizeof(v)/sizeof(oid) - 1] = n1; \
  232. X            ADD_VAR(v); }
  233. X#define ADD_X2_VAR(v,n1,n2)     { v[sizeof(v)/sizeof(oid) - 2] = n1; \
  234. X            v[sizeof(v)/sizeof(oid) - 1] = n2; \
  235. X            ADD_VAR(v); }
  236. X#define ADD_X3_VAR(v,n1,n2,n3)  { v[sizeof(v)/sizeof(oid) - 3] = n1; \
  237. X            v[sizeof(v)/sizeof(oid) - 2] = n2; \
  238. X            v[sizeof(v)/sizeof(oid) - 1] = n3; \
  239. X            ADD_VAR(v); }
  240. X
  241. X#define SET_INT(v)            { vars->type = INTEGER; \
  242. X          vars->val.integer = (long *)malloc(vars->val_len = sizeof(long)); \
  243. X        *(vars->val.integer) = (long)v; }
  244. X#define SET_TIMETICKS(v)      { vars->type = TIMETICKS; \
  245. X          vars->val.integer = (long *)malloc(vars->val_len = sizeof(long)); \
  246. X        *(vars->val.integer) = (long)v; }
  247. X#define SET_STRING(v,len)     { vars->type = STRING; \
  248. X        vars->val.string = (u_char *)malloc(RULE_ADDR_LEN) ;\
  249. X        bcopy(v, (char *)vars->val.string, vars->val_len = len); }
  250. X
  251. X#define STRING_VAL(v)         bcopy(vars->val.string, v, vars->val_len)
  252. X#define INT_VAL(v)            v = *(vars->val.integer)
  253. X
  254. X
  255. Xint set_meter_params(struct meter_status *ms)
  256. X{
  257. X   int i, count, status;
  258. X   struct snmp_pdu *pdu, *response;
  259. X   struct variable_list *vars;
  260. X
  261. X   if (ms->GCIntervalReqd == 0 && ms->HighWaterMark == 0 && 
  262. X      ms->InactivityTime == 0) return 1;  /* Nothing to do */
  263. X
  264. X   pdu = snmp_pdu_create(SET_REQ_MSG);
  265. X   i = 0;
  266. X   if (ms->GCInterval != 0) {
  267. X      ADD_VAR(o_msGCInterval);
  268. X      vars = pdu->variables;  i = 1;
  269. X      SET_INT(ms->GCIntervalReqd);
  270. X      }
  271. X   if (ms->HighWaterMark != 0) {
  272. X      ADD_VAR(o_HighWaterMark);
  273. X      vars = i ? vars->next_variable : pdu->variables;  i = 1;
  274. X      SET_INT(ms->HighWaterMark);
  275. X      }
  276. X   if (ms->InactivityTime != 0) {
  277. X      ADD_VAR(o_InactivityTimeout);
  278. X      vars = i ? vars->next_variable : pdu->variables;
  279. X      SET_INT(ms->InactivityTime);
  280. X      }
  281. X
  282. X   status = snmp_synch_response(ms->ss, pdu, &response);
  283. X   if (status == STAT_SUCCESS) {
  284. X      if (response->errstat == SNMP_ERR_NOERROR) {
  285. X         if (verbose) printf("Meter parameters set: GCI=%u, HWM=%u, IAT=%u\n",
  286. X            ms->GCIntervalReqd,ms->HighWaterMark,ms->InactivityTime);
  287. X         fprintf(log, "Meter parameters set: GCI=%u, HWM=%u, IAT=%u\n",
  288. X            ms->GCIntervalReqd,ms->HighWaterMark,ms->InactivityTime);
  289. X         fflush(log);
  290. X     }
  291. X      else {
  292. X     printf("Error in packet, reason = %s\n",
  293. X        snmp_errstring(response->errstat));
  294. X     if (response->errstat == SNMP_ERR_NOSUCHNAME) {
  295. X        printf("This name does not exist: ");
  296. X        for (count=1, vars = response->variables;
  297. X           vars && count != response->errindex;
  298. X          vars = vars->next_variable, count++) ;
  299. X        if (vars) print_objid(vars->name, vars->name_length);
  300. X        printf("\n");
  301. X        }
  302. X     }
  303. X      }
  304. X   else return 0;
  305. X   snmp_free_pdu(response);
  306. X   mswait(ms->snmp_delay);
  307. X   return 1;
  308. X   }
  309. X
  310. Xint set_collect_time(ms,v)  /* Set LastCollectTime for meter - */
  311. Xstruct meter_status *ms;  /* this tells meter a collection is starting */
  312. Xint v;
  313. X{
  314. X   int i, count, status;
  315. X   struct snmp_pdu *pdu, *response;
  316. X   struct variable_list *vars;
  317. X   pdu = snmp_pdu_create(SET_REQ_MSG);
  318. X   ADD_VAR(o_LastCollectTime);
  319. X   vars = pdu->variables;
  320. X   SET_TIMETICKS(v);
  321. X
  322. X   status = snmp_synch_response(ms->ss, pdu, &response);
  323. X   if (status == STAT_SUCCESS) {
  324. X      if (response->errstat == SNMP_ERR_NOERROR) {
  325. X         printf("Set %d: starting collection\n", ms->ruleset);
  326. X     }
  327. X      else {
  328. X     printf("Error in packet, reason = %s\n",
  329. X        snmp_errstring(response->errstat));
  330. X     if (response->errstat == SNMP_ERR_NOSUCHNAME) {
  331. X        printf("This name does not exist: ");
  332. X        for (count=1, vars = response->variables;
  333. X           vars && count != response->errindex;
  334. X          vars = vars->next_variable, count++) ;
  335. X        if (vars) print_objid(vars->name, vars->name_length);
  336. X        printf("\n");
  337. X        }
  338. X     }
  339. X      }
  340. X   else return 0;
  341. X   snmp_free_pdu(response);
  342. X   mswait(ms->snmp_delay);
  343. X   return 1;
  344. X   }
  345. X
  346. Xint set_rule_info(ms,setset)  /* 1 to set rule+action set */
  347. Xstruct meter_status *ms;      /* 0 to set rule and actions tables sizes */
  348. Xint setset;
  349. X{
  350. X   int i, count, status;
  351. X   struct snmp_pdu *pdu, *response;
  352. X   struct variable_list *vars;
  353. X   pdu = snmp_pdu_create(SET_REQ_MSG);
  354. X   if (setset) {
  355. X      ADD_VAR(o_CurrentRuleSet);
  356. X         vars = pdu->variables;
  357. X         SET_INT(ms->ruleset);
  358. X      }
  359. X   else {
  360. X      ADD_X_VAR(o_riRuleSize, ms->ruleset);
  361. X         vars = pdu->variables;
  362. X         SET_INT(ms->nrules);
  363. X      ADD_X_VAR(o_riActionSize, ms->ruleset);
  364. X         vars = vars->next_variable;
  365. X         SET_INT(ms->nactions);
  366. X      }
  367. X
  368. X   status = snmp_synch_response(ms->ss, pdu, &response);
  369. X   if (status == STAT_SUCCESS) {
  370. X      if (response->errstat == SNMP_ERR_NOERROR) {
  371. X         if (setset) printf(
  372. X            "Meter is now using rule+action set %d\n", ms->ruleset);
  373. X         else printf("Set %d: sizes set to %d rules + %d actions\n", 
  374. X            ms->ruleset,ms->nrules,ms->nactions);
  375. X     }
  376. X      else {
  377. X     printf("Error in packet, reason = %s\n",
  378. X        snmp_errstring(response->errstat));
  379. X     if (response->errstat == SNMP_ERR_NOSUCHNAME) {
  380. X        printf("This name does not exist: ");
  381. X        for (count=1, vars = response->variables;
  382. X           vars && count != response->errindex;
  383. X          vars = vars->next_variable, count++) ;
  384. X        if (vars) print_objid(vars->name, vars->name_length);
  385. X        printf("\n");
  386. X        }
  387. X     }
  388. X      }
  389. X   else return 0;
  390. X   snmp_free_pdu(response);
  391. X   mswait(ms->snmp_delay);
  392. X   return 1;
  393. X   }
  394. X
  395. Xint add_rule(ms,ri)
  396. Xstruct meter_status *ms;
  397. Xstruct rule_info *ri;
  398. X{
  399. X   int i, count, status;
  400. X   struct snmp_pdu *pdu, *response;
  401. X   struct variable_list *vars;
  402. X
  403. X   pdu = snmp_pdu_create(SET_REQ_MSG);
  404. X   ADD_X2_VAR(o_rtSelector, ri->RuleSet,ri->RuleNbr);
  405. X      vars = pdu->variables;
  406. X      SET_INT(ri->RuleSelector);
  407. X   ADD_X2_VAR(o_rtRuleMask, ri->RuleSet,ri->RuleNbr);
  408. X      vars = vars->next_variable;
  409. X      SET_STRING(ri->RuleMask,RULE_ADDR_LEN);
  410. X   ADD_X2_VAR(o_rtMatchedValue, ri->RuleSet,ri->RuleNbr);
  411. X      vars = vars->next_variable;
  412. X      SET_STRING(ri->RuleMatchedValue,RULE_ADDR_LEN);
  413. X   ADD_X2_VAR(o_rtRuleAction, ri->RuleSet,ri->RuleNbr);
  414. X      vars = vars->next_variable;
  415. X      SET_INT(ri->RuleAction);
  416. X   ADD_X2_VAR(o_rtJumpIndex, ri->RuleSet,ri->RuleNbr);
  417. X      vars = vars->next_variable;
  418. X      SET_INT(ri->RuleJumpIndex);
  419. X
  420. X   status = snmp_synch_response(ms->ss, pdu, &response);
  421. X   if (status == STAT_SUCCESS) {
  422. X      if (response->errstat == SNMP_ERR_NOERROR) {
  423. X         printf("Rule %d added to table %d\n", ri->RuleNbr,ri->RuleSet);
  424. X     }
  425. X      else {
  426. X     printf("Error in packet, reason = %s\n",
  427. X        snmp_errstring(response->errstat));
  428. X     if (response->errstat == SNMP_ERR_NOSUCHNAME) {
  429. X        printf("This name does not exist: ");
  430. X        for (count=1, vars = response->variables;
  431. X           vars && count != response->errindex;
  432. X          vars = vars->next_variable, count++) ;
  433. X        if (vars) print_objid(vars->name, vars->name_length);
  434. X        printf("\n");
  435. X        }
  436. X     }
  437. X      }
  438. X   else return 0;
  439. X   snmp_free_pdu(response);
  440. X   mswait(ms->snmp_delay);
  441. X   return 1;
  442. X   }
  443. X
  444. Xint add_action(struct meter_status *ms, struct flow_info *ai,
  445. X   unsigned char ActionSet,unsigned char ActionNbr,
  446. X   unsigned char *required)
  447. X{
  448. X   int i, count, status;
  449. X   struct snmp_pdu *pdu, *response;
  450. X   struct variable_list *vars;
  451. X
  452. X   pdu = snmp_pdu_create(SET_REQ_MSG);
  453. X   ADD_X2_VAR(o_atLowPeerType, ActionSet,ActionNbr);
  454. X      vars = pdu->variables;
  455. X      SET_INT(ai->LowPeerType);
  456. X
  457. X   if (required[FTLOWINTERFACE]) {
  458. X      ADD_X2_VAR(o_atLowInterface, ActionSet,ActionNbr);
  459. X      vars = vars->next_variable;
  460. X      SET_INT(ai->LowInterface);
  461. X      }
  462. X   if (required[FTLOWADJACENTTYPE]) {
  463. X      ADD_X2_VAR(o_atLowAdjacentType, ActionSet,ActionNbr);
  464. X      vars = vars->next_variable;
  465. X      SET_INT(ai->LowAdjType);
  466. X      }
  467. X   if (required[FTLOWADJACENTADDRESS]) {
  468. X      ADD_X2_VAR(o_atLowAdjacentAddress, ActionSet,ActionNbr);
  469. X      vars = vars->next_variable;
  470. X      SET_STRING(ai->LowAdjAddress,MAC_ADDR_LEN);
  471. X      }
  472. X   if (required[FTLOWADJACENTMASK]) {
  473. X       ADD_X2_VAR(o_atLowAdjacentMask, ActionSet,ActionNbr);
  474. X      vars = vars->next_variable;
  475. X      SET_STRING(ai->LowAdjMask,MAC_ADDR_LEN);
  476. X      }
  477. X   if (required[FTLOWPEERTYPEMASK]) {
  478. X      ADD_X2_VAR(o_atLowPeerTypeMask, ActionSet,ActionNbr);
  479. X      vars = vars->next_variable;
  480. X      SET_INT(ai->LowPeerTypeMask);
  481. X      }
  482. X   if (required[FTLOWPEERADDRESS]) {
  483. X      ADD_X2_VAR(o_atLowPeerAddress, ActionSet,ActionNbr);
  484. X      vars = vars->next_variable;
  485. X      SET_STRING(ai->LowPeerAddress,PEER_ADDR_LEN);
  486. X      }
  487. X   if (required[FTLOWPEERMASK]) {
  488. X      ADD_X2_VAR(o_atLowPeerMask, ActionSet,ActionNbr);
  489. X      vars = vars->next_variable;
  490. X      SET_STRING(ai->LowPeerMask,PEER_ADDR_LEN);
  491. X      }
  492. X   if (required[FTLOWDETAILTYPE]) {
  493. X      ADD_X2_VAR(o_atLowDetailType, ActionSet,ActionNbr);
  494. X      vars = vars->next_variable;
  495. X      SET_INT(ai->LowDetailType);
  496. X      }
  497. X   if (required[FTLOWDETAILTYPEMASK]) {
  498. X      ADD_X2_VAR(o_atLowDetailTypeMask, ActionSet,ActionNbr);
  499. X      vars = vars->next_variable;
  500. X      SET_INT(ai->LowDetailTypeMask);
  501. X      }
  502. X   if (required[FTLOWDETAILADDRESS]) {
  503. X      ADD_X2_VAR(o_atLowDetailAddress, ActionSet,ActionNbr);
  504. X      vars = vars->next_variable;
  505. X      SET_STRING(ai->LowDetailAddress,DETAIL_ADDR_LEN);
  506. X      }
  507. X   if (required[FTLOWDETAILMASK]) {
  508. X      ADD_X2_VAR(o_atLowDetailMask, ActionSet,ActionNbr);
  509. X      vars = vars->next_variable;
  510. X      SET_STRING(ai->LowDetailMask,DETAIL_ADDR_LEN);
  511. X      }
  512. X   if (required[FTHIINTERFACE]) {
  513. X      ADD_X2_VAR(o_atHighInterface, ActionSet,ActionNbr);
  514. X      vars = vars->next_variable;
  515. X      SET_INT(ai->HighInterface);
  516. X      }
  517. X   if (required[FTHIADJACENTTYPE]) {
  518. X      ADD_X2_VAR(o_atHighAdjacentType, ActionSet,ActionNbr);
  519. X      vars = vars->next_variable;
  520. X      SET_INT(ai->HighAdjType);
  521. X      }
  522. X   if (required[FTHIADJACENTADDRESS]) {
  523. X      ADD_X2_VAR(o_atHighAdjacentAddress, ActionSet,ActionNbr);
  524. X      vars = vars->next_variable;
  525. X      SET_STRING(ai->HighAdjAddress,MAC_ADDR_LEN);
  526. X      }
  527. X   if (required[FTHIADJACENTMASK]) {
  528. X      ADD_X2_VAR(o_atHighAdjacentMask, ActionSet,ActionNbr);
  529. X      vars = vars->next_variable;
  530. X      SET_STRING(ai->HighAdjMask,MAC_ADDR_LEN);
  531. X      }
  532. X   if (required[FTHIPEERTYPE]) {
  533. X      ADD_X2_VAR(o_atHighPeerType, ActionSet,ActionNbr);
  534. X      vars = vars->next_variable;
  535. X      SET_INT(ai->HighPeerType);
  536. X      }
  537. X   if (required[FTHIPEERTYPEMASK]) {
  538. X      ADD_X2_VAR(o_atHighPeerTypeMask, ActionSet,ActionNbr);
  539. X      vars = vars->next_variable;
  540. X      SET_INT(ai->HighPeerTypeMask);
  541. X      }
  542. X   if (required[FTHIPEERADDRESS]) {
  543. X      ADD_X2_VAR(o_atHighPeerAddress, ActionSet,ActionNbr);
  544. X      vars = vars->next_variable;
  545. X      SET_STRING(ai->HighPeerAddress,PEER_ADDR_LEN);
  546. X      }
  547. X   if (required[FTHIPEERMASK]) {
  548. X      ADD_X2_VAR(o_atHighPeerMask, ActionSet,ActionNbr);
  549. X      vars = vars->next_variable;
  550. X      SET_STRING(ai->HighPeerMask,PEER_ADDR_LEN);
  551. X      }
  552. X   if (required[FTHIDETAILTYPE]) {
  553. X      ADD_X2_VAR(o_atHighDetailType, ActionSet,ActionNbr);
  554. X      vars = vars->next_variable;
  555. X      SET_INT(ai->HighDetailType);
  556. X      }
  557. X   if (required[FTHIDETAILTYPEMASK]) {
  558. X      ADD_X2_VAR(o_atHighDetailTypeMask, ActionSet,ActionNbr);
  559. X      vars = vars->next_variable;
  560. X      SET_INT(ai->HighDetailTypeMask);
  561. X      }
  562. X   if (required[FTHIDETAILADDRESS]) {
  563. X      ADD_X2_VAR(o_atHighDetailAddress, ActionSet,ActionNbr);
  564. X      vars = vars->next_variable;
  565. X      SET_STRING(ai->HighDetailAddress,DETAIL_ADDR_LEN);
  566. X      }
  567. X   if (required[FTHIDETAILMASK]) {
  568. X      ADD_X2_VAR(o_atHighDetailMask, ActionSet,ActionNbr);
  569. X      vars = vars->next_variable;
  570. X      SET_STRING(ai->HighDetailMask,DETAIL_ADDR_LEN);
  571. X      }
  572. X
  573. X   status = snmp_synch_response(ms->ss, pdu, &response);
  574. X   if (status == STAT_SUCCESS) {
  575. X      if (response->errstat == SNMP_ERR_NOERROR) {
  576. X         printf("Action %d added to table %d\n", ActionNbr,ActionSet);
  577. X     }
  578. X      else {
  579. X     printf("Error in packet, reason = %s\n",
  580. X        snmp_errstring(response->errstat));
  581. X     if (response->errstat == SNMP_ERR_NOSUCHNAME) {
  582. X        printf("This name does not exist: ");
  583. X        for (count=1, vars = response->variables;
  584. X           vars && count != response->errindex;
  585. X          vars = vars->next_variable, count++) ;
  586. X        if (vars) print_objid(vars->name, vars->name_length);
  587. X        printf("\n");
  588. X        }
  589. X     }
  590. X      }
  591. X   else return 0;
  592. X   snmp_free_pdu(response);
  593. X   mswait(ms->snmp_delay);
  594. X   return 1;
  595. X   }
  596. X
  597. Xint same_acct_oid(oid *a, oid *b)  
  598. X   /* Compare oids for equality within internet-accounting MIB */
  599. X{
  600. X   int j;
  601. X   for (j = 6; j != 10; ++j) {
  602. X      if (a[j] != b[j]) return 0;
  603. X      }
  604. X   return 1;
  605. X   }
  606. X
  607. Xint column_info(struct meter_status *ms, unsigned char *fb,
  608. X   unsigned char a, unsigned long ft, int *fn)
  609. X{
  610. X   int i, count, status;
  611. X   struct snmp_pdu *pdu, *response;
  612. X   struct variable_list *vars;
  613. X   int result;
  614. X
  615. X   if (testing) printf("column_info(ms,fb,a=%d,ft=%lu,fn=%d)\n",a,ft,*fn);
  616. X   pdu = snmp_pdu_create(GETNEXT_REQ_MSG);
  617. X   ADD_X3_VAR(o_ftColumnBlob,a,ft,*fn)
  618. X   status = snmp_synch_response(ms->ss, pdu, &response);
  619. X   if (status == STAT_SUCCESS) {
  620. X      if (response->errstat == SNMP_ERR_NOERROR) {
  621. X     vars = response->variables;
  622. X         if (!same_acct_oid(vars->name,o_ftColumnBlob)) 
  623. X            return 0;  /* No more flows with last-active time > ft */
  624. X     STRING_VAL(fb);  result = vars->val_len;
  625. X     }
  626. X      else if (response->errstat == SNMP_ERR_NOSUCHNAME) return 0;
  627. X      else {
  628. X     printf("Error in packet, reason = %s\n",
  629. X        snmp_errstring(response->errstat));
  630. X     printf("This name does not exist: ");
  631. X     for (count=1, vars = response->variables;
  632. X        vars && count != response->errindex;
  633. X     vars = vars->next_variable, count++) ;
  634. X     if (vars) print_objid(vars->name, vars->name_length);
  635. X     printf("\n");
  636. X         result = 0;
  637. X     }
  638. X      }
  639. X   else return 0;
  640. X   snmp_free_pdu(response);
  641. X   mswait(ms->snmp_delay);
  642. X   return result;
  643. X   }
  644. X
  645. Xint meter_info(ms)
  646. Xstruct meter_status *ms;
  647. X{
  648. X   int i, count, status;
  649. X   struct snmp_pdu *pdu, *response;
  650. X   struct variable_list *vars;
  651. X
  652. X   if (testing) printf("meter_info(ms)\n");
  653. X   pdu = snmp_pdu_create(GET_REQ_MSG);
  654. X   ADD_VAR(o_sysDescr);
  655. X   ADD_VAR(o_sysUpTime);
  656. X   ADD_VAR(o_LastCollectTime);
  657. X   ADD_VAR(o_CurrentRuleSet);
  658. X   ADD_VAR(o_msMaxFlows);
  659. X   if (ms->statsreqd) {
  660. X      ADD_VAR(o_msStatsTime);
  661. X      ADD_VAR(o_msNbrPackets);
  662. X      ADD_VAR(o_msTotPktBacklog);
  663. X      ADD_VAR(o_msMaxPktRate);
  664. X      ADD_VAR(o_msMaxPktBacklog);
  665. X      ADD_VAR(o_msNbrFlows);
  666. X      ADD_VAR(o_msFlowsRecovered);
  667. X      ADD_VAR(o_msRuleMatches);
  668. X      ADD_VAR(o_msHashSearches);
  669. X      ADD_VAR(o_msHashCompares);
  670. X      ADD_VAR(o_msTotalHashSize);
  671. X      ADD_VAR(o_msNbrHashEntries);
  672. X      ADD_VAR(o_msGCInterval);
  673. X      ADD_VAR(o_msAvIdle1000);
  674. X      ADD_VAR(o_msMinIdle1000);
  675. X      ADD_VAR(o_pcLostPackets);
  676. X      }
  677. X
  678. X   status = snmp_synch_response(ms->ss, pdu, &response);
  679. X   if (status == STAT_SUCCESS) {
  680. X      if (response->errstat == SNMP_ERR_NOERROR) {
  681. X     vars = response->variables;
  682. X     STRING_VAL(ms->descr);
  683. X         vars = vars->next_variable;
  684. X     INT_VAL(ms->uptime);
  685. X         vars = vars->next_variable;
  686. X     INT_VAL(ms->LastCollectTime);
  687. X         vars = vars->next_variable;
  688. X     INT_VAL(ms->CurrentRuleSet);
  689. X         vars = vars->next_variable;
  690. X     INT_VAL(ms->MaxFlows);
  691. X         if (ms->statsreqd) {
  692. X            vars = vars->next_variable;
  693. X            INT_VAL(ms->StatsTime);
  694. X            vars = vars->next_variable;
  695. X            INT_VAL(ms->NbrPackets);
  696. X            vars = vars->next_variable;
  697. X            INT_VAL(ms->TotPktBacklog);
  698. X            vars = vars->next_variable;
  699. X            INT_VAL(ms->MaxPktRate);
  700. X            vars = vars->next_variable;
  701. X            INT_VAL(ms->MaxPktBacklog);
  702. X            vars = vars->next_variable;
  703. X            INT_VAL(ms->NbrFlows);
  704. X            vars = vars->next_variable;
  705. X            INT_VAL(ms->FlowsRecovered);
  706. X            vars = vars->next_variable;
  707. X            INT_VAL(ms->RuleMatches);
  708. X            vars = vars->next_variable;
  709. X            INT_VAL(ms->HashSearches);
  710. X            vars = vars->next_variable;
  711. X            INT_VAL(ms->HashCompares);
  712. X            vars = vars->next_variable;
  713. X            INT_VAL(ms->TotalHashSize);
  714. X            vars = vars->next_variable;
  715. X            INT_VAL(ms->NbrHashEntries);
  716. X            vars = vars->next_variable;
  717. X            INT_VAL(ms->GCInterval);
  718. X            vars = vars->next_variable;
  719. X            INT_VAL(ms->AvIdle1000);
  720. X            vars = vars->next_variable;
  721. X            INT_VAL(ms->MinIdle1000);
  722. X            vars = vars->next_variable;
  723. X            INT_VAL(ms->LostPackets);
  724. X            if (testing) printf("  stats read: StatsTime=%lu\n",ms->StatsTime);
  725. X            }
  726. X     }
  727. X      else {
  728. X     printf("Error in packet, reason = %s\n",
  729. X        snmp_errstring(response->errstat));
  730. X     if (response->errstat == SNMP_ERR_NOSUCHNAME) {
  731. X        printf("This name does not exist: ");
  732. X        for (count=1, vars = response->variables;
  733. X           vars && count != response->errindex;
  734. X          vars = vars->next_variable, count++) ;
  735. X        if (vars) print_objid(vars->name, vars->name_length);
  736. X        printf("\n");
  737. X        }
  738. X     }
  739. X      }
  740. X   else return 0;
  741. X   snmp_free_pdu(response);
  742. X   mswait(ms->snmp_delay);
  743. X
  744. X   if (ms->statsreqd) {  /* Zero meter statistics */
  745. X      pdu = snmp_pdu_create(SET_REQ_MSG);
  746. X      ADD_VAR(o_msStatsReset);
  747. X      vars = pdu->variables;
  748. X      SET_INT(1);
  749. X      status = snmp_synch_response(ms->ss, pdu, &response);
  750. X      if (status == STAT_SUCCESS) {
  751. X         if (testing) printf("  stats zeroed\n");
  752. X         if (response->errstat != SNMP_ERR_NOERROR) {
  753. X            printf("Error in packet, reason = %s\n",
  754. X           snmp_errstring(response->errstat));
  755. X        if (response->errstat == SNMP_ERR_NOSUCHNAME) {
  756. X           printf("This name does not exist: ");
  757. X           for (count=1, vars = response->variables;
  758. X              vars && count != response->errindex;
  759. X             vars = vars->next_variable, count++) ;
  760. X           if (vars) print_objid(vars->name, vars->name_length);
  761. X           printf("\n");
  762. X           }
  763. X        }
  764. X         }
  765. X      else return 0;
  766. X      snmp_free_pdu(response);
  767. X      mswait(ms->snmp_delay);
  768. X      }
  769. X   return 1;
  770. X   }
  771. X
  772. END_OF_FILE
  773.   if test 27166 -ne `wc -c <'netramet/src/manager/nmc_snmp.c'`; then
  774.     echo shar: \"'netramet/src/manager/nmc_snmp.c'\" unpacked with wrong size!
  775.   fi
  776.   # end of 'netramet/src/manager/nmc_snmp.c'
  777. fi
  778. if test -f 'netramet/src/snmplib/~snmp_vars.c.kip' -a "${1}" != "-c" ; then 
  779.   echo shar: Will not clobber existing file \"'netramet/src/snmplib/~snmp_vars.c.kip'\"
  780. else
  781.   echo shar: Extracting \"'netramet/src/snmplib/~snmp_vars.c.kip'\" \(33903 characters\)
  782.   sed "s/^X//" >'netramet/src/snmplib/~snmp_vars.c.kip' <<'END_OF_FILE'
  783. X/*
  784. X * snmp_vars.c - return a pointer to the named variable.
  785. X *
  786. X *
  787. X */
  788. X/***********************************************************
  789. X    Copyright 1988, 1989 by Carnegie Mellon University
  790. X
  791. X                      All Rights Reserved
  792. X
  793. XPermission to use, copy, modify, and distribute this software and its 
  794. Xdocumentation for any purpose and without fee is hereby granted, 
  795. Xprovided that the above copyright notice appear in all copies and that
  796. Xboth that copyright notice and this permission notice appear in 
  797. Xsupporting documentation, and that the name of CMU not be
  798. Xused in advertising or publicity pertaining to distribution of the
  799. Xsoftware without specific, written prior permission.  
  800. X
  801. XCMU DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  802. XALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  803. XCMU BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  804. XANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  805. XWHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  806. XARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  807. XSOFTWARE.
  808. X******************************************************************/
  809. X#ifdef KINETICS
  810. X#include "gw.h"
  811. X#include "fp4/pbuf.h"
  812. X#include "fp4/cmdmacro.h"
  813. X#include "ab.h"
  814. X#include "glob.h"
  815. X#endif
  816. X
  817. X#if (defined(unix) && !defined(KINETICS))
  818. X#include <sys/types.h>
  819. X#include <netinet/in.h>
  820. X#ifndef NULL
  821. X#define NULL 0
  822. X#endif
  823. X#endif
  824. X
  825. X
  826. X#include "asn1.h"
  827. X#include "snmp.h"
  828. X#include "snmp_impl.h"
  829. X#include "mib.h"
  830. X#include "inet.h"
  831. X#include "snmp_vars.h"
  832. X/*
  833. X *    Each variable name is placed in the variable table, without the terminating
  834. X * substring that determines the instance of the variable.  When a string is found that
  835. X * is lexicographicly preceded by the input string, the function for that entry is
  836. X * called to find the method of access of the instance of the named variable.  If
  837. X * that variable is not found, NULL is returned, and the search through the table
  838. X * continues (it should stop at the next entry).  If it is found, the function returns
  839. X * a character pointer and a length or a function pointer.  The former is the address
  840. X * of the operand, the latter is an access routine for the variable.
  841. X *
  842. X * u_char *
  843. X * findVar(name, length, exact, var_len, access_method)
  844. X * oid        *name;        IN/OUT - input name requested, output name found
  845. X * int        length;        IN/OUT - number of sub-ids in the in and out oid's
  846. X * int        exact;        IN - TRUE if an exact match was requested.
  847. X * int        len;        OUT - length of variable or 0 if function returned.
  848. X * int        access_method; OUT - 1 if function, 0 if char pointer.
  849. X *
  850. X * accessVar(rw, var, varLen)
  851. X * int        rw;        IN - request to READ or WRITE the variable
  852. X * u_char   *var;   IN/OUT - input or output buffer space
  853. X * int        *varLen;IN/OUT - input and output buffer len
  854. X */
  855. X
  856. Xstruct variable {
  857. X    oid            name[16];        /* object identifier of variable */
  858. X    u_char        namelen;        /* length of above */
  859. X    char        type;        /* type of variable, INTEGER or (octet) STRING */
  860. X    u_char        magic;        /* passed to function as a hint */
  861. X    u_short        acl;        /* access control list for variable */
  862. X    u_char        *(*findVar)();  /* function that finds variable */
  863. X};
  864. X
  865. Xchar        version_descr[30] = "Kinetics FastPath4";
  866. Xoid        version_id[] = {1, 3, 6, 1, 4, 1, 3, 1, 1};
  867. Xint        version_id_len = sizeof(version_id);
  868. Xu_long        uptime;
  869. Xlong        cfg_nnets = MAX_INTERFACES;
  870. Xlong        long_return;
  871. Xu_char        return_buf[64];
  872. X
  873. X
  874. Xstruct mib_ifEntry  mib_ifEntry_proto[MAX_INTERFACES] = {
  875. X    {1, "Kinetics KFPS2 Ethernet", MIB_IFTYPE_ETHERNETCSMACD, 
  876. X        1500, 10000000L, "", 
  877. X    6, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, 
  878. X    {2, "Kinetics KFPS2 Appletalk", MIB_IFTYPE_OTHER,
  879. X        1500, 230000L, "", 
  880. X    3, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
  881. X};
  882. Xstruct mib_ifEntry mib_ifEntry[MAX_INTERFACES];
  883. X
  884. Xstruct mib_ip mib_ip_proto = {
  885. X    1, IPFRAGTTL, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
  886. X};
  887. Xstruct mib_ip mib_ip;
  888. X
  889. X#define ROUTE_DEFAULT    0
  890. X#define ROUTE_LOCAL    1
  891. Xstruct mib_ipRouteEntry mib_ipRouteEntry_proto[2] = {
  892. X    {0, 1, 1, -1, -1, -1, 0, MIB_IPROUTETYPE_REMOTE, MIB_IPROUTEPROTO_LOCAL, 0},    /* default route */
  893. X    {0, 1, 0, -1, -1, -1, 0, MIB_IPROUTETYPE_DIRECT, MIB_IPROUTEPROTO_LOCAL, 0}        /* local route */
  894. X};
  895. Xstruct mib_ipRouteEntry mib_ipRouteEntry[2];
  896. X
  897. Xstruct mib_udp mib_udp_proto = {
  898. X    0, 0, 0, 0
  899. X};
  900. Xstruct mib_udp mib_udp;
  901. X
  902. Xlong    mib_icmpInMsgs;
  903. Xlong    mib_icmpOutMsgs;
  904. Xlong    mib_icmpInErrors;    /* not checked in KIP */
  905. Xlong    mib_icmpOutErrors;    /* not checked in KIP */
  906. Xlong    mib_icmpInCount[ICMP_MAXTYPE + 1];
  907. Xlong    mib_icmpOutCount[ICMP_MAXTYPE + 1];
  908. X
  909. X
  910. Xinit_snmp(){
  911. X    bcopy((char *)mib_ifEntry_proto, (char *)mib_ifEntry, sizeof(mib_ifEntry));
  912. X    bcopy((char *)&mib_ip_proto, (char *)&mib_ip, sizeof(mib_ip));
  913. X    bcopy((char *)mib_ipRouteEntry_proto, (char *)mib_ipRouteEntry, sizeof(mib_ipRouteEntry));
  914. X    bcopy((char *)&mib_udp_proto, (char *)&mib_udp, sizeof(mib_udp));
  915. X}
  916. X
  917. X/*
  918. X * These are byte offsets into their structures.
  919. X * This really should be computed by the compiler, but the
  920. X * compiler I'm using doesn't want to do this.
  921. X */
  922. X#define VERSION_DESCR    0
  923. X#define VERSION_ID    32
  924. X#define CFG_NNETS    48
  925. X#define UPTIME        52
  926. X
  927. X#define IFINDEX        0
  928. X#define IFDESCR        4
  929. X#define IFTYPE        36
  930. X#define IFMTU        40
  931. X#define IFSPEED        44
  932. X#define IFPHYSADDRESS    48
  933. X#define IFADMINSTATUS    60
  934. X#define IFOPERSTATUS    64
  935. X#define IFLASTCHANGE    68
  936. X#define IFINOCTETS    72
  937. X#define IFINUCASTPKTS    76
  938. X#define    IFINNUCASTPKTS    80
  939. X#define    IFINDISCARDS    84
  940. X#define    IFINERRORS    88
  941. X#define    IFINUNKNOWNPROTOS   92
  942. X#define    IFOUTOCTETS    96
  943. X#define    IFOUTUCASTPKTS    100
  944. X#define    IFOUTNUCASTPKTS    104
  945. X#define    IFOUTDISCARDS    108
  946. X#define    IFOUTERRORS    112
  947. X#define    IFOUTQLEN    116
  948. X
  949. X#define ATIFINDEX    0
  950. X#define ATPHYSADDRESS    4
  951. X#define ATNETADDRESS    16
  952. X
  953. X#define IPFORWARDING    0
  954. X#define IPDEFAULTTTL    4
  955. X#define IPINRECEIVES    8
  956. X#define IPINHDRERRORS    12
  957. X#define IPINADDRERRORS    16
  958. X#define IPFORWDATAGRAMS    20
  959. X#define IPINUNKNOWNPROTOS   24
  960. X#define IPINDISCARDS    28
  961. X#define IPINDELIVERS    32
  962. X#define IPOUTREQUESTS    36
  963. X#define IPOUTDISCARDS    40
  964. X#define IPOUTNOROUTES    44
  965. X#define IPREASMTIMEOUT    48
  966. X#define IPREASMREQDS    52
  967. X#define IPREASMOKS    56
  968. X#define IPREASMFAILS    60
  969. X#define IPFRAGOKS    64
  970. X#define IPFRAGFAILS    68
  971. X#define IPFRAGCREATES    72
  972. X
  973. X#define IPADADDR    0
  974. X#define IPADIFINDEX    4
  975. X#define IPADNETMASK    8
  976. X#define IPADBCASTADDR    12
  977. X
  978. X#define IPROUTEDEST    0
  979. X#define IPROUTEIFINDEX    4
  980. X#define IPROUTEMETRIC1    8
  981. X#define IPROUTEMETRIC2    12
  982. X#define IPROUTEMETRIC3    16
  983. X#define IPROUTEMETRIC4    20
  984. X#define IPROUTENEXTHOP    24
  985. X#define IPROUTETYPE    28
  986. X#define IPROUTEPROTO    32
  987. X#define IPROUTEAGE    36
  988. X
  989. X#define    ICMPINMSGS        0
  990. X#define    ICMPINERRORS        4
  991. X#define    ICMPINDESTUNREACHS  8
  992. X#define    ICMPINTIMEEXCDS        12
  993. X#define    ICMPINPARMPROBS        16
  994. X#define    ICMPINSRCQUENCHS    20
  995. X#define    ICMPINREDIRECTS        24
  996. X#define    ICMPINECHOS        28
  997. X#define    ICMPINECHOREPS        32
  998. X#define    ICMPINTIMESTAMPS    36
  999. X#define    ICMPINTIMESTAMPREPS 40
  1000. X#define    ICMPINADDRMASKS        44
  1001. X#define    ICMPINADDRMASKREPS  48
  1002. X#define    ICMPOUTMSGS        52
  1003. X#define    ICMPOUTERRORS        56
  1004. X#define    ICMPOUTDESTUNREACHS 60
  1005. X#define    ICMPOUTTIMEEXCDS    64
  1006. X#define    ICMPOUTPARMPROBS    68
  1007. X#define    ICMPOUTSRCQUENCHS   72
  1008. X#define    ICMPOUTREDIRECTS    76
  1009. X#define    ICMPOUTECHOS        80
  1010. X#define    ICMPOUTECHOREPS        84
  1011. X#define    ICMPOUTTIMESTAMPS   88
  1012. X#define    ICMPOUTTIMESTAMPREPS    92
  1013. X#define    ICMPOUTADDRMASKS    96
  1014. X#define    ICMPOUTADDRMASKREPS 100
  1015. X
  1016. X#define UDPINDATAGRAMS        0
  1017. X#define UDPNOPORTS        4
  1018. X#define    UDPINERRORS        8
  1019. X#define UDPOUTDATAGRAMS        12
  1020. X
  1021. Xstruct variable        variables[] = {
  1022. X    /* these must be lexicographly ordered by the name field */
  1023. X    {{MIB, 1, 1, 0},        9, STRING,  VERSION_DESCR, RONLY, var_system },
  1024. X    {{MIB, 1, 2, 0},        9, OBJID,   VERSION_ID, RONLY, var_system },
  1025. X    {{MIB, 1, 3, 0},        9, TIMETICKS, UPTIME, RONLY, var_system },
  1026. X    {{MIB, 2, 1, 0},        9, INTEGER, CFG_NNETS, RONLY, var_system },
  1027. X    {{MIB, 2, 2, 1, 1, 0xFF},  11, INTEGER, IFINDEX, RONLY, var_ifEntry },
  1028. X    {{MIB, 2, 2, 1, 2, 0xFF},  11, STRING,  IFDESCR, RONLY, var_ifEntry },
  1029. X    {{MIB, 2, 2, 1, 3, 0xFF},  11, INTEGER, IFTYPE, RONLY, var_ifEntry },
  1030. X    {{MIB, 2, 2, 1, 4, 0xFF},  11, INTEGER, IFMTU, RONLY, var_ifEntry },
  1031. X    {{MIB, 2, 2, 1, 5, 0xFF},  11, GAUGE,   IFSPEED, RONLY, var_ifEntry },
  1032. X    {{MIB, 2, 2, 1, 6, 0xFF},  11, STRING,  IFPHYSADDRESS, RONLY, var_ifEntry },
  1033. X    {{MIB, 2, 2, 1, 7, 0xFF},  11, INTEGER, IFADMINSTATUS, RWRITE, var_ifEntry },
  1034. X    {{MIB, 2, 2, 1, 8, 0xFF},  11, INTEGER, IFOPERSTATUS, RONLY, var_ifEntry },
  1035. X    {{MIB, 2, 2, 1, 9, 0xFF},  11, TIMETICKS, IFLASTCHANGE, RONLY, var_ifEntry },
  1036. X    {{MIB, 2, 2, 1, 10, 0xFF}, 11, COUNTER, IFINOCTETS, RONLY, var_ifEntry },
  1037. X    {{MIB, 2, 2, 1, 11, 0xFF}, 11, COUNTER, IFINUCASTPKTS, RONLY, var_ifEntry },
  1038. X    {{MIB, 2, 2, 1, 12, 0xFF}, 11, COUNTER, IFINNUCASTPKTS, RONLY, var_ifEntry },
  1039. X    {{MIB, 2, 2, 1, 13, 0xFF}, 11, COUNTER, IFINDISCARDS, RONLY, var_ifEntry },
  1040. X    {{MIB, 2, 2, 1, 14, 0xFF}, 11, COUNTER, IFINERRORS, RONLY, var_ifEntry },
  1041. X    {{MIB, 2, 2, 1, 15, 0xFF}, 11, COUNTER, IFINUNKNOWNPROTOS, RONLY, var_ifEntry },
  1042. X    {{MIB, 2, 2, 1, 16, 0xFF}, 11, COUNTER, IFOUTOCTETS, RONLY, var_ifEntry },
  1043. X    {{MIB, 2, 2, 1, 17, 0xFF}, 11, COUNTER, IFOUTUCASTPKTS, RONLY, var_ifEntry },
  1044. X    {{MIB, 2, 2, 1, 18, 0xFF}, 11, COUNTER, IFOUTNUCASTPKTS, RONLY, var_ifEntry },
  1045. X    {{MIB, 2, 2, 1, 19, 0xFF}, 11, COUNTER, IFOUTDISCARDS, RONLY, var_ifEntry },
  1046. X    {{MIB, 2, 2, 1, 20, 0xFF}, 11, COUNTER, IFOUTERRORS, RONLY, var_ifEntry },
  1047. X    {{MIB, 2, 2, 1, 21, 0xFF}, 11, GAUGE,   IFOUTQLEN, RONLY, var_ifEntry },
  1048. X    {{MIB, 3, 1, 1, 1, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, 16, INTEGER,    ATIFINDEX, RWRITE, var_atEntry }, 
  1049. X    {{MIB, 3, 1, 1, 2, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, 16, STRING,        ATPHYSADDRESS, RWRITE, var_atEntry }, 
  1050. X    {{MIB, 3, 1, 1, 3, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, 16, IPADDRESS,  ATNETADDRESS, RWRITE, var_atEntry },
  1051. X    {{MIB, 4, 1, 0},        9, INTEGER, IPFORWARDING, RONLY, var_ip },
  1052. X    {{MIB, 4, 2, 0},        9, INTEGER, IPDEFAULTTTL, RWRITE, var_ip },
  1053. X    {{MIB, 4, 3, 0},        9, COUNTER, IPINRECEIVES, RONLY, var_ip },
  1054. X    {{MIB, 4, 4, 0},        9, COUNTER, IPINHDRERRORS, RONLY, var_ip },
  1055. X    {{MIB, 4, 5, 0},        9, COUNTER, IPINADDRERRORS, RONLY, var_ip },
  1056. X    {{MIB, 4, 6, 0},        9, COUNTER, IPFORWDATAGRAMS, RONLY, var_ip },
  1057. X    {{MIB, 4, 7, 0},        9, COUNTER, IPINUNKNOWNPROTOS, RONLY, var_ip },
  1058. X    {{MIB, 4, 8, 0},        9, COUNTER, IPINDISCARDS, RONLY, var_ip },
  1059. X    {{MIB, 4, 9, 0},        9, COUNTER, IPINDELIVERS, RONLY, var_ip },
  1060. X    {{MIB, 4, 10, 0},        9, COUNTER, IPOUTREQUESTS, RONLY, var_ip },
  1061. X    {{MIB, 4, 11, 0},        9, COUNTER, IPOUTDISCARDS, RONLY, var_ip },
  1062. X    {{MIB, 4, 12, 0},        9, COUNTER, IPOUTNOROUTES, RONLY, var_ip },
  1063. X    {{MIB, 4, 13, 0},        9, INTEGER, IPREASMTIMEOUT, RONLY, var_ip },
  1064. X    {{MIB, 4, 14, 0},        9, COUNTER, IPREASMREQDS, RONLY, var_ip },
  1065. X    {{MIB, 4, 15, 0},        9, COUNTER, IPREASMOKS, RONLY, var_ip },
  1066. X    {{MIB, 4, 16, 0},        9, COUNTER, IPREASMFAILS, RONLY, var_ip },
  1067. X    {{MIB, 4, 17, 0},        9, COUNTER, IPFRAGOKS, RONLY, var_ip },
  1068. X    {{MIB, 4, 18, 0},        9, COUNTER, IPFRAGFAILS, RONLY, var_ip },
  1069. X    {{MIB, 4, 19, 0},        9, COUNTER, IPFRAGCREATES, RONLY, var_ip },
  1070. X    {{MIB, 4, 20, 1, 1, 0xFF, 0xFF, 0xFF, 0xFF}, 14, IPADDRESS, IPADADDR, RONLY, var_ipAddrEntry },
  1071. X    {{MIB, 4, 20, 1, 2, 0xFF, 0xFF, 0xFF, 0xFF}, 14, INTEGER,    IPADIFINDEX, RONLY, var_ipAddrEntry },
  1072. X    {{MIB, 4, 20, 1, 3, 0xFF, 0xFF, 0xFF, 0xFF}, 14, IPADDRESS, IPADNETMASK, RONLY, var_ipAddrEntry },
  1073. X    {{MIB, 4, 20, 1, 4, 0xFF, 0xFF, 0xFF, 0xFF}, 14, INTEGER,    IPADBCASTADDR, RONLY, var_ipAddrEntry },
  1074. X    {{MIB, 4, 21, 1, 1, 0xFF, 0xFF, 0xFF, 0xFF}, 14, IPADDRESS, IPROUTEDEST, RWRITE, var_ipRouteEntry },
  1075. X    {{MIB, 4, 21, 1, 2, 0xFF, 0xFF, 0xFF, 0xFF}, 14, INTEGER,    IPROUTEIFINDEX, RWRITE, var_ipRouteEntry },
  1076. X    {{MIB, 4, 21, 1, 3, 0xFF, 0xFF, 0xFF, 0xFF}, 14, INTEGER,    IPROUTEMETRIC1, RWRITE, var_ipRouteEntry },
  1077. X    {{MIB, 4, 21, 1, 4, 0xFF, 0xFF, 0xFF, 0xFF}, 14, INTEGER,    IPROUTEMETRIC2, RWRITE, var_ipRouteEntry },
  1078. X    {{MIB, 4, 21, 1, 5, 0xFF, 0xFF, 0xFF, 0xFF}, 14, INTEGER,    IPROUTEMETRIC3, RWRITE, var_ipRouteEntry },
  1079. X    {{MIB, 4, 21, 1, 6, 0xFF, 0xFF, 0xFF, 0xFF}, 14, INTEGER,    IPROUTEMETRIC4, RWRITE, var_ipRouteEntry },
  1080. X    {{MIB, 4, 21, 1, 7, 0xFF, 0xFF, 0xFF, 0xFF}, 14, IPADDRESS, IPROUTENEXTHOP, RWRITE, var_ipRouteEntry },
  1081. X    {{MIB, 4, 21, 1, 8, 0xFF, 0xFF, 0xFF, 0xFF}, 14, INTEGER,    IPROUTETYPE, RWRITE, var_ipRouteEntry },
  1082. X    {{MIB, 4, 21, 1, 9, 0xFF, 0xFF, 0xFF, 0xFF}, 14, INTEGER,    IPROUTEPROTO, RONLY, var_ipRouteEntry },
  1083. X    {{MIB, 4, 21, 1, 10, 0xFF, 0xFF, 0xFF, 0xFF}, 14, INTEGER,    IPROUTEAGE, RWRITE, var_ipRouteEntry },
  1084. X    {{MIB, 5, 1, 0},        9, COUNTER, ICMPINMSGS, RONLY, var_icmp },
  1085. X    {{MIB, 5, 2, 0},        9, COUNTER, ICMPINERRORS, RONLY, var_icmp },
  1086. X    {{MIB, 5, 3, 0},        9, COUNTER, ICMPINDESTUNREACHS, RONLY, var_icmp },
  1087. X    {{MIB, 5, 4, 0},        9, COUNTER, ICMPINTIMEEXCDS, RONLY, var_icmp },
  1088. X    {{MIB, 5, 5, 0},        9, COUNTER, ICMPINPARMPROBS, RONLY, var_icmp },
  1089. X    {{MIB, 5, 6, 0},        9, COUNTER, ICMPINSRCQUENCHS, RONLY, var_icmp },
  1090. X    {{MIB, 5, 7, 0},        9, COUNTER, ICMPINREDIRECTS, RONLY, var_icmp },
  1091. X    {{MIB, 5, 8, 0},        9, COUNTER, ICMPINECHOS, RONLY, var_icmp },
  1092. X    {{MIB, 5, 9, 0},        9, COUNTER, ICMPINECHOREPS, RONLY, var_icmp },
  1093. X    {{MIB, 5, 10, 0},        9, COUNTER, ICMPINTIMESTAMPS, RONLY, var_icmp },
  1094. X    {{MIB, 5, 11, 0},        9, COUNTER, ICMPINTIMESTAMPREPS, RONLY, var_icmp },
  1095. X    {{MIB, 5, 12, 0},        9, COUNTER, ICMPINADDRMASKS, RONLY, var_icmp },
  1096. X    {{MIB, 5, 13, 0},        9, COUNTER, ICMPINADDRMASKREPS, RONLY, var_icmp },
  1097. X    {{MIB, 5, 14, 0},        9, COUNTER, ICMPOUTMSGS, RONLY, var_icmp },
  1098. X    {{MIB, 5, 15, 0},        9, COUNTER, ICMPOUTERRORS, RONLY, var_icmp },
  1099. X    {{MIB, 5, 16, 0},        9, COUNTER, ICMPOUTDESTUNREACHS, RONLY, var_icmp },
  1100. X    {{MIB, 5, 17, 0},        9, COUNTER, ICMPOUTTIMEEXCDS, RONLY, var_icmp },
  1101. X    {{MIB, 5, 18, 0},        9, COUNTER, ICMPOUTPARMPROBS, RONLY, var_icmp },
  1102. X    {{MIB, 5, 19, 0},        9, COUNTER, ICMPOUTSRCQUENCHS, RONLY, var_icmp },
  1103. X    {{MIB, 5, 20, 0},        9, COUNTER, ICMPOUTREDIRECTS, RONLY, var_icmp },
  1104. X    {{MIB, 5, 21, 0},        9, COUNTER, ICMPOUTECHOS, RONLY, var_icmp },
  1105. X    {{MIB, 5, 22, 0},        9, COUNTER, ICMPOUTECHOREPS, RONLY, var_icmp },
  1106. X    {{MIB, 5, 23, 0},        9, COUNTER, ICMPOUTTIMESTAMPS, RONLY, var_icmp },
  1107. X    {{MIB, 5, 24, 0},        9, COUNTER, ICMPOUTTIMESTAMPREPS, RONLY, var_icmp },
  1108. X    {{MIB, 5, 25, 0},        9, COUNTER, ICMPOUTADDRMASKS, RONLY, var_icmp },
  1109. X    {{MIB, 5, 26, 0},        9, COUNTER, ICMPOUTADDRMASKREPS, RONLY, var_icmp },
  1110. X    {{MIB, 7, 1, 0},        9, COUNTER, UDPINDATAGRAMS, RONLY, var_udp }, 
  1111. X    {{MIB, 7, 2, 0},        9, COUNTER, UDPNOPORTS, RONLY, var_udp },
  1112. X    {{MIB, 7, 3, 0},        9, COUNTER, UDPINERRORS, RONLY, var_udp }, 
  1113. X    {{MIB, 7, 4, 0},        9, COUNTER, UDPOUTDATAGRAMS, RONLY, var_udp }
  1114. X};
  1115. X
  1116. X
  1117. X
  1118. X
  1119. X/*
  1120. X * getStatPtr - return a pointer to the named variable, as well as it's
  1121. X * type, length, and access control list.
  1122. X *
  1123. X * If an exact match for the variable name exists, it is returned.  If not,
  1124. X * and exact is false, the next variable lexicographically after the
  1125. X * requested one is returned.
  1126. X *
  1127. X * If no appropriate variable can be found, NULL is returned.
  1128. X */
  1129. Xu_char  *
  1130. XgetStatPtr(name, namelen, type, len, acl, exact, access_method)
  1131. X    oid        *name;        /* IN - name of var, OUT - name matched */
  1132. X    int        *namelen;   /* IN -number of sub-ids in name, OUT - subid-is in matched name */
  1133. X    u_char    *type;        /* OUT - type of matched variable */
  1134. X    int        *len;        /* OUT - length of matched variable */
  1135. X    u_short    *acl;        /* OUT - access control list */
  1136. X    int        exact;        /* IN - TRUE if exact match wanted */
  1137. X    int        *access_method; /* OUT - 1 if function, 0 if char * */
  1138. X{
  1139. X
  1140. X    register struct variable    *vp;
  1141. X
  1142. X    register int    x;
  1143. X    register u_char    *access;
  1144. X    int            result;
  1145. X
  1146. X    for(x = 0, vp = variables; x < sizeof(variables)/sizeof(struct variable); vp++, x++){
  1147. X    /*
  1148. X     * compare should be expanded inline.
  1149. X     */
  1150. X    result = compare(name, *namelen, vp->name, (int)vp->namelen);
  1151. X    if ((result < 0) || (exact && (result == 0))){
  1152. X        access = (*(vp->findVar))(vp, name, namelen, exact, len, access_method);
  1153. X        if (access != NULL)
  1154. X        break;
  1155. X    }
  1156. X    }
  1157. X    if (x == sizeof(variables)/sizeof(struct variable))
  1158. X    return NULL;
  1159. X
  1160. X    /* vp now points to the approprate struct */
  1161. X    *type = vp->type;
  1162. X    *acl = vp->acl;
  1163. X    return access;
  1164. X}
  1165. X
  1166. X
  1167. X
  1168. Xint
  1169. Xcompare(name1, len1, name2, len2)
  1170. X    register oid        *name1, *name2;
  1171. X    register int        len1, len2;
  1172. X{
  1173. X    register int    len;
  1174. X
  1175. X    /* len = minimum of len1 and len2 */
  1176. X    if (len1 < len2)
  1177. X    len = len1;
  1178. X    else
  1179. X    len = len2;
  1180. X    /* find first non-matching byte */
  1181. X    while(len-- > 0){
  1182. X    if (*name1 < *name2)
  1183. X        return -1;
  1184. X    if (*name2++ < *name1++)
  1185. X        return 1;
  1186. X    }
  1187. X    /* bytes match up to length of shorter string */
  1188. X    if (len1 < len2)
  1189. X    return -1;  /* name1 shorter, so it is "less" */
  1190. X    if (len2 < len1)
  1191. X    return 1;
  1192. X    return 0;    /* both strings are equal */
  1193. X}
  1194. X
  1195. X
  1196. Xu_char *
  1197. Xvar_system(vp, name, length, exact, var_len, access_method)
  1198. X    register struct variable *vp;   /* IN - pointer to variable entry that points here */
  1199. X    register oid    *name;        /* IN/OUT - input name requested, output name found */
  1200. X    register int    *length;    /* IN/OUT - length of input and output oid's */
  1201. X    int            exact;        /* IN - TRUE if an exact match was requested. */
  1202. X    int            *var_len;   /* OUT - length of variable or 0 if function returned. */
  1203. X    int            *access_method;    /* OUT - 1 if function, 0 if char pointer. */
  1204. X{
  1205. X    if (exact && (compare(name, *length, vp->name, (int)vp->namelen) != 0))
  1206. X    return NULL;
  1207. X    bcopy((char *)vp->name, (char *)name, (int)vp->namelen * sizeof(oid));
  1208. X    *length = vp->namelen;
  1209. X    *access_method = 0;
  1210. X    *var_len = sizeof(long);    /* default length */
  1211. X    switch (vp->magic){
  1212. X    case VERSION_DESCR:
  1213. X        *var_len = strlen(version_descr);
  1214. X        return (u_char *)version_descr;
  1215. X    case VERSION_ID:
  1216. X        *var_len = sizeof(version_id);
  1217. X        return (u_char *)version_id;
  1218. X    case CFG_NNETS:
  1219. X        return (u_char *)&cfg_nnets;
  1220. X    case UPTIME:
  1221. X        return (u_char *)&uptime;
  1222. X    default:
  1223. X        ERROR("");
  1224. X    }
  1225. X    return NULL;
  1226. X}
  1227. X
  1228. X
  1229. Xu_char *
  1230. Xvar_ifEntry(vp, name, length, exact, var_len, access_method)
  1231. X    register struct variable *vp;   /* IN - pointer to variable entry that points here */
  1232. X    register oid    *name;        /* IN/OUT - input name requested, output name found */
  1233. X    register int    *length;    /* IN/OUT - length of input and output oid's */
  1234. X    int            exact;        /* IN - TRUE if an exact match was requested. */
  1235. X    int            *var_len;   /* OUT - length of variable or 0 if function returned. */
  1236. X    int            *access_method; /* OUT - 1 if function, 0 if char pointer. */
  1237. X{
  1238. X    oid            newname[MAX_NAME_LEN];
  1239. X    register int    interface;
  1240. X    register struct mib_ifEntry    *ifp;
  1241. X    extern struct conf    conf;
  1242. X    int            result;
  1243. X
  1244. X    bcopy((char *)vp->name, (char *)newname, (int)vp->namelen * sizeof(oid));
  1245. X    /* find "next" interface */
  1246. X    for(interface = 1; interface <= MAX_INTERFACES; interface++){
  1247. X    newname[10] = (oid)interface;
  1248. X    result = compare(name, *length, newname, (int)vp->namelen);
  1249. X    if ((exact && (result == 0)) || (!exact && (result < 0)))
  1250. X        break;
  1251. X    }
  1252. X    if (interface > MAX_INTERFACES)
  1253. X    return NULL;
  1254. X    interface--; /* translate into internal index of interfaces */
  1255. X    bcopy((char *)newname, (char *)name, (int)vp->namelen * sizeof(oid));
  1256. X    *length = vp->namelen;
  1257. X    *access_method = 0;
  1258. X    *var_len = sizeof(long);
  1259. X
  1260. X    ifp = &mib_ifEntry[interface];
  1261. X    switch (vp->magic){
  1262. X        case IFDESCR:
  1263. X        *var_len = strlen(ifp->ifDescr);
  1264. X        return (u_char *)ifp->ifDescr;
  1265. X    case IFPHYSADDRESS:
  1266. X        *var_len = ifp->PhysAddrLen;
  1267. X        if (interface == 0)
  1268. X            return (u_char *)ifie.if_haddr;
  1269. X        else {
  1270. X        /*
  1271. X         * As far as IP is concerned, the "physical" address includes the Appletalk
  1272. X         * network address as well as node number.
  1273. X         */
  1274. X        return_buf[0] = ((u_char *)&conf.atneta)[0];
  1275. X        return_buf[1] = ((u_char *)&conf.atneta)[1];
  1276. X        return_buf[2] = ifab.if_dnode;
  1277. X            return (u_char *)return_buf;
  1278. X        }
  1279. X    case IFOUTQLEN:
  1280. X#ifdef notdef
  1281. X        if (interface == 0)
  1282. X        long_return = sendq->pq_len;
  1283. X        else
  1284. X        long_return = 0;    /* There is no appletalk transmit queue */
  1285. X#else
  1286. X        long_return = 0;
  1287. X#endif
  1288. X        return (u_char *)&long_return;
  1289. X    default:
  1290. X        return (u_char *)(((char *)ifp) + vp->magic);
  1291. X    }
  1292. X}
  1293. X
  1294. X/* 
  1295. X * from arp.c:
  1296. X * There is no arp.h, so this must be recreated here.
  1297. X */
  1298. X#define    ARPHLNMAX    6    /* largest arp_hln value needed */
  1299. X#define    ARPPLN        4    /* length of protocol address (IP) */
  1300. Xstruct    arptab {
  1301. X    iaddr_t at_iaddr;        /* internet address */
  1302. X    u_char    at_haddr[ARPHLNMAX];    /* hardware address */
  1303. X    u_char    at_timer;        /* minutes since last reference */
  1304. X    u_char    at_flags;        /* flags */
  1305. X    struct    pbuf *at_hold;        /* last packet until resolved/timeout */
  1306. X};
  1307. X/* at_flags field values */
  1308. X#define    ATF_INUSE    1        /* entry in use */
  1309. X#define ATF_COM        2        /* completed entry (haddr valid) */
  1310. X
  1311. X#define    ARPTAB_BSIZ    5        /* bucket size */
  1312. X#define    ARPTAB_NB    11        /* number of buckets */
  1313. X#define    ARPTAB_SIZE    (ARPTAB_BSIZ * ARPTAB_NB)
  1314. X
  1315. X
  1316. Xu_char *
  1317. Xvar_atEntry(vp, name, length, exact, var_len, access_method)
  1318. X    register struct variable *vp;    /* IN - pointer to variable entry that points here */
  1319. X    register oid        *name;    /* IN/OUT - input name requested, output name found */
  1320. X    register int        *length;    /* IN/OUT - length of input and output oid's */
  1321. X    int                exact;    /* IN - TRUE if an exact match was requested. */
  1322. X    int                *var_len;    /* OUT - length of variable or 0 if function returned. */
  1323. X    int                *access_method; /* OUT - 1 if function, 0 if char pointer. */
  1324. X{
  1325. X    /*
  1326. X     * object identifier is of form:
  1327. X     * 1.3.6.1.2.1.3.1.1.1.interface.1.A.B.C.D,  where A.B.C.D is IP address.
  1328. X     * Interface is at offset 10,
  1329. X     * IPADDR starts at offset 12.
  1330. X     */
  1331. X    oid                lowest[16];
  1332. X    oid                current[16];
  1333. X    register struct arptab  *arp;
  1334. X    struct arptab        *lowarp = 0;
  1335. X    extern struct arptab    arptab[];
  1336. X    register struct ipdad   *ipdp;
  1337. X    struct ipdad        *lowipdp = 0;
  1338. X    extern struct ipdad        ipdad[];
  1339. X    long            ipaddr;
  1340. X    int                addrlen;
  1341. X    extern struct conf        conf;
  1342. X    register u_char        *cp;
  1343. X    register oid        *op;
  1344. X    register int        count;
  1345. X
  1346. X    /* fill in object part of name for current (less sizeof instance part) */
  1347. X    bcopy((char *)vp->name, (char *)current, (int)(vp->namelen - 6) * sizeof(oid));
  1348. X    for(arp = arptab; arp < arptab + ARPTAB_SIZE; arp++){
  1349. X    if (!(arp->at_flags & ATF_COM))    /* if this entry isn't valid */
  1350. X        continue;
  1351. X    /* create new object id */
  1352. X    current[10] = 1;    /* ifIndex == 1 (ethernet) */
  1353. X    current[11] = 1;
  1354. X    cp = (u_char *)&(arp->at_iaddr);
  1355. X    op = current + 12;
  1356. X    for(count = 4; count > 0; count--)
  1357. X        *op++ = *cp++;
  1358. X    if (exact){
  1359. X        if (compare(current, 16, name, *length) == 0){
  1360. X        bcopy((char *)current, (char *)lowest, 16 * sizeof(oid));
  1361. X        lowarp = arp;
  1362. X        break;    /* no need to search further */
  1363. X        }
  1364. X    } else {
  1365. X        if ((compare(current, 16, name, *length) > 0) && (!lowarp || (compare(current, 16, lowest, 16) < 0))){
  1366. X        /*
  1367. X         * if new one is greater than input and closer to input than
  1368. X         * previous lowest, save this one as the "next" one.
  1369. X         */
  1370. X        bcopy((char *)current, (char *)lowest, 16 * sizeof(oid));
  1371. X        lowarp = arp;
  1372. X        }
  1373. X    }
  1374. X    }
  1375. X    ipaddr = conf.ipaddr + conf.ipstatic + 1;
  1376. X    for(ipdp = ipdad; ipdp < ipdad + NIPDAD; ipdp++, ipaddr++){
  1377. X    if (ipdp->timer == 0)    /* if this entry is unused, continue */
  1378. X        continue;
  1379. X    /* create new object id */
  1380. X    current[10] = 2;    /* ifIndex == 2 (appletalk) */
  1381. X    current[11] = 1;
  1382. X    cp = (u_char *)&ipaddr;
  1383. X    op = current + 12;
  1384. X    for(count = 4; count > 0; count--)
  1385. X        *op++ = *cp++;
  1386. X    if (exact){
  1387. X        if (compare(current, 16, name, *length) == 0){
  1388. X        bcopy((char *)current, (char *)lowest, 16 * sizeof(oid));
  1389. X        lowipdp = ipdp;
  1390. X        lowarp = 0;
  1391. X        break;    /* no need to search further */
  1392. X        }
  1393. X    } else {
  1394. X        if ((compare(current, 16, name, *length) > 0) && ((!lowarp && !lowipdp) || (compare(current, 16, lowest, 16) < 0))){
  1395. X        /*
  1396. X         * if new one is greater than input and closer to input than
  1397. X         * previous lowest, save this one as the "next" one.
  1398. X         */
  1399. X        bcopy((char *)current, (char *)lowest, 16 * sizeof(oid));
  1400. X        lowipdp = ipdp;
  1401. X        /* ipdad entry is lower, so invalidate arp entry */
  1402. X        lowarp = 0;
  1403. X        }
  1404. X    }
  1405. X    }
  1406. X    if (lowarp != 0){    /* arp entry was lowest */
  1407. X    addrlen = 6;
  1408. X    bcopy((char *)lowarp->at_haddr, (char *)return_buf, 6);
  1409. X    } else if (lowipdp != 0) {
  1410. X    addrlen = 3;
  1411. X    /*
  1412. X     * As far as IP is concerned, the "physical" address includes the Appletalk
  1413. X     * network address as well as node number.
  1414. X     */
  1415. X    return_buf[0] = ((u_char *)&lowipdp->net)[0];
  1416. X    return_buf[1] = ((u_char *)&lowipdp->net)[1];
  1417. X    return_buf[2] = lowipdp->node;
  1418. X    } else
  1419. X    return NULL;    /* no match */
  1420. X    bcopy((char *)lowest, (char *)name, 16 * sizeof(oid));
  1421. X    *length = 16;
  1422. X    *access_method = 0;
  1423. X    switch(vp->magic){
  1424. X    case ATIFINDEX:
  1425. X        *var_len = sizeof long_return;
  1426. X        long_return = lowest[10];
  1427. X        return (u_char *)&long_return;
  1428. X    case ATPHYSADDRESS:
  1429. X        *var_len = addrlen;
  1430. X        return (u_char *)return_buf;
  1431. X    case ATNETADDRESS:
  1432. X        *var_len = sizeof long_return;
  1433. X        cp = (u_char *)&long_return;
  1434. X        op = lowest + 12;
  1435. X        for(count = 4; count > 0; count--)
  1436. X        *cp++ = *op++;
  1437. X        return (u_char *)&long_return;
  1438. X    default:
  1439. X        ERROR("");
  1440. X   }
  1441. X   return NULL;
  1442. X}
  1443. X
  1444. Xu_char *
  1445. Xvar_ip(vp, name, length, exact, var_len, access_method)
  1446. X    register struct variable *vp;   /* IN - pointer to variable entry that points here */
  1447. X    oid        *name;        /* IN/OUT - input name requested, output name found */
  1448. X    int        *length;        /* IN/OUT - length of input and output oid's */
  1449. X    int        exact;        /* IN - TRUE if an exact match was requested. */
  1450. X    int        *var_len;        /* OUT - length of variable or 0 if function returned. */
  1451. X    int        *access_method; /* OUT - 1 if function, 0 if char pointer. */
  1452. X{
  1453. X    if (exact && (compare(name, *length, vp->name, (int)vp->namelen) != 0))
  1454. X    return NULL;
  1455. X    bcopy((char *)vp->name, (char *)name, (int)vp->namelen * sizeof(oid));
  1456. X    *length = vp->namelen;
  1457. X    *access_method = 0;
  1458. X    *var_len = sizeof(long);
  1459. X    return ((u_char *)&mib_ip) + vp->magic;
  1460. X}
  1461. X
  1462. Xu_char *
  1463. Xvar_ipRouteEntry(vp, name, length, exact, var_len, access_method)
  1464. X    register struct variable *vp;   /* IN - pointer to variable entry that points here */
  1465. X    register oid        *name;        /* IN/OUT - input name requested, output name found */
  1466. X    register int    *length;    /* IN/OUT - length of input and output strings */
  1467. X    int            exact;        /* IN - TRUE if an exact match was requested. */
  1468. X    int            *var_len;   /* OUT - length of variable or 0 if function returned. */
  1469. X    int            *access_method; /* OUT - 1 if function, 0 if char pointer. */
  1470. X{
  1471. X    oid                newname[MAX_NAME_LEN];
  1472. X    register int        entry;
  1473. X    register struct mib_ipRouteEntry    *routep;
  1474. X    int                result;
  1475. X    register int        count;
  1476. X    register u_char        *cp;
  1477. X    register oid        *op;
  1478. X    extern struct conf        conf;
  1479. X
  1480. X    /* set up a routing table to search. All other values are set at startup. */
  1481. X    routep = mib_ipRouteEntry;
  1482. X    routep[ROUTE_DEFAULT].ipRouteDest = 0;
  1483. X    routep[ROUTE_DEFAULT].ipRouteNextHop = conf.iproutedef;
  1484. X    routep[ROUTE_LOCAL].ipRouteDest = ipnetpart(conf.ipaddr);
  1485. X    routep[ROUTE_LOCAL].ipRouteNextHop = conf.ipaddr;
  1486. X
  1487. X    bcopy((char *)vp->name, (char *)newname, (int)vp->namelen * sizeof(oid));
  1488. X    /* find "next" route */
  1489. X    for(entry = 0; entry < ROUTE_ENTRIES; entry++){
  1490. X    cp = (u_char *)&routep->ipRouteDest;
  1491. X    op = newname + 10;
  1492. X    for(count = 4; count > 0; count--)
  1493. X        *op++ = *cp++;
  1494. X    result = compare(name, *length, newname, (int)vp->namelen);
  1495. X    if ((exact && (result == 0)) || (!exact && (result < 0)))
  1496. X        break;
  1497. X    routep++;
  1498. X    }
  1499. X    if (entry >= ROUTE_ENTRIES)
  1500. X    return NULL;
  1501. X    bcopy((char *)newname, (char *)name, (int)vp->namelen * sizeof(oid));
  1502. X    *length = vp->namelen;
  1503. X    *access_method = 0;
  1504. X    *var_len = sizeof(long);
  1505. X
  1506. X    routep = &mib_ipRouteEntry[entry];
  1507. X    switch (vp->magic){
  1508. X    case IPROUTENEXTHOP:
  1509. X        if (entry == ROUTE_DEFAULT)
  1510. X        return (u_char *)&conf.iproutedef;
  1511. X        else
  1512. X        return (u_char *)&conf.ipaddr;
  1513. X    default:
  1514. X        return (u_char *)(((u_char *)routep) + vp->magic);
  1515. X    }
  1516. X}
  1517. X
  1518. Xu_char *
  1519. Xvar_ipAddrEntry(vp, name, length, exact, var_len, access_method)
  1520. X    register struct variable *vp;    /* IN - pointer to variable entry that points here */
  1521. X    register oid    *name;        /* IN/OUT - input name requested, output name found */
  1522. X    register int    *length;    /* IN/OUT - length of input and output oid's */
  1523. X    int            exact;        /* IN - TRUE if an exact match was requested. */
  1524. X    int            *var_len;   /* OUT - length of variable or 0 if function returned. */
  1525. X    int            *access_method; /* OUT - 1 if function, 0 if char pointer. */
  1526. X{
  1527. X    oid            newname[14];
  1528. X    int            result;
  1529. X    extern struct conf    conf;
  1530. X    register int    count;
  1531. X    register u_char *cp;
  1532. X    register oid    *op;
  1533. X
  1534. X    bcopy((char *)vp->name, (char *)newname, (int)vp->namelen * sizeof(oid));
  1535. X    /* now find "next" ipaddr */
  1536. X    /*
  1537. X     * foreach ipaddress entry, cobble up newname with its IP address,
  1538. X     * by copying the ipaddress into the 10 - 13't subid's
  1539. X     * then compare with name.  If greater than name and less than lowest,
  1540. X     * save as new lowest.
  1541. X     * Having said all that, I'm now going to cheat because I only have one
  1542. X     * IP address (on both interfaces).
  1543. X     */
  1544. X    cp = (u_char *)&conf.ipaddr;
  1545. X    op = newname + 10;
  1546. X    for(count = sizeof(conf.ipaddr); count > 0; count--)
  1547. X    *op++ = *cp++;
  1548. X    result = compare(name, *length, newname, (int)vp->namelen);
  1549. X    if ((exact && (result != 0)) || (!exact && (result >= 0)))
  1550. X    return NULL;    /* no match */
  1551. X    bcopy((char *)newname, (char *)name, (int)vp->namelen * sizeof(oid));
  1552. X    *length = vp->namelen;
  1553. X    *access_method = 0;
  1554. X    *var_len = sizeof(long);
  1555. X
  1556. X    switch (vp->magic){
  1557. X        case IPADADDR:
  1558. X        return (u_char *)&conf.ipaddr;
  1559. X        case IPADIFINDEX:
  1560. X        /*
  1561. X         * Always return ethernet interface. SNMP
  1562. X         * has no access method to access instances
  1563. X         * on different interfaces with same IP address.
  1564. X         */
  1565. X        long_return = 1;
  1566. X        return (u_char *)&long_return;
  1567. X    case IPADNETMASK:
  1568. X        long_return = (IN_CLASSA(conf.ipaddr) ? IN_CLASSA_NET :
  1569. X            (IN_CLASSB(conf.ipaddr) ? IN_CLASSB_NET : IN_CLASSC_NET));
  1570. X        return (u_char *)&long_return;
  1571. X    case IPADBCASTADDR:
  1572. X        long_return = conf.ipbroad & 1;
  1573. X        return (u_char *)&long_return;
  1574. X    default:
  1575. X        ERROR("");
  1576. X    }
  1577. X    return NULL;
  1578. X}
  1579. X
  1580. X
  1581. Xu_char *
  1582. Xvar_icmp(vp, name, length, exact, var_len, access_method)
  1583. X    register struct variable *vp;    /* IN - pointer to variable entry that points here */
  1584. X    oid        *name;        /* IN/OUT - input name requested, output name found */
  1585. X    int        *length;        /* IN/OUT - length of input and output oid's */
  1586. X    int        exact;        /* IN - TRUE if an exact match was requested. */
  1587. X    int        *var_len;        /* OUT - length of variable or 0 if function returned. */
  1588. X    int        *access_method; /* OUT - 1 if function, 0 if char pointer. */
  1589. X{
  1590. X    if (exact && (compare(name, *length, vp->name, (int)vp->namelen) != 0))
  1591. X    return NULL;
  1592. X    bcopy((char *)vp->name, (char *)name, (int)vp->namelen * sizeof(oid));
  1593. X    *length = vp->namelen;
  1594. X    *access_method = 0;
  1595. X    *var_len = sizeof(long); /* all following variables are sizeof long */
  1596. X    switch (vp->magic){
  1597. X    case ICMPINMSGS:
  1598. X        return (u_char *)&mib_icmpInMsgs;
  1599. X    case ICMPINERRORS:
  1600. X        return (u_char *)&mib_icmpInErrors;
  1601. X    case ICMPINDESTUNREACHS:
  1602. X        return (u_char *)&mib_icmpInCount[3];
  1603. X    case ICMPINTIMEEXCDS:
  1604. X        return (u_char *)&mib_icmpInCount[11];
  1605. X    case ICMPINPARMPROBS:
  1606. X        return (u_char *)&mib_icmpInCount[12];
  1607. X    case ICMPINSRCQUENCHS:
  1608. X        return (u_char *)&mib_icmpInCount[4];
  1609. X    case ICMPINREDIRECTS:
  1610. X        return (u_char *)&mib_icmpInCount[5];
  1611. X    case ICMPINECHOS:
  1612. X        return (u_char *)&mib_icmpInCount[8];
  1613. X    case ICMPINECHOREPS:
  1614. X        return (u_char *)&mib_icmpInCount[0];
  1615. X    case ICMPINTIMESTAMPS:
  1616. X        return (u_char *)&mib_icmpInCount[13];
  1617. X    case ICMPINTIMESTAMPREPS:
  1618. X        return (u_char *)&mib_icmpInCount[14];
  1619. X    case ICMPINADDRMASKS:
  1620. X        return (u_char *)&mib_icmpInCount[17];
  1621. X    case ICMPINADDRMASKREPS:
  1622. X        return (u_char *)&mib_icmpInCount[18];
  1623. X    case ICMPOUTMSGS:
  1624. X        return (u_char *)&mib_icmpOutMsgs;
  1625. X    case ICMPOUTERRORS:
  1626. X        return (u_char *)&mib_icmpOutErrors;
  1627. X    case ICMPOUTDESTUNREACHS:
  1628. X        return (u_char *)&mib_icmpOutCount[3];
  1629. X    case ICMPOUTTIMEEXCDS:
  1630. X        return (u_char *)&mib_icmpOutCount[11];
  1631. X    case ICMPOUTPARMPROBS:
  1632. X        return (u_char *)&mib_icmpOutCount[12];
  1633. X    case ICMPOUTSRCQUENCHS:
  1634. X        return (u_char *)&mib_icmpOutCount[4];
  1635. X    case ICMPOUTREDIRECTS:
  1636. X        return (u_char *)&mib_icmpOutCount[5];
  1637. X    case ICMPOUTECHOS:
  1638. X        return (u_char *)&mib_icmpOutCount[8];
  1639. X    case ICMPOUTECHOREPS:
  1640. X        return (u_char *)&mib_icmpOutCount[0];
  1641. X    case ICMPOUTTIMESTAMPS:
  1642. X        return (u_char *)&mib_icmpOutCount[13];
  1643. X    case ICMPOUTTIMESTAMPREPS:
  1644. X        return (u_char *)&mib_icmpOutCount[14];
  1645. X    case ICMPOUTADDRMASKS:
  1646. X        return (u_char *)&mib_icmpOutCount[17];
  1647. X    case ICMPOUTADDRMASKREPS:
  1648. X        return (u_char *)&mib_icmpOutCount[18];
  1649. X    default:
  1650. X        ERROR("");
  1651. X    }
  1652. X    return NULL;
  1653. X}
  1654. X
  1655. X
  1656. Xu_char *
  1657. Xvar_udp(vp, name, length, exact, var_len, access_method)
  1658. X    register struct variable *vp;    /* IN - pointer to variable entry that points here */
  1659. X    oid        *name;        /* IN/OUT - input name requested, output name found */
  1660. X    int        *length;        /* IN/OUT - length of input and output oid's */
  1661. X    int        exact;        /* IN - TRUE if an exact match was requested. */
  1662. X    int        *var_len;        /* OUT - length of variable or 0 if function returned. */
  1663. X    int        *access_method; /* OUT - 1 if function, 0 if char pointer. */
  1664. X{
  1665. X    if (exact && (compare(name, *length, vp->name, (int)vp->namelen) != 0))
  1666. X    return NULL;
  1667. X    bcopy((char *)vp->name, (char *)name, (int)vp->namelen * sizeof(oid));
  1668. X    *length = vp->namelen;
  1669. X    *access_method = 0;
  1670. X    *var_len = sizeof(long);
  1671. X    return ((u_char *)&mib_udp) + vp->magic;
  1672. X}
  1673. END_OF_FILE
  1674.   if test 33903 -ne `wc -c <'netramet/src/snmplib/~snmp_vars.c.kip'`; then
  1675.     echo shar: \"'netramet/src/snmplib/~snmp_vars.c.kip'\" unpacked with wrong size!
  1676.   fi
  1677.   # end of 'netramet/src/snmplib/~snmp_vars.c.kip'
  1678. fi
  1679. echo shar: End of archive 18 \(of 25\).
  1680. cp /dev/null ark18isdone
  1681. MISSING=""
  1682. for I in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 ; do
  1683.     if test ! -f ark${I}isdone ; then
  1684.     MISSING="${MISSING} ${I}"
  1685.     fi
  1686. done
  1687. if test "${MISSING}" = "" ; then
  1688.     echo You have unpacked all 25 archives.
  1689.     rm -f ark[1-9]isdone ark[1-9][0-9]isdone
  1690. else
  1691.     echo You still must unpack the following archives:
  1692.     echo "        " ${MISSING}
  1693. fi
  1694. exit 0
  1695. exit 0 # Just in case...
  1696.