home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1994 March / Source_Code_CD-ROM_Walnut_Creek_March_1994.iso / compsrcs / misc / volume40 / netramet / part06 < prev    next >
Encoding:
Text File  |  1993-11-07  |  63.8 KB  |  1,850 lines
  1. Newsgroups: comp.sources.misc
  2. From: nevil@ccu1.aukuni.ac.nz (J Nevil Brownlee)
  3. Subject: v40i094:  netramet - Network Traffic Accounting Meter, Part06/25
  4. Message-ID: <1993Nov7.220714.11323@sparky.sterling.com>
  5. X-Md4-Signature: a94c8c297d3064ee8ef48548fce08b4f
  6. Sender: kent@sparky.sterling.com (Kent Landfield)
  7. Organization: Sterling Software
  8. Date: Sun, 7 Nov 1993 22:07:14 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 94
  13. Archive-name: netramet/part06
  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/apps/snmptrap.c netramet/src/meter/met_vars.c
  21. #   netramet/src/snmplib/include/ausnmp.h
  22. # Wrapped by kent@sparky on Tue Nov  2 18:17:06 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 6 (of 25)."'
  26. if test -f 'netramet/src/apps/snmptrap.c' -a "${1}" != "-c" ; then 
  27.   echo shar: Will not clobber existing file \"'netramet/src/apps/snmptrap.c'\"
  28. else
  29.   echo shar: Extracting \"'netramet/src/apps/snmptrap.c'\" \(6730 characters\)
  30.   sed "s/^X//" >'netramet/src/apps/snmptrap.c' <<'END_OF_FILE'
  31. X/*
  32. X * snmptrap.c - send snmp traps to a network entity.
  33. X *
  34. X */
  35. X/***********************************************************
  36. X    Copyright 1989 by Carnegie Mellon University
  37. X
  38. X                      All Rights Reserved
  39. X
  40. XPermission to use, copy, modify, and distribute this software and its 
  41. Xdocumentation for any purpose and without fee is hereby granted, 
  42. Xprovided that the above copyright notice appear in all copies and that
  43. Xboth that copyright notice and this permission notice appear in 
  44. Xsupporting documentation, and that the name of CMU not be
  45. Xused in advertising or publicity pertaining to distribution of the
  46. Xsoftware without specific, written prior permission.  
  47. X
  48. XCMU DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  49. XALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  50. XCMU BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  51. XANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  52. XWHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  53. XARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  54. XSOFTWARE.
  55. X******************************************************************/
  56. X#include <sys/types.h>
  57. X#include <netinet/in.h>
  58. X#include <netdb.h>
  59. X#include <stdio.h>
  60. X#include <sys/time.h>
  61. X#include <sys/socket.h>
  62. X#include <net/if.h>
  63. X#include <sys/ioctl.h>
  64. X#include <sys/file.h>
  65. X#include <nlist.h>
  66. X
  67. X#include "ausnmp.h"
  68. X#include "snmp.h"
  69. X#include "snmpimpl.h"
  70. X#include "asn1.h"
  71. X#include "snmpapi.h"
  72. X#include "snmpclnt.h"
  73. X
  74. Xextern int  errno;
  75. Xint    snmp_dump_packet = 0;
  76. X
  77. X#define NUM_NETWORKS    16   /* max number of interfaces to check */
  78. X
  79. Xoid objid_enterprise[] = {1, 3, 6, 1, 4, 1, 3, 1, 1};
  80. Xoid objid_sysdescr[] = {1, 3, 6, 1, 2, 1, 1, 1, 0};
  81. X
  82. Xstruct nlist nl[] = {
  83. X    { "_boottime" },
  84. X    { "" }
  85. X};
  86. X
  87. X
  88. Xint snmp_input(){
  89. X}
  90. X
  91. X#ifndef IFF_LOOPBACK
  92. X#define IFF_LOOPBACK 0
  93. X#endif
  94. X#define LOOPBACK    0x7f000001
  95. Xu_long
  96. Xget_myaddr(){
  97. X    int sd;
  98. X    struct ifconf ifc;
  99. X    struct ifreq conf[NUM_NETWORKS], *ifrp, ifreq;
  100. X    struct sockaddr_in *in_addr;
  101. X    int count;
  102. X    int interfaces;        /* number of interfaces returned by ioctl */
  103. X
  104. X    if ((sd = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
  105. X    return 0;
  106. X    ifc.ifc_len = sizeof(conf);
  107. X    ifc.ifc_buf = (caddr_t)conf;
  108. X    if (ioctl(sd, SIOCGIFCONF, (char *)&ifc) < 0){
  109. X    close(sd);
  110. X    return 0;
  111. X    }
  112. X    ifrp = ifc.ifc_req;
  113. X    interfaces = ifc.ifc_len / sizeof(struct ifreq);
  114. X    for(count = 0; count < interfaces; count++, ifrp++){
  115. X    ifreq = *ifrp;
  116. X    if (ioctl(sd, SIOCGIFFLAGS, (char *)&ifreq) < 0)
  117. X        continue;
  118. X    in_addr = (struct sockaddr_in *)&ifrp->ifr_addr;
  119. X    if ((ifreq.ifr_flags & IFF_UP)
  120. X        && (ifreq.ifr_flags & IFF_RUNNING)
  121. X        && !(ifreq.ifr_flags & IFF_LOOPBACK)
  122. X        && in_addr->sin_addr.s_addr != LOOPBACK){
  123. X        close(sd);
  124. X        return in_addr->sin_addr.s_addr;
  125. X        }
  126. X    }
  127. X    close(sd);
  128. X    return 0;
  129. X}
  130. X
  131. X/*
  132. X * Returns uptime in centiseconds(!).
  133. X */
  134. Xlong uptime(){
  135. X    struct timeval boottime, now, diff;
  136. X    int kmem;
  137. X
  138. X    if ((kmem = open("/dev/kmem", 0)) < 0)
  139. X    return 0;
  140. X    nlist("/vmunix", nl);
  141. X    if (nl[0].n_type == 0){
  142. X    close(kmem);
  143. X    return 0;
  144. X    }
  145. X    
  146. X    lseek(kmem, (long)nl[0].n_value, L_SET);
  147. X    read(kmem, &boottime, sizeof(boottime));
  148. X    close(kmem);
  149. X
  150. X    gettimeofday(&now, 0);
  151. X    now.tv_sec--;
  152. X    now.tv_usec += 1000000L;
  153. X    diff.tv_sec = now.tv_sec - boottime.tv_sec;
  154. X    diff.tv_usec = now.tv_usec - boottime.tv_usec;
  155. X    if (diff.tv_usec > 1000000L){
  156. X    diff.tv_usec -= 1000000L;
  157. X    diff.tv_sec++;
  158. X    }
  159. X    return ((diff.tv_sec * 100) + (diff.tv_usec / 10000));
  160. X}
  161. X
  162. Xu_long parse_address(address)
  163. X    char *address;
  164. X{
  165. X    u_long addr;
  166. X    struct sockaddr_in saddr;
  167. X    struct hostent *hp;
  168. X
  169. X    if ((addr = inet_addr(address)) != -1)
  170. X    return addr;
  171. X    hp = gethostbyname(address);
  172. X    if (hp == NULL){
  173. X    fprintf(stderr, "unknown host: %s\n", address);
  174. X    return 0;
  175. X    } else {
  176. X    bcopy((char *)hp->h_addr, (char *)&saddr.sin_addr, hp->h_length);
  177. X    return saddr.sin_addr.s_addr;
  178. X    }
  179. X
  180. X}
  181. Xmain(argc, argv)
  182. X    int        argc;
  183. X    char    *argv[];
  184. X{
  185. X    struct snmp_session session, *ss;
  186. X    struct snmp_pdu *pdu;
  187. X    struct variable_list *vars;
  188. X    int    arg;
  189. X    char *gateway = NULL;
  190. X    char *community = NULL;
  191. X    char *trap = NULL, *specific = NULL, *description = NULL, *agent = NULL;
  192. X
  193. X
  194. X    /*
  195. X     * usage: snmptrap gateway-name community-name trap-type specific-type device-description [ -a agent-addr ]
  196. X     */
  197. X    for(arg = 1; arg < argc; arg++){
  198. X    if (argv[arg][0] == '-'){
  199. X        switch(argv[arg][1]){
  200. X        case 'a':
  201. X            agent = argv[++arg];
  202. X            break;
  203. X        case 'd':
  204. X            snmp_dump_packet++;
  205. X            break;
  206. X        default:
  207. X            printf("invalid option: -%c\n", argv[arg][1]);
  208. X            break;
  209. X        }
  210. X        continue;
  211. X    }
  212. X    if (gateway == NULL){
  213. X        gateway = argv[arg];
  214. X    } else if (community == NULL){
  215. X        community = argv[arg]; 
  216. X    } else if (trap == NULL){
  217. X        trap = argv[arg];
  218. X    } else if (specific == NULL){
  219. X        specific = argv[arg];
  220. X    } else {
  221. X        description = argv[arg];
  222. X    }
  223. X    }
  224. X
  225. X    if (!(gateway && community && trap && specific && description)){
  226. X    printf("usage: snmptrap host community trap-type specific-type device-description [ -a agent-addr ]\n");
  227. X    exit(1);
  228. X    }
  229. X
  230. X    bzero((char *)&session, sizeof(struct snmp_session));
  231. X    session.peername = gateway;
  232. X    session.community = (u_char *)community;
  233. X    session.community_len = strlen((char *)community);
  234. X    session.retries = SNMP_DEFAULT_RETRIES;
  235. X    session.timeout = SNMP_DEFAULT_TIMEOUT;
  236. X    session.authenticator = NULL;
  237. X    session.callback = snmp_input;
  238. X    session.callback_magic = NULL;
  239. X    session.remote_port = SNMP_TRAP_PORT;
  240. X    ss = snmp_open(&session);
  241. X    if (ss == NULL){
  242. X    printf("Couldn't open snmp\n");
  243. X    exit(-1);
  244. X    }
  245. X
  246. X    pdu = snmp_pdu_create(TRP_REQ_MSG);
  247. X    pdu->enterprise = (oid *)malloc(sizeof(objid_enterprise));
  248. X    bcopy((char *)objid_enterprise, (char *)pdu->enterprise, sizeof(objid_enterprise));
  249. X    pdu->enterprise_length = sizeof(objid_enterprise) / sizeof(oid);
  250. X    if (agent != NULL)
  251. X    pdu->agent_addr.sin_addr.s_addr = parse_address(agent);
  252. X    else
  253. X    pdu->agent_addr.sin_addr.s_addr = get_myaddr();
  254. X    pdu->trap_type = atoi(trap);
  255. X    pdu->specific_type = atoi(specific);
  256. X    pdu->time = uptime();
  257. X
  258. X    pdu->variables = vars = (struct variable_list *)malloc(sizeof(struct variable_list));
  259. X    vars->next_variable = NULL;
  260. X    vars->name = (oid *)malloc(sizeof(objid_sysdescr));
  261. X    bcopy((char *)objid_sysdescr, (char *)vars->name, sizeof(objid_sysdescr));
  262. X    vars->name_length = sizeof(objid_sysdescr) / sizeof(oid);
  263. X    vars->type = ASN_OCTET_STR;
  264. X    vars->val.string = (u_char *)malloc(strlen(description) + 1);
  265. X    strcpy((char *)vars->val.string, description);
  266. X    vars->val_len = strlen(description);
  267. X
  268. X    if (snmp_send(ss, pdu)== 0){
  269. X    printf("error\n");
  270. X    }
  271. X    snmp_close(ss);
  272. X}
  273. X
  274. END_OF_FILE
  275.   if test 6730 -ne `wc -c <'netramet/src/apps/snmptrap.c'`; then
  276.     echo shar: \"'netramet/src/apps/snmptrap.c'\" unpacked with wrong size!
  277.   fi
  278.   # end of 'netramet/src/apps/snmptrap.c'
  279. fi
  280. if test -f 'netramet/src/meter/met_vars.c' -a "${1}" != "-c" ; then 
  281.   echo shar: Will not clobber existing file \"'netramet/src/meter/met_vars.c'\"
  282. else
  283.   echo shar: Extracting \"'netramet/src/meter/met_vars.c'\" \(53127 characters\)
  284.   sed "s/^X//" >'netramet/src/meter/met_vars.c' <<'END_OF_FILE'
  285. X/* 1125, Tue 5 Oct 93
  286. X
  287. X   MET_VARS.C:  AU Internet Accounting Meter snmp agent
  288. X        Based on the CMU snmpd version, snmpd.c
  289. X
  290. X   Copyright (C) 1992,1993 by Nevil Brownlee,
  291. X   Computer Centre,  University of Auckland */
  292. X
  293. X#define noTESTING
  294. X#define noGC_TEST
  295. X
  296. X#include "ausnmp.h"
  297. X
  298. X#include <ctype.h>
  299. X#include <sys/types.h>
  300. X
  301. X#ifdef AU_MSDOS
  302. X#include <alloc.h>
  303. X#endif
  304. X
  305. X#ifdef SUNOS
  306. X#include <malloc.h>
  307. X#ifdef TESTING
  308. X#include "stdio.h"
  309. X#endif
  310. X#endif
  311. X
  312. X#include "pktsnap.h"
  313. X#include "flowhash.h"
  314. X
  315. X#ifdef AU_MSDOS
  316. X#include "tcp.h"
  317. X
  318. X#else
  319. X
  320. X#include <nlist.h>  /* BSD include files, used in CMU snmpvars.c */
  321. X#include <syslog.h>
  322. X#include <sys/time.h>
  323. X#include <sys/socket.h>
  324. X#include <netinet/in.h>
  325. X#include <sys/param.h>
  326. X#include <sys/dir.h>
  327. X#include <net/if.h>
  328. X#include <net/route.h>
  329. X#include <netinet/in_pcb.h>
  330. X#include <netinet/if_ether.h>
  331. X#include <netinet/in_systm.h>
  332. X#include <netinet/in_var.h>
  333. X#include <netinet/ip.h>
  334. X#include <netinet/ip_var.h>
  335. X#include <netinet/tcp.h>
  336. X#include <netinet/tcp_timer.h>
  337. X#include <netinet/tcp_var.h>
  338. X#include <netinet/tcp_fsm.h>
  339. X#include <netinet/udp.h>
  340. X#include <netinet/udp_var.h>
  341. X#include <netinet/ip_icmp.h>
  342. X#include <netinet/icmp_var.h>
  343. X
  344. X#ifdef BSD_UNIX  /* Not provided by SG Irix or giving errors with SunOS  */
  345. X#include <machine/pte.h>
  346. X#include <sys/ioctl.h>
  347. X#include <sys/proc.h>
  348. X#include <sys/protosw.h>
  349. X#include <sys/user.h>
  350. X#include <sys/vm.h>
  351. X#endif
  352. X
  353. X#endif  /* End !AU_MSDOS */
  354. X
  355. X#ifndef NULL
  356. X#define NULL 0
  357. X#endif
  358. X
  359. X#include "asn1.h"  /* CMU snmp include files */
  360. X#include "snmp.h"
  361. X#include "snmpimpl.h"
  362. X#include "mib.h"
  363. X
  364. X#include "met_vars.h"  /* Constants for snmp oids */
  365. X
  366. Xlong long_return;
  367. X
  368. Xvoid init_snmp()
  369. X{  }
  370. X
  371. X#define INT_ACCT    1, 3, 6, 1, 3, 99
  372. X#define U_AUCKLAND  1, 3, 6, 1, 4, 1, 411
  373. X
  374. Xchar version_descr[] = "NeTraMet: Network Traffic Meter V2.0";
  375. Xoid version_id[] = {
  376. X     1,  3,  6,       1,      4,          1,   411,     1, 2,2};
  377. X/* iso.org.dod.internet.private.enterprises.U_Auckland.monitor.2.2 */
  378. X
  379. Xstruct variable     variables[] = {
  380. X    /* these must be lexicographly ordered by the name field */
  381. X    {{MIB, 1, 1, 0},        9, STRING,  VERSION_DESCR, RONLY, var_system},
  382. X    {{MIB, 1, 2, 0},        9, OBJID,   VERSION_ID, RONLY, var_system},
  383. X    {{MIB, 1, 3, 0},        9, TIMETICKS, UPTIME, RONLY, var_system},
  384. X    {{MIB, 2, 1, 0},        9, INTEGER, IFNUMBER, RONLY, var_system},
  385. X
  386. X   {{INT_ACCT, 1, 1, 0},       9, INTEGER, HIGHWATERMARK, RWRITE, var_system},
  387. X   {{INT_ACCT, 1, 2, 0},       9, INTEGER, FLOODMARK, RWRITE, var_system},
  388. X   {{INT_ACCT, 1, 3, 0},       9, INTEGER, INACT_TIMEOUT, RWRITE, var_system},
  389. X   {{INT_ACCT, 1, 5, 1, 1, MAX_SUBID}, 11, INTEGER, CIINDEX, RONLY, var_rinfo},
  390. X   {{INT_ACCT, 1, 5, 1, 2, MAX_SUBID}, 11, STRING, CIPEERADDR, RONLY, var_rinfo},
  391. X   {{INT_ACCT, 1, 5, 1, 3, MAX_SUBID}, 11, TIMETICKS, CILASTTIME, RONLY, var_rinfo},
  392. X   {{INT_ACCT, 1, 5, 1, 4, MAX_SUBID}, 11, TIMETICKS, CIPREVTIME, RONLY, var_rinfo},
  393. X   {{INT_ACCT, 1, 6, 0},       9, TIMETICKS, LAST_COLLECT_TIME, RWRITE, var_system},
  394. X   {{INT_ACCT, 1, 7, 1, 1, MAX_SUBID}, 11, INTEGER, RIINDEX, RONLY, var_rinfo},
  395. X   {{INT_ACCT, 1, 7, 1, 2, MAX_SUBID}, 11, INTEGER, RIRULESIZE, RWRITE, var_rinfo},
  396. X   {{INT_ACCT, 1, 7, 1, 3, MAX_SUBID}, 11, INTEGER, RIACTIONSIZE, RWRITE, var_rinfo},
  397. X   {{INT_ACCT, 1, 8, 0},       9, INTEGER, CURRENT_RULE_SET, RWRITE, var_system},
  398. X   {{INT_ACCT, 1, 9, 0},       9, INTEGER, EMERGENCY_RULE_SET, RWRITE, var_system},
  399. X
  400. X   {{INT_ACCT, 2, 1, 1,  1, MAX_SUBID}, 11, INTEGER, FTFLOWINDEX, RONLY, var_ft},
  401. X   {{INT_ACCT, 2, 1, 1,  2, MAX_SUBID}, 11, INTEGER, FTFLOWSTATUS, RONLY, var_ft},
  402. X   {{INT_ACCT, 2, 1, 1,  3, MAX_SUBID}, 11, INTEGER, FTLOWINTERFACE, RONLY, var_ft},
  403. X   {{INT_ACCT, 2, 1, 1,  4, MAX_SUBID}, 11, INTEGER, FTLOWADJACENTTYPE, RONLY, var_ft},
  404. X   {{INT_ACCT, 2, 1, 1,  5, MAX_SUBID}, 11, STRING,  FTLOWADJACENTADDRESS, RONLY, var_ft},
  405. X   {{INT_ACCT, 2, 1, 1,  6, MAX_SUBID}, 11, STRING,  FTLOWADJACENTMASK, RONLY, var_ft},
  406. X   {{INT_ACCT, 2, 1, 1,  7, MAX_SUBID}, 11, INTEGER, FTLOWPEERTYPE, RONLY, var_ft},
  407. X   {{INT_ACCT, 2, 1, 1,  8, MAX_SUBID}, 11, INTEGER, FTLOWPEERTYPEMASK, RONLY, var_ft},
  408. X   {{INT_ACCT, 2, 1, 1,  9, MAX_SUBID}, 11, STRING,  FTLOWPEERADDRESS, RONLY, var_ft},
  409. X   {{INT_ACCT, 2, 1, 1, 10, MAX_SUBID}, 11, STRING,  FTLOWPEERMASK, RONLY, var_ft},
  410. X   {{INT_ACCT, 2, 1, 1, 11, MAX_SUBID}, 11, INTEGER, FTLOWDETAILTYPE, RONLY, var_ft},
  411. X   {{INT_ACCT, 2, 1, 1, 12, MAX_SUBID}, 11, INTEGER, FTLOWDETAILTYPEMASK, RONLY, var_ft},
  412. X   {{INT_ACCT, 2, 1, 1, 13, MAX_SUBID}, 11, STRING,  FTLOWDETAILADDRESS, RONLY, var_ft},
  413. X   {{INT_ACCT, 2, 1, 1, 14, MAX_SUBID}, 11, STRING,  FTLOWDETAILMASK, RONLY, var_ft},
  414. X   {{INT_ACCT, 2, 1, 1, 17, MAX_SUBID}, 11, INTEGER, FTHIINTERFACE, RONLY, var_ft},
  415. X   {{INT_ACCT, 2, 1, 1, 18, MAX_SUBID}, 11, INTEGER, FTHIADJACENTTYPE, RONLY, var_ft},
  416. X   {{INT_ACCT, 2, 1, 1, 19, MAX_SUBID}, 11, STRING,  FTHIADJACENTADDRESS, RONLY, var_ft},
  417. X   {{INT_ACCT, 2, 1, 1, 20, MAX_SUBID}, 11, STRING,  FTHIADJACENTMASK, RONLY, var_ft},
  418. X   {{INT_ACCT, 2, 1, 1, 21, MAX_SUBID}, 11, INTEGER, FTHIPEERTYPE, RONLY, var_ft},
  419. X   {{INT_ACCT, 2, 1, 1, 22, MAX_SUBID}, 11, INTEGER, FTHIPEERTYPEMASK, RONLY, var_ft},
  420. X   {{INT_ACCT, 2, 1, 1, 23, MAX_SUBID}, 11, STRING,  FTHIPEERADDRESS, RONLY, var_ft},
  421. X   {{INT_ACCT, 2, 1, 1, 24, MAX_SUBID}, 11, STRING,  FTHIPEERMASK, RONLY, var_ft},
  422. X   {{INT_ACCT, 2, 1, 1, 25, MAX_SUBID}, 11, INTEGER, FTHIDETAILTYPE, RONLY, var_ft},
  423. X   {{INT_ACCT, 2, 1, 1, 26, MAX_SUBID}, 11, INTEGER, FTHIDETAILTYPEMASK, RONLY, var_ft},
  424. X   {{INT_ACCT, 2, 1, 1, 27, MAX_SUBID}, 11, STRING,  FTHIDETAILADDRESS, RONLY, var_ft},
  425. X   {{INT_ACCT, 2, 1, 1, 28, MAX_SUBID}, 11, STRING,  FTHIDETAILMASK, RONLY, var_ft},
  426. X   {{INT_ACCT, 2, 1, 1, 33, MAX_SUBID}, 11, INTEGER, FTPDUSCALE, RONLY, var_ft},
  427. X   {{INT_ACCT, 2, 1, 1, 34, MAX_SUBID}, 11, INTEGER, FTOCTETSCALE, RONLY, var_ft},
  428. X   {{INT_ACCT, 2, 1, 1, 35, MAX_SUBID}, 11, INTEGER, FTRULESET, RONLY, var_ft},
  429. X   {{INT_ACCT, 2, 1, 1, 36, MAX_SUBID}, 11, INTEGER, FTFLOWTYPE, RONLY, var_ft},
  430. X   {{INT_ACCT, 2, 1, 1, 37, MAX_SUBID}, 11, COUNTER, FTUPOCTETS, RONLY, var_ft},
  431. X   {{INT_ACCT, 2, 1, 1, 38, MAX_SUBID}, 11, COUNTER, FTUPPDUS, RONLY, var_ft},
  432. X   {{INT_ACCT, 2, 1, 1, 39, MAX_SUBID}, 11, COUNTER, FTDOWNOCTETS, RONLY, var_ft},
  433. X   {{INT_ACCT, 2, 1, 1, 40, MAX_SUBID}, 11, COUNTER, FTDOWNPDUS, RONLY, var_ft},
  434. X   {{INT_ACCT, 2, 1, 1, 41, MAX_SUBID}, 11, TIMETICKS, FTFIRSTTIME, RONLY, var_ft},
  435. X   {{INT_ACCT, 2, 1, 1, 42, MAX_SUBID}, 11, TIMETICKS, FTLASTTIME, RONLY, var_ft},
  436. X
  437. X   {{INT_ACCT, 2, 2, 1, 1, MAX_SUBID, MAX_SUBID}, 12, TIMETICKS, FTCRFIRSTTIME, RONLY, var_flow_index},
  438. X   {{INT_ACCT, 2, 2, 1, 2, MAX_SUBID, MAX_SUBID}, 12, INTEGER, FTCRFLOWINDEX, RONLY, var_flow_index},
  439. X
  440. X   {{INT_ACCT, 2, 3, 1, 1, MAX_SUBID, MAX_SUBID}, 12, TIMETICKS, FTACFIRSTTIME, RONLY, var_flow_index},
  441. X   {{INT_ACCT, 2, 3, 1, 2, MAX_SUBID, MAX_SUBID}, 12, INTEGER, FTACFLOWINDEX, RONLY, var_flow_index},
  442. X
  443. X   {{INT_ACCT, 2, 4, 1, 1, MAX_SUBID, MAX_SUBID, MAX_SUBID}, 13, INTEGER, FTCOLATTRIB, RONLY, var_col_tbl},
  444. X   {{INT_ACCT, 2, 4, 1, 2, MAX_SUBID, MAX_SUBID, MAX_SUBID}, 13, TIMETICKS, FTCOLTIME, RONLY, var_col_tbl},
  445. X   {{INT_ACCT, 2, 4, 1, 3, MAX_SUBID, MAX_SUBID, MAX_SUBID}, 13, INTEGER, FTCOLINDEX, RONLY, var_col_tbl},
  446. X   {{INT_ACCT, 2, 4, 1, 4, MAX_SUBID, MAX_SUBID, MAX_SUBID}, 13, OPAQUE, FTCOLBLOB, RONLY, var_col_tbl},
  447. X
  448. X   {{INT_ACCT, 3, 1, 1, 1, MAX_SUBID, MAX_SUBID}, 12, INTEGER, RTRULESET, RONLY, var_rt},
  449. X   {{INT_ACCT, 3, 1, 1, 2, MAX_SUBID, MAX_SUBID}, 12, INTEGER, RTRULEINDEX, RONLY, var_rt},
  450. X   {{INT_ACCT, 3, 1, 1, 3, MAX_SUBID, MAX_SUBID}, 12, INTEGER, RTSELECTOR, RWRITE, var_rt},
  451. X   {{INT_ACCT, 3, 1, 1, 4, MAX_SUBID, MAX_SUBID}, 12, STRING, RTRULEMASK, RWRITE, var_rt},
  452. X   {{INT_ACCT, 3, 1, 1, 5, MAX_SUBID, MAX_SUBID}, 12, STRING, RTMATCHVALUE, RWRITE, var_rt},
  453. X   {{INT_ACCT, 3, 1, 1, 6, MAX_SUBID, MAX_SUBID}, 12, INTEGER, RTRULEACTION, RWRITE, var_rt},
  454. X   {{INT_ACCT, 3, 1, 1, 7, MAX_SUBID, MAX_SUBID}, 12, INTEGER, RTJUMPINDEX, RWRITE, var_rt},
  455. X
  456. X   {{INT_ACCT, 4, 1, 1,  1, MAX_SUBID, MAX_SUBID}, 12, INTEGER, ATACTIONINDEX, RONLY, var_rt},
  457. X   {{INT_ACCT, 4, 1, 1,  3, MAX_SUBID, MAX_SUBID}, 12, INTEGER, ATLOWINTERFACE, RONLY, var_rt},
  458. X   {{INT_ACCT, 4, 1, 1,  4, MAX_SUBID, MAX_SUBID}, 12, INTEGER, ATLOWADJACENTTYPE, RWRITE, var_rt},
  459. X   {{INT_ACCT, 4, 1, 1,  5, MAX_SUBID, MAX_SUBID}, 12, STRING,  ATLOWADJACENTADDRESS, RWRITE, var_rt},
  460. X   {{INT_ACCT, 4, 1, 1,  6, MAX_SUBID, MAX_SUBID}, 12, STRING,  ATLOWADJACENTMASK, RWRITE, var_rt},
  461. X   {{INT_ACCT, 4, 1, 1,  7, MAX_SUBID, MAX_SUBID}, 12, INTEGER, ATLOWPEERTYPE, RWRITE, var_rt},
  462. X   {{INT_ACCT, 4, 1, 1,  8, MAX_SUBID, MAX_SUBID}, 12, INTEGER, ATLOWPEERTYPEMASK, RWRITE, var_rt},
  463. X   {{INT_ACCT, 4, 1, 1,  9, MAX_SUBID, MAX_SUBID}, 12, STRING,  ATLOWPEERADDRESS, RWRITE, var_rt},
  464. X   {{INT_ACCT, 4, 1, 1, 10, MAX_SUBID, MAX_SUBID}, 12, STRING,  ATLOWPEERMASK, RWRITE, var_rt},
  465. X   {{INT_ACCT, 4, 1, 1, 11, MAX_SUBID, MAX_SUBID}, 12, INTEGER, ATLOWDETAILTYPE, RWRITE, var_rt},
  466. X   {{INT_ACCT, 4, 1, 1, 12, MAX_SUBID, MAX_SUBID}, 12, INTEGER, ATLOWDETAILTYPEMASK, RWRITE, var_rt},
  467. X   {{INT_ACCT, 4, 1, 1, 13, MAX_SUBID, MAX_SUBID}, 12, STRING,  ATLOWDETAILADDRESS, RWRITE, var_rt},
  468. X   {{INT_ACCT, 4, 1, 1, 14, MAX_SUBID, MAX_SUBID}, 12, STRING,  ATLOWDETAILMASK, RWRITE, var_rt},
  469. X   {{INT_ACCT, 4, 1, 1, 17, MAX_SUBID, MAX_SUBID}, 12, INTEGER, ATHIINTERFACE, RWRITE, var_rt},
  470. X   {{INT_ACCT, 4, 1, 1, 18, MAX_SUBID, MAX_SUBID}, 12, INTEGER, ATHIADJACENTTYPE, RWRITE, var_rt},
  471. X   {{INT_ACCT, 4, 1, 1, 19, MAX_SUBID, MAX_SUBID}, 12, STRING,  ATHIADJACENTADDRESS, RWRITE, var_rt},
  472. X   {{INT_ACCT, 4, 1, 1, 20, MAX_SUBID, MAX_SUBID}, 12, STRING,  ATHIADJACENTMASK, RWRITE, var_rt},
  473. X   {{INT_ACCT, 4, 1, 1, 21, MAX_SUBID, MAX_SUBID}, 12, INTEGER, ATHIPEERTYPE, RWRITE, var_rt},
  474. X   {{INT_ACCT, 4, 1, 1, 22, MAX_SUBID, MAX_SUBID}, 12, INTEGER, ATHIPEERTYPEMASK, RWRITE, var_rt},
  475. X   {{INT_ACCT, 4, 1, 1, 23, MAX_SUBID, MAX_SUBID}, 12, STRING,  ATHIPEERADDRESS, RWRITE, var_rt},
  476. X   {{INT_ACCT, 4, 1, 1, 24, MAX_SUBID, MAX_SUBID}, 12, STRING,  ATHIPEERMASK, RWRITE, var_rt},
  477. X   {{INT_ACCT, 4, 1, 1, 25, MAX_SUBID, MAX_SUBID}, 12, INTEGER, ATHIDETAILTYPE, RWRITE, var_rt},
  478. X   {{INT_ACCT, 4, 1, 1, 26, MAX_SUBID, MAX_SUBID}, 12, INTEGER, ATHIDETAILTYPEMASK, RWRITE, var_rt},
  479. X   {{INT_ACCT, 4, 1, 1, 27, MAX_SUBID, MAX_SUBID}, 12, STRING,  ATHIDETAILADDRESS, RWRITE, var_rt},
  480. X   {{INT_ACCT, 4, 1, 1, 28, MAX_SUBID, MAX_SUBID}, 12, STRING,  ATHIDETAILMASK, RWRITE, var_rt},
  481. X   {{INT_ACCT, 4, 1, 1, 33, MAX_SUBID, MAX_SUBID}, 12, INTEGER, ATPDUSCALE, RWRITE, var_rt},
  482. X   {{INT_ACCT, 4, 1, 1, 34, MAX_SUBID, MAX_SUBID}, 12, INTEGER, ATOCTETSCALE, RWRITE, var_rt},
  483. X   {{INT_ACCT, 4, 1, 1, 35, MAX_SUBID, MAX_SUBID}, 12, INTEGER, ATACTIONSET, RWRITE, var_rt},
  484. X
  485. X   {{U_AUCKLAND, 1,  1, 0},  10, INTEGER, MSSTATSRESET, RWRITE, var_system},
  486. X   {{U_AUCKLAND, 1,  2, 0},  10, INTEGER, MSSTATSTIME, RONLY, var_system},
  487. X   {{U_AUCKLAND, 1,  3, 0},  10, INTEGER, MSNPACKETS, RONLY, var_system},
  488. X   {{U_AUCKLAND, 1,  4, 0},  10, INTEGER, MSTBACKLOG, RONLY, var_system},
  489. X   {{U_AUCKLAND, 1,  5, 0},  10, INTEGER, MSMXPKTRATE, RONLY, var_system},
  490. X   {{U_AUCKLAND, 1,  6, 0},  10, INTEGER, MSMXBACKLOG, RONLY, var_system},
  491. X   {{U_AUCKLAND, 1,  7, 0},  10, INTEGER, MSNFLOWS, RONLY, var_system},
  492. X   {{U_AUCKLAND, 1,  8, 0},  10, INTEGER, MSFLOWSRCV, RONLY, var_system},
  493. X   {{U_AUCKLAND, 1,  9, 0},  10, INTEGER, MSNMATCHES, RONLY, var_system},
  494. X   {{U_AUCKLAND, 1, 10, 0},  10, INTEGER, MSHASHSRCHS, RONLY, var_system},
  495. X   {{U_AUCKLAND, 1, 11, 0},  10, INTEGER, MSHASHCMPS, RONLY, var_system},
  496. X   {{U_AUCKLAND, 1, 12, 0},  10, INTEGER, MSTHASHSZ, RONLY, var_system},
  497. X   {{U_AUCKLAND, 1, 13, 0},  10, INTEGER, MSNHASHENTS, RONLY, var_system},
  498. X   {{U_AUCKLAND, 1, 14, 0},  10, INTEGER, MSGCINTERVAL, RWRITE, var_system},
  499. X   {{U_AUCKLAND, 1, 15, 0},  10, INTEGER, MSMXFLOWS, RONLY, var_system},
  500. X   {{U_AUCKLAND, 1, 16, 0},  10, INTEGER, MSAVIDLEPER1000, RONLY, var_system},
  501. X   {{U_AUCKLAND, 1, 17, 0},  10, INTEGER, MSMINIDLEPER1000, RONLY, var_system},
  502. X
  503. X   {{U_AUCKLAND, 2, 1, 0},   10, INTEGER, PCNEARMEM, RONLY, var_system},
  504. X   {{U_AUCKLAND, 2, 2, 0},   10, INTEGER, PCFARMEM, RONLY, var_system},
  505. X   {{U_AUCKLAND, 2, 3, 0},   10, INTEGER, PCBADPKTS, RONLY, var_system},
  506. X   {{U_AUCKLAND, 2, 4, 0},   10, INTEGER, PCNOBUFPKTS, RONLY, var_system},
  507. X   {{U_AUCKLAND, 2, 5, 0},   10, INTEGER, PCLOSTPKTS, RONLY, var_system},
  508. X   };
  509. X
  510. Xint
  511. Xcompare(name1, len1, name2, len2)
  512. X    register oid        *name1, *name2;
  513. X    register int        len1, len2;
  514. X{
  515. X    register int    len;
  516. X    /* len = minimum of len1 and len2 */
  517. X    if (len1 < len2)
  518. X    len = len1;
  519. X    else
  520. X    len = len2;
  521. X    /* find first non-matching byte */
  522. X    while(len-- > 0){
  523. X    if (*name1 < *name2)
  524. X        return -1;
  525. X    if (*name2++ < *name1++)
  526. X        return 1;
  527. X    }
  528. X    /* bytes match up to length of shorter string */
  529. X    if (len1 < len2)
  530. X    return -1;  /* name1 shorter, so it is "less" */
  531. X    if (len2 < len1)
  532. X    return 1;
  533. X    return 0;    /* both strings are equal */
  534. X}
  535. X
  536. X/*
  537. X * getStatPtr - return a pointer to the named variable, as well as it's
  538. X * type, length, and access control list.
  539. X *
  540. X * If an exact match for the variable name exists, it is returned.  If not,
  541. X * and exact is false, the next variable lexicographically after the
  542. X * requested one is returned.
  543. X *
  544. X * If no appropriate variable can be found, NULL is returned.
  545. X */
  546. Xu_char far *
  547. XgetStatPtr(name, namelen, type, len, acl, exact, access_method)
  548. X    oid        *name;        /* IN - name of var, OUT - name matched */
  549. X    int        *namelen;   /* IN -number of sub-ids in name, OUT - subid-is in matched name */
  550. X    u_char    *type;        /* OUT - type of matched variable */
  551. X    int        *len;        /* OUT - length of matched variable */
  552. X    u_short    *acl;        /* OUT - access control list */
  553. X    int        exact;        /* IN - TRUE if exact match wanted */
  554. X    int        *access_method; /* OUT - 1 if function, 0 if char * */
  555. X{
  556. X    register struct variable    *vp;
  557. X    register int    x;
  558. X    u_char far        *access;
  559. X    int            result;
  560. X    register int    minlen;
  561. X    register oid    *name1, *name2;
  562. X   int b,t;
  563. X
  564. X   b = 0;  t = sizeof(variables)/sizeof(struct variable) - 1;
  565. X   do {  /* Binary search averages about 6 compares instead of 22 */
  566. X      x = (b + t)/2;
  567. X      vp = &variables[x];
  568. X      result = compare(name, *namelen, vp->name, (int)vp->namelen);
  569. X      if (result < 0) t = x-1;  /* Move top down */
  570. X      else b = x+1; /* Move bottom up */
  571. X      } while (b <= t);
  572. X
  573. X   for (x = t, vp = &variables[x];
  574. X     x < sizeof(variables)/sizeof(struct variable);  ++vp, ++x) {
  575. X   /* Find first vp entry >= requested one */
  576. X      result = compare(name, *namelen, vp->name, (int)vp->namelen);
  577. X      if ((result < 0) || (exact && (result == 0))) {
  578. X     access = (*(vp->findVar))(vp, name, namelen, exact, len, access_method);
  579. X     if (access != NULL) {
  580. X        *type = vp->type;
  581. X        *acl = vp->acl;
  582. X        return access;
  583. X        }
  584. X     }
  585. X      }
  586. X
  587. X   return NULL;
  588. X   }
  589. X
  590. Xextern unsigned long snmp_peer_addr;  /* Declared in meter_pc.c */
  591. X
  592. Xvoid display_msg(unsigned char timestamp, char *msg)
  593. X{
  594. X#ifdef AU_MSDOS
  595. X   if (display_enabled) {
  596. X      scpos(0,24);
  597. X      if (timestamp) printf("%02d%02d:%02d  ", tod_h,tod_m,tod_s);
  598. X      else printf("   ");
  599. X      printf(msg);
  600. X      w_roll(0,7, 40,24, 1);
  601. X      }
  602. X#else
  603. X   time_t t; char *ts;
  604. X   if (display_enabled) {
  605. X      if (timestamp) {
  606. X         time(&t);  ts = ctime(&t);
  607. X         printf("%c%c%c%c:%c%c  ", 
  608. X            ts[11],ts[12],ts[14],ts[15], ts[17],ts[18]);
  609. X         }
  610. X      else printf("   ");
  611. X      printf("%s\n",msg);
  612. X      }
  613. X#endif
  614. X   }
  615. X
  616. Xint writechar(int doSet, u_char *var_val,
  617. X   u_char var_val_type, int var_val_len, u_char far *statP);
  618. Xint writeint(int doSet, u_char *var_val,
  619. X   u_char var_val_type, int var_val_len, u_char far *statP);
  620. Xint writelong(int doSet, u_char *var_val,
  621. X   u_char var_val_type, int var_val_len, u_char far *statP);
  622. Xint writeAddress(int doSet, u_char *var_val,
  623. X   u_char var_val_type, int var_val_len, u_char far *statP);
  624. X
  625. Xint writeRuleSet(int doSet, u_char *var_val,
  626. X   u_char var_val_type, int var_val_len, u_char far *statP);
  627. Xint writeRuleSize(int doSet, u_char *var_val,
  628. X   u_char var_val_type, int var_val_len, u_char far *statP);
  629. Xint writeActionSize(int doSet, u_char *var_val,
  630. X   u_char var_val_type, int var_val_len, u_char far *statP);
  631. Xint writeLastCollectTime(int doSet, u_char *var_val,
  632. X   u_char var_val_type, int var_val_len, u_char far *statP);
  633. Xint writeStatsReset(int doSet, u_char *var_val,
  634. X   u_char var_val_type, int var_val_len, u_char far *statP);
  635. X
  636. Xu_char far *
  637. Xvar_system(vp, name, length, exact, var_len, write_method)
  638. X    register struct variable *vp;   /* IN - pointer to variable entry that points here */
  639. X    register oid    *name;        /* IN/OUT - input name requested, output name found */
  640. X    register int    *length;    /* IN/OUT - length of input and output oid's */
  641. X    int            exact;        /* IN - TRUE if an exact match was requested. */
  642. X    int            *var_len;   /* OUT - length of variable or 0 if function returned. */
  643. X    int            (**write_method)(); /* OUT - 1 if function, 0 if char pointer. */
  644. X{
  645. X#ifndef AU_MSDOS
  646. X    struct timeval now, boottime;
  647. X#endif
  648. X   unsigned long dummy;
  649. X
  650. X    if (exact && (compare(name, *length, vp->name, (int)vp->namelen) != 0))
  651. X    return NULL;
  652. X    bcopy((char far *)vp->name, (char far *)name, (int)vp->namelen * sizeof(oid));
  653. X    *length = vp->namelen;
  654. X    *write_method = 0;
  655. X    *var_len = sizeof(long);    /* default length */
  656. X   switch (vp->magic){
  657. X   case VERSION_DESCR:
  658. X      *var_len = strlen(version_descr);
  659. X      return (u_char far *)version_descr;
  660. X   case VERSION_ID:
  661. X      *var_len = sizeof(version_id);
  662. X      return (u_char far *)version_id;
  663. X   case UPTIME:
  664. X      long_return = uptime();
  665. X      return (u_char far *)&long_return;
  666. X   case IFNUMBER:
  667. X      long_return = 1;  /* 1 ethernet card to start with */
  668. X      return (u_char far *)&long_return;
  669. X
  670. X   case HIGHWATERMARK:
  671. X      *write_method = (int (*)())writechar;
  672. X      *var_len = sizeof(unsigned char);
  673. X      return (u_char far *)&HighWaterMark;
  674. X   case FLOODMARK:
  675. X      *write_method = (int (*)())writechar;
  676. X      *var_len = sizeof(unsigned char);
  677. X      return (u_char far *)&FloodMark;
  678. X   case INACT_TIMEOUT:
  679. X      *write_method = (int (*)())writelong;
  680. X      return (u_char far *)&InactivityTimeout;
  681. X   case LAST_COLLECT_TIME:
  682. X      *write_method = (int (*)())writeLastCollectTime;
  683. X      return (u_char far *)&LastCollectTime;
  684. X   case CURRENT_RULE_SET:
  685. X      *write_method = (int (*)())writeRuleSet;
  686. X      *var_len = sizeof(unsigned char);
  687. X      return (u_char far *)&CurrentRuleSet;
  688. X   case EMERGENCY_RULE_SET:
  689. X      *write_method = (int (*)())writeRuleSet;
  690. X      *var_len = sizeof(unsigned char);
  691. X      return (u_char far *)&EmergencyRuleSet;
  692. X
  693. X   case MSSTATSRESET:
  694. X      *write_method = (int (*)())writeStatsReset;
  695. X      long_return = 0;
  696. X      return (u_char far *)&long_return;
  697. X   case MSSTATSTIME:
  698. X      return (u_char far *)&stats_time;
  699. X   case MSNPACKETS:
  700. X      return (u_char far *)&npackets;
  701. X   case MSTBACKLOG:
  702. X      return (u_char far *)&t_backlog;
  703. X   case MSMXPKTRATE:
  704. X      *var_len = sizeof(unsigned int);
  705. X      return (u_char far *)&max_pkt_rate;
  706. X   case MSMXBACKLOG:
  707. X      *var_len = sizeof(unsigned int);
  708. X      return (u_char far *)&max_pkt_backlog;
  709. X   case MSNFLOWS:
  710. X      *var_len = sizeof(unsigned int);
  711. X      return (u_char far *)&nflows;
  712. X   case MSFLOWSRCV:
  713. X      return (u_char far *)&FlowsRecovered;
  714. X   case MSNMATCHES:
  715. X      return (u_char far *)&n_matches;
  716. X   case MSHASHSRCHS:
  717. X      return (u_char far *)&n_hash_searches;
  718. X   case MSHASHCMPS:
  719. X      return (u_char far *)&n_hash_compares;
  720. X   case MSTHASHSZ:
  721. X      *var_len = sizeof(unsigned int);
  722. X      return (u_char far *)&t_hash_size;
  723. X   case MSNHASHENTS:
  724. X      *var_len = sizeof(unsigned int);
  725. X      return (u_char far *)&n_hash_ents;
  726. X   case MSGCINTERVAL:
  727. X      *write_method = (int (*)())writechar;
  728. X      *var_len = sizeof(unsigned char);
  729. X      return (u_char far *)&gc_interval;
  730. X   case MSMXFLOWS:
  731. X      long_return = mxflowsp1-1;  /* Set at meter startup */
  732. X      return (u_char far *)&long_return;
  733. X   case MSAVIDLEPER1000:
  734. X#ifdef AU_MSDOS
  735. X      long_return = kilodummypackets;
  736. X      if (dummypackets >= 500) ++long_return;
  737. X      long_return = long_return*1000L/(long_return+npackets/1000L);
  738. X#else
  739. X      long_return = 0;
  740. X#endif
  741. X      return (u_char far *)&long_return;
  742. X   case MSMINIDLEPER1000:
  743. X#ifdef AU_MSDOS
  744. X      long_return = (mindummyrate*10000L+5L)/((mindummyrate+mdpacketrate)*10L);
  745. X#else
  746. X      long_return = 0;
  747. X#endif
  748. X      return (u_char far *)&long_return;
  749. X
  750. X#ifdef AU_MSDOS
  751. X   case PCNEARMEM:
  752. X      long_return = (long)coreleft();
  753. X      return (u_char far *)&long_return;
  754. X   case PCFARMEM:
  755. X      long_return = (long)farcoreleft();
  756. X      return (u_char far *)&long_return;
  757. X   case PCBADPKTS:
  758. X      return (u_char far *)&badpackets;
  759. X   case PCNOBUFPKTS:
  760. X      return (u_char far *)&nobufpackets;
  761. X   case PCLOSTPKTS:
  762. X      return (u_char far *)&lostpackets;
  763. X#else
  764. X   case PCLOSTPKTS:
  765. X      long_return = 0;
  766. X      return (u_char far *)&long_return;
  767. X#endif
  768. X
  769. X   default:
  770. X      ERROR("");
  771. X      }
  772. X   return NULL;
  773. X   }
  774. X
  775. Xint string_OK(t)
  776. Xint t;
  777. X{
  778. X   if (t != STRING) {
  779. X      display_msg(1,"Not string");  return FALSE;
  780. X      }
  781. X   return TRUE;
  782. X   }
  783. X
  784. Xint int_OK(t)
  785. Xint t;
  786. X{
  787. X   if (t != INTEGER){
  788. X      display_msg(1,"Not integer");  return FALSE;
  789. X      }
  790. X   return TRUE;
  791. X   }
  792. X
  793. Xint writelong(int doSet, u_char *var_val,
  794. X   u_char var_val_type, int var_val_len, u_char far *statP)
  795. X{
  796. X   int bigsize = 1000;
  797. X   long intval = 0;
  798. X   if (!int_OK(var_val_type)) return FALSE;
  799. X   asn_parse_int(var_val, &bigsize, &var_val_type, &intval, sizeof(intval));
  800. X   if (intval < 0) {
  801. X      display_msg(1,"Bad long");  return FALSE;
  802. X      }
  803. X   if (doSet) *((long far *)statP) = intval;
  804. X   return TRUE;
  805. X  }
  806. X
  807. Xint writeint(int doSet, u_char *var_val,
  808. X   u_char var_val_type, int var_val_len, u_char far *statP)
  809. X{
  810. X   int bigsize = 1000;
  811. X   long intval = 0;
  812. X   unsigned int i;
  813. X   if (!int_OK(var_val_type)) return FALSE;
  814. X   asn_parse_int(var_val, &bigsize, &var_val_type, &intval, sizeof(intval));
  815. X   if (intval < 0 || intval > 0xFFFF) {
  816. X      display_msg(1,"Bad int");  return FALSE;
  817. X      }
  818. X   if (doSet) {
  819. X      i = (int)intval;
  820. X      *((int far *)statP) = i;
  821. X      }
  822. X   return TRUE;
  823. X  }
  824. X
  825. Xint writechar(int doSet, u_char *var_val,
  826. X   u_char var_val_type, int var_val_len, u_char far *statP)
  827. X{
  828. X   int bigsize = 1000;
  829. X   long intval = 0;
  830. X   unsigned char c;
  831. X   if (!int_OK(var_val_type)) return FALSE;
  832. X   asn_parse_int(var_val, &bigsize, &var_val_type, &intval, sizeof(intval));
  833. X   if (intval < 0 || intval > 0xFF) {
  834. X      display_msg(1,"Bad char");  return FALSE;
  835. X      }
  836. X   if (doSet) {
  837. X      c = (char)intval;
  838. X      *((char far *)statP) = c;
  839. X      }
  840. X   return TRUE;
  841. X  }
  842. X
  843. Xint writeAddress(int doSet, u_char *var_val,
  844. X   u_char var_val_type, int var_val_len, u_char far *statP)
  845. X{
  846. X   int size, bigsize = 1000;
  847. X   u_char buf[RULE_ADDR_LEN], *cp;
  848. X
  849. X   if (!string_OK(var_val_type)) return FALSE;
  850. X   if (var_val_len < 1 || var_val_len > RULE_ADDR_LEN) {
  851. X      display_msg(1,"Bad Address");  return FALSE;
  852. X      }
  853. X   size = sizeof(buf);
  854. X   asn_parse_string(var_val, &bigsize, &var_val_type, buf, &size);
  855. X   if (doSet) {
  856. X      addrcpy(statP, buf, var_val_len);
  857. X      }
  858. X   return TRUE;
  859. X   }
  860. X
  861. Xint writeRuleSet(int doSet, u_char *var_val,
  862. X   u_char var_val_type, int var_val_len, u_char far *statP)
  863. X{
  864. X   int bigsize = 1000;
  865. X   long intval = 0;
  866. X   char msg[30];
  867. X   if (!int_OK(var_val_type)) return FALSE;
  868. X   asn_parse_int(var_val, &bigsize, &var_val_type, &intval, sizeof(intval));
  869. X   if (intval < 1 || intval > MXNRTBLS) {
  870. X      display_msg(1,"Bad RuleSet");  return FALSE;
  871. X      }
  872. X   if (intval == CurrentRuleSet) return TRUE;  /* No change needed */
  873. X   if (doSet) {
  874. X      if (statP == (unsigned char far *)&CurrentRuleSet) {
  875. X     if (!open_rule_set(0, intval)) {
  876. X        display_msg(1,"Incomplete RuleSet");  return FALSE;
  877. X        }
  878. X     else {
  879. X        close_rule_set();
  880. X        open_rule_set(1,intval);
  881. X        sprintf(msg,"Rule set %d opened", intval);
  882. X        display_msg(1,msg);
  883. X        }
  884. X     }
  885. X      else {
  886. X     sprintf(msg,"Emergency rule set %d", EmergencyRuleSet = intval);
  887. X     display_msg(1,msg);
  888. X     }
  889. X      }
  890. X   return TRUE;
  891. X   }
  892. X
  893. Xunsigned char info_table_index;  /* Set by var_rinfo() */
  894. X
  895. Xint writeRuleSize(int doSet, u_char *var_val,
  896. X   u_char var_val_type, int var_val_len, u_char far *statP)
  897. X{
  898. X   int bigsize = 1000;
  899. X   long intval = 0;
  900. X   char msg[30];
  901. X   struct rule far *rt;
  902. X
  903. X   if (!int_OK(var_val_type)) return FALSE;
  904. X   asn_parse_int(var_val, &bigsize, &var_val_type, &intval, sizeof(intval));
  905. X   if (info_table_index == CurrentRuleSet) {
  906. X      display_msg(1,"Can't modify current rules");  return FALSE;
  907. X      }
  908. X   if (info_table_index < 2) {
  909. X      display_msg(1,"Can't modify default rules");  return FALSE;
  910. X      }
  911. X   if (doSet) {
  912. X      if (intval > rt_size[info_table_index-1]) {  /* Needs to be bigger */
  913. X     if (rt_size[info_table_index-1] != 0)
  914. X        farfree(rule_table[info_table_index-1]);
  915. X     rt = (struct rule far *)farmalloc(sizeof(struct rule)*intval);
  916. X     if (rt == NULL) {
  917. X        display_msg(1,"No mem for rule table");  return FALSE;
  918. X        }
  919. X     rule_table[info_table_index-1] = rt;
  920. X     rt_size[info_table_index-1] = intval;
  921. X     }
  922. X      sprintf(msg,"rt[%d]: %d rules", info_table_index,intval);
  923. X      display_msg(1,msg);
  924. X      }
  925. X   return TRUE;
  926. X   }
  927. X
  928. Xint writeActionSize(int doSet, u_char *var_val,
  929. X   u_char var_val_type, int var_val_len, u_char far *statP)
  930. X{
  931. X   int bigsize = 1000, j;
  932. X   long intval = 0;
  933. X   char msg[30];
  934. X   struct flow far *at;
  935. X
  936. X   if (!int_OK(var_val_type)) return FALSE;
  937. X   asn_parse_int(var_val, &bigsize, &var_val_type, &intval, sizeof(intval));
  938. X   if (info_table_index == CurrentRuleSet) {
  939. X      display_msg(1,"Can't modify current actions");  return FALSE;
  940. X      }
  941. X   if (info_table_index < 2) {
  942. X      display_msg(1,"Can't modify default actions");  return FALSE;
  943. X      }
  944. X   if (doSet) {
  945. X      if (intval > at_size[info_table_index-1]) {  /* Needs to be bigger */
  946. X     if (at_size[info_table_index-1] != 0)
  947. X        farfree(action_table[info_table_index-1]);
  948. X     at = (struct flow far *)farmalloc(sizeof(struct flow)*intval);
  949. X     if (at == NULL) {
  950. X        display_msg(1,"No mem for action table");  return FALSE;
  951. X        }
  952. X     action_table[info_table_index-1] = at;
  953. X     at_size[info_table_index-1] = intval;
  954. X     }
  955. X      else at = action_table[info_table_index-1];
  956. X      for (j = 0; j != intval; ++j, ++at) {
  957. X     bcopy((unsigned char far *)Key(null_flow),
  958. X        (unsigned char far *)Key(at), sizeof(struct flow_key));
  959. X     }
  960. X      sprintf(msg,"at[%d]: %d actions", info_table_index,intval);
  961. X      display_msg(1,msg);
  962. X      }
  963. X   return TRUE;
  964. X   }
  965. X
  966. Xint writeLastCollectTime(int doSet, u_char *var_val,
  967. X   u_char var_val_type, int var_val_len, u_char far *statP)
  968. X{
  969. X   int bigsize = 1000;
  970. X   unsigned char j;
  971. X   long intval = 0;
  972. X   char msg[30];
  973. X   unsigned char CollectPeer[4];
  974. X   struct CTinfo *ctip;
  975. X
  976. X   if (var_val_type != TIMETICKS) {
  977. X      display_msg(1,"Not timeticks");  return FALSE;
  978. X      }
  979. X   asn_parse_int(var_val, &bigsize, &var_val_type, &intval, sizeof(intval));
  980. X   if (doSet) {
  981. X      CollectPeer[0] = snmp_peer_addr >> 24;
  982. X      CollectPeer[1] = (snmp_peer_addr >> 16) & 0xFF;
  983. X      CollectPeer[2] = (snmp_peer_addr >>  8) & 0xFF;
  984. X      CollectPeer[3] = snmp_peer_addr & 0xFF;
  985. X      for (j = 0; j != n_collectors; ++j) {
  986. X     ctip = &CTi[j];
  987. X     if (qcmp((unsigned char far *)ctip->LastCollectPeer,
  988. X        (unsigned char far *)CollectPeer, PEER_ADDR_LEN) == 0);
  989. X           break;
  990. X     }
  991. X      if (j == n_collectors) {  /* New collector */
  992. X     ctip = &CTi[n_collectors++];
  993. X     bcopy((unsigned char far *)CollectPeer,
  994. X        (unsigned char far *)ctip->LastCollectPeer, PEER_ADDR_LEN);
  995. X     }
  996. X      ctip->PrevCollectTime = ctip->LastCollectTime;
  997. X      ctip->LastCollectTime = LastCollectTime = s_uptime;
  998. X
  999. X      GarbageCollectTime = LastCollectTime < InactivityTimeout ? 0
  1000. X     : LastCollectTime-InactivityTimeout;  /* Must be >= 0 */
  1001. X      for (j = 0; j != n_collectors; ++j) {
  1002. X     ctip = &CTi[j];
  1003. X     if (ctip->PrevCollectTime < GarbageCollectTime)
  1004. X        GarbageCollectTime = ctip->PrevCollectTime;
  1005. X     }
  1006. X
  1007. X      sprintf(msg,"Collection by %d.%d.%d.%d",
  1008. X     CollectPeer[0],CollectPeer[1],CollectPeer[2],CollectPeer[3]);
  1009. X      display_msg(1,msg);
  1010. X#ifdef GC_TEST
  1011. X      printf("uptime=%lu, GCtime=%lu\n",
  1012. X     LastCollectTime,GarbageCollectTime);
  1013. X#endif
  1014. X      }
  1015. X   return TRUE;
  1016. X   }
  1017. X
  1018. Xint writeStatsReset(int doSet, u_char *var_val,
  1019. X   u_char var_val_type, int var_val_len, u_char far *statP)
  1020. X{
  1021. X   int bigsize = 1000;
  1022. X   unsigned char j;
  1023. X   long intval = 0;
  1024. X   if (!int_OK(var_val_type)) return FALSE;
  1025. X   asn_parse_int(var_val, &bigsize, &var_val_type, &intval, sizeof(intval));
  1026. X   if (doSet) zero_stats();
  1027. X   return TRUE;
  1028. X   }
  1029. X
  1030. Xu_char far *    /* Rule+Action Info table */
  1031. Xvar_rinfo(vp, name, length, exact, var_len, write_method)
  1032. X    register struct variable *vp;   /* IN - pointer to variable entry that points here */
  1033. X    register oid    *name;        /* IN/OUT - input name requested, output name found */
  1034. X    register int    *length;    /* IN/OUT - length of input and output oid's */
  1035. X    int            exact;        /* IN - TRUE if an exact match was requested. */
  1036. X    int            *var_len;   /* OUT - length of variable or 0 if function returned. */
  1037. X    int            (**write_method)(); /* OUT - 1 if function, 0 if char pointer. */
  1038. X{
  1039. X   unsigned char collect_rq, collect_ix, tblsz;
  1040. X   oid newname[MAX_NAME_LEN];
  1041. X   unsigned int x;
  1042. X   struct flow far *t;
  1043. X#ifdef TESTING
  1044. X   unsigned char j;
  1045. X   int cmp;
  1046. X#endif
  1047. X
  1048. X   collect_rq =(unsigned int)name[7] == 5;  /* 5 = collector, 7 = rule set */
  1049. X   x = (unsigned int)name[10];
  1050. X   tblsz = collect_rq ? n_collectors : MXNRTBLS;
  1051. X#ifdef TESTING
  1052. X   scpos(0,24);
  1053. X   printf("\nvar_rinfo(): exact=%d, collect=%d, x=%d, tblsz=%d, magic=%d\n   name=",
  1054. X      collect_rq,exact,x,tblsz,vp->magic);
  1055. X   for (j = 0; j != *length; ++j) printf(".%d",name[j]);
  1056. X   printf("\n");
  1057. X#endif
  1058. X   bcopy((char far *)vp->name, (char far *)newname, 10*sizeof(oid));
  1059. X
  1060. X   if (exact) {
  1061. X      if (x > tblsz) return NULL;
  1062. X      newname[10] = (oid)x;
  1063. X      if (compare(name,*length, newname,(int)vp->namelen) != 0) return NULL;
  1064. X      }
  1065. X   else {
  1066. X      if (compare(name,10, newname,10) != 0) x = 0;
  1067. X      for (++x;  x <= tblsz;  ++x) {
  1068. X     newname[10] = (oid)x;
  1069. X#ifdef TESTING
  1070. X     cmp = compare(name, *length, newname, (int)vp->namelen);
  1071. X     printf("x=%d, cmp=%d ", x,cmp);
  1072. X     for (j = 0; j != (int)vp->namelen; ++j) printf(".%d",newname[j]);
  1073. X     printf("\n");
  1074. X     if (cmp < 0) break;
  1075. X#else
  1076. X     if (compare(name, *length, newname, (int)vp->namelen) < 0) break;
  1077. X#endif
  1078. X     }
  1079. X      if (x > tblsz) return NULL;
  1080. X      }
  1081. X
  1082. X   bcopy((char far *)newname, (char far *)name, (int)vp->namelen * sizeof(oid));
  1083. X   *length = (int)vp->namelen;
  1084. X
  1085. X   if (!collect_rq) info_table_index = x;
  1086. X   *var_len = sizeof(long);
  1087. X   *write_method = 0;
  1088. X   switch (vp->magic) {
  1089. X   case RIINDEX:
  1090. X   case CIINDEX:
  1091. X      long_return = (long)x;
  1092. X      return (u_char *)&long_return;
  1093. X   case RIRULESIZE:
  1094. X      *write_method = (int (*)())writeRuleSize;
  1095. X      *var_len = sizeof(unsigned int);
  1096. X      return (u_char far *)&rt_size[x-1];
  1097. X   case RIACTIONSIZE:
  1098. X      *write_method = (int (*)())writeActionSize;
  1099. X      *var_len = sizeof(unsigned int);
  1100. X      return (u_char far *)&at_size[x-1];
  1101. X
  1102. X   case CIPEERADDR:
  1103. X      *var_len = PEER_ADDR_LEN;
  1104. X      return (u_char far *)CTi[x-1].LastCollectPeer;
  1105. X   case CILASTTIME:
  1106. X      return (u_char far *)&CTi[x-1].LastCollectTime;
  1107. X   case CIPREVTIME:
  1108. X      return (u_char far *)&CTi[x-1].PrevCollectTime;
  1109. X
  1110. X   default:
  1111. X      ERROR("");
  1112. X      }
  1113. X   return NULL;
  1114. X   }
  1115. X
  1116. Xunsigned char *putshort(unsigned char *d, unsigned int n)
  1117. X{
  1118. X   *d++ = (n >> 8) & 0xFF;
  1119. X   *d++ = n & 0xFF;
  1120. X   return d;
  1121. X   }
  1122. X
  1123. Xunsigned char *putlong(unsigned char *d, unsigned long n)
  1124. X{
  1125. X   *d++ = (n >> 24) & 0xFF;
  1126. X   *d++ = (n >> 16) & 0xFF;
  1127. X   *d++ = (n >> 8) & 0xFF;
  1128. X   *d++ = n & 0xFF;
  1129. X   return d;
  1130. X   }
  1131. X
  1132. Xu_char far *    /* Flow table */
  1133. Xvar_ft(vp, name, length, exact, var_len, write_method)
  1134. X    register struct variable *vp;   /* IN - pointer to variable entry that points here */
  1135. X    register oid    *name;        /* IN/OUT - input name requested, output name found */
  1136. X    register int    *length;    /* IN/OUT - length of input and output oid's */
  1137. X    int            exact;        /* IN - TRUE if an exact match was requested. */
  1138. X    int            *var_len;   /* OUT - length of variable or 0 if function returned. */
  1139. X    int            (**write_method)(); /* OUT - 1 if function, 0 if char pointer. */
  1140. X{
  1141. X   oid newname[MAX_NAME_LEN];
  1142. X   unsigned int x;
  1143. X   struct flow far *t;
  1144. X
  1145. X   bcopy((char far *)vp->name, (char far *)newname, (int)vp->namelen * sizeof(oid));
  1146. X
  1147. X   if (exact) {
  1148. X      newname[10] = name[10];
  1149. X      x = (unsigned int)newname[10];
  1150. X      if (compare(name,*length, newname,(int)vp->namelen) != 0  /* No match */
  1151. X     || (t = find_flow(x)) == NULL)  /* Doesn't exist */
  1152. X     return NULL;
  1153. X      }
  1154. X   else {
  1155. X      x = compare(name,10, newname,10) != 0  /* Not in this ptTable column */
  1156. X     ? 0  /* Have to search whole table */
  1157. X     : (unsigned int)name[10];  /* Only search from specified row */
  1158. X      for (++x;  x <= mxflowsp1;  ++x) {
  1159. X     if ((t = find_flow(x)) == NULL)  /* Ignore deallocated flows */
  1160. X        continue;
  1161. X     newname[10] = (oid)x;
  1162. X     if (compare(name, *length, newname, (int)vp->namelen) < 0) break;
  1163. X     }
  1164. X      if (x > mxflowsp1) return NULL;
  1165. X      }
  1166. X
  1167. X   bcopy((char far *)newname, (char far *)name, (int)vp->namelen * sizeof(oid));
  1168. X   *length = (int)vp->namelen;
  1169. X
  1170. X   *write_method = 0;
  1171. X   *var_len = sizeof(long);
  1172. X   switch (vp->magic) {
  1173. X   case FTFLOWINDEX:
  1174. X      long_return = (long)x;
  1175. X      return (u_char *)&long_return;
  1176. X   case FTFLOWSTATUS:
  1177. X      long_return = find_flow(x) != NULL;
  1178. X      return (u_char far *)&long_return;
  1179. X   case FTLOWINTERFACE:
  1180. X   case FTHIINTERFACE:
  1181. X   case FTLOWADJACENTTYPE:
  1182. X   case FTHIADJACENTTYPE:
  1183. X      long_return = 1;
  1184. X      return (u_char far *)&long_return;
  1185. X   case FTLOWADJACENTADDRESS:
  1186. X      *var_len = MAC_ADDR_LEN;
  1187. X      return (u_char far *)&t->Low.AdjAddress;
  1188. X   case FTLOWADJACENTMASK:
  1189. X      *var_len = MAC_ADDR_LEN;
  1190. X      return (u_char far *)&t->Low.AdjMask;
  1191. X   case FTLOWPEERTYPE:
  1192. X   case FTHIPEERTYPE:
  1193. X      *var_len = sizeof(unsigned char);
  1194. X      return (u_char far *)&t->PeerAddrType;
  1195. X   case FTLOWPEERTYPEMASK:
  1196. X   case FTHIPEERTYPEMASK:
  1197. X      *var_len = sizeof(unsigned char);
  1198. X      return (u_char far *)&t->PeerTypeMask;
  1199. X   case FTLOWPEERADDRESS:
  1200. X      *var_len = PEER_ADDR_LEN;
  1201. X      return (u_char far *)&t->Low.PeerAddress;
  1202. X   case FTLOWPEERMASK:
  1203. X      *var_len = PEER_ADDR_LEN;
  1204. X      return (u_char far *)&t->Low.PeerMask;
  1205. X   case FTLOWDETAILTYPE:
  1206. X   case FTHIDETAILTYPE:
  1207. X      *var_len = sizeof(unsigned char);
  1208. X      return (u_char far *)&t->DetailAddrType;
  1209. X   case FTLOWDETAILTYPEMASK:
  1210. X   case FTHIDETAILTYPEMASK:
  1211. X      *var_len = sizeof(unsigned char);
  1212. X      return (u_char far *)&t->DetailTypeMask;
  1213. X   case FTLOWDETAILADDRESS:
  1214. X      *var_len = DETAIL_ADDR_LEN;
  1215. X      return (u_char far *)&t->Low.DetailAddress;
  1216. X   case FTLOWDETAILMASK:
  1217. X      *var_len = DETAIL_ADDR_LEN;
  1218. X      return (u_char far *)&t->Low.DetailMask;
  1219. X   case FTHIADJACENTADDRESS:
  1220. X      *var_len = MAC_ADDR_LEN;
  1221. X      return (u_char far *)&t->High.AdjAddress;
  1222. X   case FTHIADJACENTMASK:
  1223. X      *var_len = MAC_ADDR_LEN;
  1224. X      return (u_char far *)&t->High.AdjMask;
  1225. X   case FTHIPEERADDRESS:
  1226. X      *var_len = PEER_ADDR_LEN;
  1227. X      return (u_char far *)&t->High.PeerAddress;
  1228. X   case FTHIPEERMASK:
  1229. X      *var_len = PEER_ADDR_LEN;
  1230. X      return (u_char far *)&t->High.PeerMask;
  1231. X   case FTHIDETAILADDRESS:
  1232. X      *var_len = DETAIL_ADDR_LEN;
  1233. X      return (u_char far *)&t->High.DetailAddress;
  1234. X   case FTHIDETAILMASK:
  1235. X      *var_len = DETAIL_ADDR_LEN;
  1236. X      return (u_char far *)&t->High.DetailMask;
  1237. X   case FTRULESET:
  1238. X      *var_len = sizeof(unsigned char);
  1239. X      return (u_char far *)&t->FlowRuleSet;
  1240. X   case FTFLOWTYPE:
  1241. X      *var_len = sizeof(unsigned char);
  1242. X      return (u_char far *)&t->FlowType;
  1243. X   case FTUPOCTETS:
  1244. X      return (u_char far *)&t->UpOctets;
  1245. X   case FTUPPDUS:
  1246. X      return (u_char far *)&t->UpPDUs;
  1247. X   case FTDOWNOCTETS:
  1248. X      return (u_char far *)&t->DownOctets;
  1249. X   case FTDOWNPDUS:
  1250. X      return (u_char far *)&t->DownPDUs;
  1251. X   case FTFIRSTTIME:
  1252. X      return (u_char far *)&t->FirstTime;
  1253. X   case FTLASTTIME:
  1254. X      return (u_char far *)&t->LastTime;
  1255. X
  1256. X   default:
  1257. X      ERROR("");
  1258. X      }
  1259. X   return NULL;
  1260. X   }
  1261. X
  1262. Xu_char far *    /* Creation and activity tables */
  1263. Xvar_flow_index(vp, name, length, exact, var_len, write_method)
  1264. X    register struct variable *vp;   /* IN - pointer to variable entry that points here */
  1265. X    register oid    *name;        /* IN/OUT - input name requested, output name found */
  1266. X    register int    *length;    /* IN/OUT - length of input and output oid's */
  1267. X    int            exact;        /* IN - TRUE if an exact match was requested. */
  1268. X    int            *var_len;   /* OUT - length of variable or 0 if function returned. */
  1269. X    int            (**write_method)(); /* OUT - 1 if function, 0 if char pointer. */
  1270. X{
  1271. X   unsigned char create;
  1272. X   unsigned long t_time;  /* 'Target' time */
  1273. X   unsigned int x;
  1274. X   oid newname[MAX_NAME_LEN];
  1275. X   struct flow far *t;
  1276. X#ifdef TESTING
  1277. X   unsigned char j;
  1278. X#endif
  1279. X
  1280. X   create = name[7] == 2;  /* acct.2.2.1 = CreateTime */
  1281. X   t_time = (unsigned long)name[10];
  1282. X   x = (unsigned int)name[11];
  1283. X   bcopy((char far *)vp->name, (char far *)newname, (int)vp->namelen * sizeof(oid));
  1284. X#ifdef TESTING
  1285. X   scpos(0,24);
  1286. X   printf("flow_index(): exact=%d, create=%d, t=%lu, x=%d\n      name=",
  1287. X      exact,create,t_time,x);
  1288. X   for (j = 0; j != *length; ++j) printf(".%d",name[j]);
  1289. X   printf("\n");
  1290. X#endif
  1291. X
  1292. X   if (exact) {
  1293. X      if (compare(name, *length-2, newname, (int)vp->namelen-2) != 0)
  1294. X     return NULL;
  1295. X      for ( ;  x <= mxflowsp1;  ++x) {
  1296. X     if ((t = find_flow(x)) == NULL)  /* Ignore deallocated flows */
  1297. X        continue;
  1298. X     if (create) {
  1299. X        if (t->FirstTime > t_time)  /* Created after target time */
  1300. X           break;
  1301. X        }
  1302. X     else if (t->LastTime > t_time)  /* Active after target time */
  1303. X        break;
  1304. X     }
  1305. X      newname[10] = t_time;  newname[11] = (oid)x;
  1306. X      }
  1307. X   else {  /* Does oid match up to indexes? */
  1308. X      if (compare(name,10, newname,10) != 0) {    /* No - find first entry */
  1309. X     t_time = 1L;  /* Have to search whole flow table */
  1310. X     x = 1;  /* Flow 1 is a dummy - never used by meter */
  1311. X     }
  1312. X      for (++x;  x <= mxflowsp1;  ++x) {
  1313. X     if ((t = find_flow(x)) == NULL)  /* Ignore deallocated flows */
  1314. X        continue;
  1315. X     if (create) {
  1316. X        if (t->FirstTime <= t_time)  /* Created up to target time */
  1317. X           continue;
  1318. X        }
  1319. X     else if (t->LastTime <= t_time)  /* Active up to target time */
  1320. X        continue;
  1321. X     newname[10] = t_time;  newname[11] = (oid)x;
  1322. X     if (compare(name, *length, newname, (int)vp->namelen) < 0) break;
  1323. X     }
  1324. X      }
  1325. X   if (x > mxflowsp1) return NULL;  /* No more flows to search */
  1326. X      /* Only allow getnext to go through flow table once! */
  1327. X
  1328. X   bcopy((char far *)newname, (char far *)name, (int)vp->namelen * sizeof(oid));
  1329. X   *length = (int)vp->namelen;
  1330. X
  1331. X   *write_method = 0;
  1332. X   *var_len = sizeof(long);
  1333. X   switch (vp->magic) {
  1334. X   case FTCRFIRSTTIME:
  1335. X      return (u_char far *)&t->FirstTime;
  1336. X   case FTCRFLOWINDEX:
  1337. X      long_return = (long)x;
  1338. X      return (u_char far *)&long_return;
  1339. X   case FTACFIRSTTIME:
  1340. X      return (u_char far *)&t->LastTime;
  1341. X   case FTACFLOWINDEX:
  1342. X      long_return = (long)x;
  1343. X      return (u_char far *)&long_return;
  1344. X      }
  1345. X   return NULL;
  1346. X   }
  1347. X
  1348. Xu_char far *    /* Activity Column Table */
  1349. Xvar_col_tbl(vp, name, length, exact, var_len, write_method)
  1350. X    register struct variable *vp;   /* IN - pointer to variable entry that points here */
  1351. X    register oid    *name;        /* IN/OUT - input name requested, output name found */
  1352. X    register int    *length;    /* IN/OUT - length of input and output oid's */
  1353. X    int            exact;        /* IN - TRUE if an exact match was requested. */
  1354. X    int            *var_len;   /* OUT - length of variable or 0 if function returned. */
  1355. X    int            (**write_method)(); /* OUT - 1 if function, 0 if char pointer. */
  1356. X{
  1357. X   unsigned long t_time;  /* 'Target' time */
  1358. X   unsigned int x,n;
  1359. X   unsigned char a;
  1360. X   oid newname[MAX_NAME_LEN];
  1361. X   unsigned char *ucp;
  1362. X   struct flow far *t;
  1363. X#ifdef TESTING
  1364. X   unsigned char j;
  1365. X#endif
  1366. X
  1367. X   a = (unsigned char)name[10];
  1368. X   t_time = (unsigned long)name[11];
  1369. X   x = (unsigned int)name[12];
  1370. X#ifdef TESTING
  1371. X   scpos(0,24);
  1372. X   printf("col_tbl(): exct=%d, a=%d, t=%lu, x=%d\n      name=",
  1373. X      exact,a,t_time,x);
  1374. X   for (j = 0; j != *length; ++j) printf(".%d",name[j]);
  1375. X   printf("\n");
  1376. X#endif
  1377. X   bcopy((char far *)vp->name, (char far *)newname, 10*sizeof(oid));
  1378. X   if (exact) {
  1379. X      if (compare(name, 10, newname, 10) != 0) return NULL;
  1380. X      if (a < FTFLOWINDEX || a > FTLASTTIME) return NULL;
  1381. X      newname[10] = (oid)a;
  1382. X      for ( ;  x <= mxflowsp1;  ++x) {
  1383. X     if ((t = find_flow(x)) == NULL)  /* Ignore deallocated flows */
  1384. X        continue;
  1385. X     if (t->LastTime > t_time)  /* Active after target time */
  1386. X        break;
  1387. X     }
  1388. X      newname[11] = (oid)t_time;  newname[12] = (oid)x;
  1389. X      }
  1390. X   else {  /* Does oid match up to indexes? */
  1391. X      if (compare(name,10, newname,10) != 0) {    /* No - find first entry */
  1392. X     a = FTLOWPEERTYPE;
  1393. X     t_time = 1L;  /* Have to search whole flow table */
  1394. X     x = 1;  /* Flow 1 is a dummy - never used by meter */
  1395. X     }
  1396. X      else if (a > FTLASTTIME) return NULL;
  1397. X      newname[10] = (oid)a;
  1398. X      for (++x;  x <= mxflowsp1;  ++x) {
  1399. X     if ((t = find_flow(x)) == NULL)  /* Ignore deallocated flows */
  1400. X        continue;
  1401. X     if (t->LastTime <= t_time)  /* Active up to target time */
  1402. X        continue;
  1403. X     newname[11] = (oid)t_time;  newname[12] = (oid)x;
  1404. X     if (compare(name, *length, newname, (int)vp->namelen) < 0) break;
  1405. X     }
  1406. X      }
  1407. X   if (x > mxflowsp1) return NULL;  /* No more flows to search */
  1408. X      /* Only allow getnext to go through flow table once! */
  1409. X
  1410. X   bcopy((char far *)newname, (char far *)name, (int)vp->namelen * sizeof(oid));
  1411. X   *length = (int)vp->namelen;
  1412. X
  1413. X   *write_method = 0;
  1414. X   *var_len = sizeof(long);
  1415. X   switch (vp->magic) {
  1416. X   case FTCOLATTRIB:
  1417. X      long_return = (long)a;
  1418. X      return (u_char far *)&long_return;
  1419. X   case FTCOLTIME:
  1420. X      return (u_char far *)&t->LastTime;
  1421. X   case FTCOLINDEX:
  1422. X      long_return = (long)x;
  1423. X      return (u_char far *)&long_return;
  1424. X   case FTCOLBLOB:
  1425. X      for (n = 0, ucp = column_blob;  /* Build the flow blob */
  1426. X        n <= FLOWBLOBSZ*(2+RULE_ADDR_LEN);  ++x) {
  1427. X     for ( ; x <= mxflowsp1;  ++x) {  /* Find next active flow */
  1428. X        if ((t = find_flow(x)) != NULL && t->LastTime > t_time) {
  1429. X           ucp = putshort(ucp,netshort(x));
  1430. X           switch (a) {  /* Build the flow blob */
  1431. X           case FTFLOWINDEX:
  1432. X          ucp = putshort(ucp,netshort(x));
  1433. X          break;
  1434. X           case FTFLOWSTATUS:
  1435. X           case FTLOWINTERFACE:
  1436. X           case FTHIINTERFACE:
  1437. X           case FTLOWADJACENTTYPE:
  1438. X           case FTHIADJACENTTYPE:
  1439. X          *ucp++ = 1;
  1440. X          break;
  1441. X           case FTLOWADJACENTADDRESS:
  1442. X          bcopy(t->Low.AdjAddress,
  1443. X             (unsigned char far *)ucp, MAC_ADDR_LEN);
  1444. X          ucp += MAC_ADDR_LEN;
  1445. X          break;
  1446. X           case FTLOWADJACENTMASK:
  1447. X          bcopy(t->Low.AdjMask,
  1448. X             (unsigned char far *)ucp, MAC_ADDR_LEN);
  1449. X          ucp += MAC_ADDR_LEN;
  1450. X          break;
  1451. X           case FTLOWPEERTYPE:
  1452. X           case FTHIPEERTYPE:
  1453. X          *ucp++ = t->PeerAddrType;
  1454. X          break;
  1455. X           case FTLOWPEERTYPEMASK:
  1456. X           case FTHIPEERTYPEMASK:
  1457. X          *ucp++ = t->PeerTypeMask;
  1458. X          break;
  1459. X           case FTLOWPEERADDRESS:
  1460. X          bcopy(t->Low.PeerAddress,
  1461. X             (unsigned char far *)ucp, PEER_ADDR_LEN);
  1462. X          ucp += PEER_ADDR_LEN;
  1463. X          break;
  1464. X           case FTLOWPEERMASK:
  1465. X          bcopy(t->Low.PeerMask,
  1466. X             (unsigned char far *)ucp, PEER_ADDR_LEN);
  1467. X          ucp += PEER_ADDR_LEN;
  1468. X          break;
  1469. X           case FTLOWDETAILTYPE:
  1470. X           case FTHIDETAILTYPE:
  1471. X          *ucp++ = t->DetailAddrType;
  1472. X          break;
  1473. X           case FTLOWDETAILTYPEMASK:
  1474. X           case FTHIDETAILTYPEMASK:
  1475. X          *ucp++ = t->DetailTypeMask;
  1476. X          break;
  1477. X           case FTLOWDETAILADDRESS:
  1478. X          bcopy(t->Low.DetailAddress,
  1479. X             (unsigned char far *)ucp, DETAIL_ADDR_LEN);
  1480. X          ucp += DETAIL_ADDR_LEN;
  1481. X          break;
  1482. X           case FTLOWDETAILMASK:
  1483. X          bcopy(t->Low.DetailMask,
  1484. X             (unsigned char far *)ucp, DETAIL_ADDR_LEN);
  1485. X          ucp += DETAIL_ADDR_LEN;
  1486. X          break;
  1487. X           case FTHIADJACENTADDRESS:
  1488. X          bcopy(t->High.AdjAddress,
  1489. X             (unsigned char far *)ucp, MAC_ADDR_LEN);
  1490. X          ucp += MAC_ADDR_LEN;
  1491. X          break;
  1492. X           case FTHIADJACENTMASK:
  1493. X          bcopy(t->High.AdjMask,
  1494. X             (unsigned char far *)ucp, MAC_ADDR_LEN);
  1495. X          ucp += MAC_ADDR_LEN;
  1496. X          break;
  1497. X           case FTHIPEERADDRESS:
  1498. X          bcopy(t->High.PeerAddress,
  1499. X             (unsigned char far *)ucp, PEER_ADDR_LEN);
  1500. X          ucp += PEER_ADDR_LEN;
  1501. X          break;
  1502. X           case FTHIPEERMASK:
  1503. X          bcopy(t->High.PeerMask,
  1504. X             (unsigned char far *)ucp, PEER_ADDR_LEN);
  1505. X          ucp += PEER_ADDR_LEN;
  1506. X          break;
  1507. X           case FTHIDETAILADDRESS:
  1508. X          bcopy(t->High.DetailAddress,
  1509. X             (unsigned char far *)ucp, DETAIL_ADDR_LEN);
  1510. X          ucp += DETAIL_ADDR_LEN;
  1511. X          break;
  1512. X           case FTHIDETAILMASK:
  1513. X          bcopy(t->High.DetailMask,
  1514. X             (unsigned char far *)ucp, DETAIL_ADDR_LEN);
  1515. X          ucp += DETAIL_ADDR_LEN;
  1516. X          break;
  1517. X           case FTRULESET:
  1518. X          *ucp++ = t->FlowRuleSet;
  1519. X          break;
  1520. X           case FTFLOWTYPE:
  1521. X          *ucp++ = t->FlowType;
  1522. X          break;
  1523. X           case FTUPOCTETS:
  1524. X          ucp = putlong(ucp,netlong(t->UpOctets));
  1525. X          break;
  1526. X           case FTUPPDUS:
  1527. X          ucp = putlong(ucp,netlong(t->UpPDUs));
  1528. X          break;
  1529. X           case FTDOWNOCTETS:
  1530. X          ucp = putlong(ucp,netlong(t->DownOctets));
  1531. X          break;
  1532. X           case FTDOWNPDUS:
  1533. X          ucp = putlong(ucp,netlong(t->DownPDUs));
  1534. X          break;
  1535. X           case FTFIRSTTIME:
  1536. X          ucp = putlong(ucp,netlong(t->FirstTime));
  1537. X          break;
  1538. X           case FTLASTTIME:
  1539. X          ucp = putlong(ucp,netlong(t->LastTime));
  1540. X          break;
  1541. X          }
  1542. X           n += 2+attribs[a].len;
  1543. X           break;
  1544. X           }
  1545. X        }
  1546. X     if (x > mxflowsp1) {
  1547. X        if (!exact) name[12] = mxflowsp1;
  1548. X           /* Return index of last possible flow */
  1549. X        putshort(ucp,0);  /* Mark end of column */
  1550. X        *var_len = n+2;
  1551. X        return (u_char far *)&column_blob;
  1552. X        }
  1553. X     }
  1554. X      if (!exact) name[12] = (oid)x;
  1555. X     /* Return index of last flow in blob */
  1556. X      putshort(ucp,1);  /* Mark end of this blob (more to come) */
  1557. X      *var_len = n+2;
  1558. X      return (u_char far *)&column_blob;
  1559. X      }
  1560. X   return NULL;
  1561. X   }
  1562. X
  1563. Xu_char far *    /* Rule + action tables */
  1564. Xvar_rt(vp, name, length, exact, var_len, write_method)
  1565. X    register struct variable *vp;   /* IN - pointer to variable entry that points here */
  1566. X    register oid    *name;        /* IN/OUT - input name requested, output name found */
  1567. X    register int    *length;    /* IN/OUT - length of input and output oid's */
  1568. X    int            exact;        /* IN - TRUE if an exact match was requested. */
  1569. X    int            *var_len;   /* OUT - length of variable or 0 if function returned. */
  1570. X    int            (**write_method)(); /* OUT - 1 if function, 0 if char pointer. */
  1571. X{
  1572. X   unsigned char rule_rq, rule_set;
  1573. X   unsigned int x, sz;
  1574. X   oid newname[MAX_NAME_LEN];
  1575. X   struct rule far *r, far *rt;
  1576. X   struct flow far *a, far *at;
  1577. X#ifdef TESTING
  1578. X   unsigned char j;
  1579. X   int cmp;
  1580. X#endif
  1581. X
  1582. X   rule_rq =  /* acct.3 = rule table, acct.4 = action table */
  1583. X      (unsigned int)name[6] == 3;
  1584. X#ifdef TESTING
  1585. X   rule_set = name[10];
  1586. X   x = (unsigned int)name[11];
  1587. X   scpos(0,24);
  1588. X   printf("var_rt(): exact=%d, rule=%d, set=%d, x=%d\n   name=",
  1589. X      exact,rule_rq,rule_set,x);
  1590. X   for (j = 0; j != *length; ++j) printf(".%d",name[j]);
  1591. X   printf("\n");
  1592. X#endif
  1593. X   bcopy((char far *)vp->name, (char far *)newname, 10*sizeof(oid));
  1594. X   if (exact) {
  1595. X      if ((rule_set = name[10]) > MXNRTBLS) return NULL;
  1596. X      x = (unsigned int)name[11];
  1597. X      if (rule_rq) {
  1598. X     if ((rt = rule_table[rule_set-1]) == NULL) return NULL;
  1599. X     if (x > (sz = rt_size[rule_set-1])) return NULL;
  1600. X     }
  1601. X     else {
  1602. X     if ((at = action_table[rule_set-1]) == NULL) return NULL;
  1603. X     if (x > (sz = at_size[rule_set-1])) return NULL;
  1604. X     }
  1605. X      newname[10] = (oid)rule_set;  newname[11] = (oid)x;
  1606. X      if (compare(name,*length, newname,(int)vp->namelen) != 0) return NULL;
  1607. X      if (rule_rq) {
  1608. X     if ((r = &rt[x-1]) == NULL) return NULL;
  1609. X     }
  1610. X      else {
  1611. X     if ((a = &at[x-1]) == NULL) return NULL;
  1612. X     }
  1613. X      }
  1614. X   else {
  1615. X      if (compare(name,10, newname,10) != 0) {  /* Not in this table column */
  1616. X     rule_set = 1;  x = 0;  /* Have to search whole 2-D table */
  1617. X     }
  1618. X      else {
  1619. X     rule_set = name[10];  x = (unsigned int)name[11];
  1620. X     }
  1621. X      for ( ; ; ++rule_set, x = 0) {
  1622. X     if (rule_set > MXNRTBLS) return NULL;
  1623. X     if (rule_rq) {
  1624. X        if ((rt = rule_table[rule_set-1]) == NULL) continue;
  1625. X        if (x >= (sz = rt_size[rule_set-1])) continue;
  1626. X        }
  1627. X     else {
  1628. X        if ((at = action_table[rule_set-1]) == NULL) continue;
  1629. X        if (x >= (sz = at_size[rule_set-1])) continue;
  1630. X        }
  1631. X     newname[10] = (oid)rule_set;
  1632. X     for (++x; x <= sz; ++x) {
  1633. X        if (rule_rq) {
  1634. X           if ((r = &rt[x-1]) == NULL) continue;
  1635. X           }
  1636. X        else {
  1637. X           if ((a = &at[x-1]) == NULL) continue;
  1638. X           }
  1639. X        newname[11] = (oid)x;
  1640. X#ifdef TESTING
  1641. X        cmp = compare(name, *length, newname, (int)vp->namelen);
  1642. X        printf("x=%d, cmp=%d ", x,cmp);
  1643. X        for (j = 0; j != (int)vp->namelen; ++j) printf(".%d",newname[j]);
  1644. X        printf("\n");
  1645. X        if (cmp < 0) break;
  1646. X#else
  1647. X        if (compare(name, *length, newname, (int)vp->namelen) < 0) break;
  1648. X#endif
  1649. X        }
  1650. X     if (x <= sz) break;  /* Found the next one! */
  1651. X     }
  1652. X      }
  1653. X
  1654. X   bcopy((char far *)newname, (char far *)name, (int)vp->namelen * sizeof(oid));
  1655. X   *length = (int)vp->namelen;
  1656. X
  1657. X#ifdef TESTING
  1658. X#ifdef AU_MSDOS
  1659. Xif (rule_rq) printf("   rt[%d], address=%Fp, x=%d\n", rule_set, r, x);
  1660. Xelse printf("   at[%d], address=%Fp, x=%d\n", rule_set, a, x);
  1661. X#else
  1662. Xif (rule_rq) printf("   rt[%d], address=%lu, x=%d\n", rule_set, r, x);
  1663. Xelse printf("   at[%d], address=%lu, x=%d\n", rule_set, a, x);
  1664. Xfflush(stdout);
  1665. X#endif
  1666. X#endif
  1667. X   *write_method = 0;
  1668. X   *var_len = sizeof(long);
  1669. X   switch (vp->magic) {
  1670. X   case RTRULESET:
  1671. X   case ATACTIONSET:
  1672. X      long_return = (long)rule_set;
  1673. X      return (u_char far *)&long_return;
  1674. X   case RTRULEINDEX:
  1675. X   case ATACTIONINDEX:
  1676. X      long_return = (long)x;
  1677. X      return (u_char far *)&long_return;
  1678. X
  1679. X   case RTSELECTOR:
  1680. X      *write_method = (int (*)())writechar;
  1681. X      *var_len = sizeof(unsigned char);
  1682. X      return (u_char far *)&r->RuleSelector;
  1683. X   case RTRULEMASK:
  1684. X      *write_method = (int (*)())writeAddress;
  1685. X      *var_len = RULE_ADDR_LEN;
  1686. X      return (u_char far *)&r->RuleMask;
  1687. X   case RTMATCHVALUE:
  1688. X      *write_method = (int (*)())writeAddress;
  1689. X      *var_len = RULE_ADDR_LEN;
  1690. X      return (u_char far *)&r->RuleMatchedValue;
  1691. X   case RTRULEACTION:
  1692. X      *write_method = (int (*)())writechar;
  1693. X      *var_len = sizeof(unsigned char);
  1694. X      return (u_char far *)&r->RuleAction;
  1695. X   case RTJUMPINDEX:
  1696. X      *write_method = (int (*)())writeint;
  1697. X      *var_len = sizeof(unsigned int);
  1698. X      return (u_char far *)&r->RuleJumpIndex;
  1699. X
  1700. X   case ATLOWINTERFACE:
  1701. X   case ATHIINTERFACE:
  1702. X      break;  /* Interface 1 is the only one! */
  1703. X
  1704. X   case ATLOWADJACENTTYPE:
  1705. X   case ATHIADJACENTTYPE:
  1706. X      break;  /* Ethernet is the only adjacent type! */
  1707. X   case ATLOWADJACENTADDRESS:
  1708. X      *write_method = (int (*)())writeAddress;
  1709. X      *var_len = MAC_ADDR_LEN;
  1710. X      return (u_char far *)&a->Low.AdjAddress;
  1711. X   case ATLOWADJACENTMASK:
  1712. X      *write_method = (int (*)())writeAddress;
  1713. X      *var_len = MAC_ADDR_LEN;
  1714. X      return (u_char far *)&a->Low.AdjMask;
  1715. X
  1716. X   case ATLOWPEERTYPE:
  1717. X   case ATHIPEERTYPE:
  1718. X      *write_method = (int (*)())writechar;
  1719. X      *var_len = sizeof(unsigned char);
  1720. X      return (u_char far *)&a->PeerAddrType;
  1721. X   case ATLOWPEERTYPEMASK:
  1722. X   case ATHIPEERTYPEMASK:
  1723. X      *write_method = (int (*)())writechar;
  1724. X      *var_len = sizeof(unsigned char);
  1725. X      return (u_char far *)&a->PeerTypeMask;
  1726. X   case ATLOWPEERADDRESS:
  1727. X      *write_method = (int (*)())writeAddress;
  1728. X      *var_len = PEER_ADDR_LEN;
  1729. X      return (u_char far *)&a->Low.PeerAddress;
  1730. X   case ATLOWPEERMASK:
  1731. X      *write_method = (int (*)())writeAddress;
  1732. X      *var_len = PEER_ADDR_LEN;
  1733. X      return (u_char far *)&a->Low.PeerMask;
  1734. X
  1735. X   case ATLOWDETAILTYPE:
  1736. X   case ATHIDETAILTYPE:
  1737. X      *write_method = (int (*)())writechar;
  1738. X      *var_len = sizeof(unsigned char);
  1739. X      return (u_char far *)&a->DetailAddrType;
  1740. X   case ATLOWDETAILTYPEMASK:
  1741. X   case ATHIDETAILTYPEMASK:
  1742. X      *write_method = (int (*)())writechar;
  1743. X      *var_len = sizeof(unsigned char);
  1744. X      return (u_char far *)&a->DetailTypeMask;
  1745. X   case ATLOWDETAILADDRESS:
  1746. X      *write_method = (int (*)())writeAddress;
  1747. X      *var_len = DETAIL_ADDR_LEN;
  1748. X      return (u_char far *)&a->Low.DetailAddress;
  1749. X   case ATLOWDETAILMASK:
  1750. X      *write_method = (int (*)())writeAddress;
  1751. X      *var_len = DETAIL_ADDR_LEN;
  1752. X      return (u_char far *)&a->Low.DetailMask;
  1753. X
  1754. X   case ATHIADJACENTADDRESS:
  1755. X      *write_method = (int (*)())writeAddress;
  1756. X      *var_len = MAC_ADDR_LEN;
  1757. X      return (u_char far *)&a->High.AdjAddress;
  1758. X   case ATHIADJACENTMASK:
  1759. X      *write_method = (int (*)())writeAddress;
  1760. X      *var_len = MAC_ADDR_LEN;
  1761. X      return (u_char far *)&a->High.AdjMask;
  1762. X
  1763. X   case ATHIPEERADDRESS:
  1764. X      *write_method = (int (*)())writeAddress;
  1765. X      *var_len = PEER_ADDR_LEN;
  1766. X      return (u_char far *)&a->High.PeerAddress;
  1767. X   case ATHIPEERMASK:
  1768. X      *write_method = (int (*)())writeAddress;
  1769. X      *var_len = PEER_ADDR_LEN;
  1770. X      return (u_char far *)&a->High.PeerMask;
  1771. X
  1772. X   case ATHIDETAILADDRESS:
  1773. X      *write_method = (int (*)())writeAddress;
  1774. X      *var_len = DETAIL_ADDR_LEN;
  1775. X      return (u_char far *)&a->High.DetailAddress;
  1776. X   case ATHIDETAILMASK:
  1777. X      *write_method = (int (*)())writeAddress;
  1778. X      *var_len = DETAIL_ADDR_LEN;
  1779. X      return (u_char far *)&a->High.DetailMask;
  1780. X
  1781. X   case ATPDUSCALE:
  1782. X   case ATOCTETSCALE:
  1783. X      break;  /* Not yet implemented */
  1784. X
  1785. X   default:
  1786. X      ERROR("");
  1787. X      }
  1788. X   return NULL;
  1789. X   }
  1790. END_OF_FILE
  1791.   if test 53127 -ne `wc -c <'netramet/src/meter/met_vars.c'`; then
  1792.     echo shar: \"'netramet/src/meter/met_vars.c'\" unpacked with wrong size!
  1793.   fi
  1794.   # end of 'netramet/src/meter/met_vars.c'
  1795. fi
  1796. if test -f 'netramet/src/snmplib/include/ausnmp.h' -a "${1}" != "-c" ; then 
  1797.   echo shar: Will not clobber existing file \"'netramet/src/snmplib/include/ausnmp.h'\"
  1798. else
  1799.   echo shar: Extracting \"'netramet/src/snmplib/include/ausnmp.h'\" \(531 characters\)
  1800.   sed "s/^X//" >'netramet/src/snmplib/include/ausnmp.h' <<'END_OF_FILE'
  1801. X/* 1000, Fri 4 Jun 93
  1802. X
  1803. X   Header file for AU_MSDOS implementation of CMU SNMP
  1804. X
  1805. X   Nevil Brownlee,  Computer Centre, University of Auckland */
  1806. X
  1807. X
  1808. X#ifdef AU_MSDOS
  1809. Xtypedef unsigned char u_char;
  1810. Xtypedef unsigned long u_long;
  1811. Xtypedef unsigned int u_short;
  1812. X
  1813. X#include <mem.h>
  1814. Xvoid qmove(unsigned char far *s, unsigned char far *d, unsigned int n);
  1815. X#define bcopy(s,d,n) qmove(s,d,n)
  1816. X
  1817. X#else  /* Not AU_MSDOS */
  1818. X
  1819. X#define far
  1820. X#define farfree free
  1821. X#define farmalloc malloc
  1822. X#include <sys/types.h>
  1823. X#include <malloc.h>
  1824. X#include <memory.h>
  1825. X
  1826. X#endif
  1827. END_OF_FILE
  1828.   if test 531 -ne `wc -c <'netramet/src/snmplib/include/ausnmp.h'`; then
  1829.     echo shar: \"'netramet/src/snmplib/include/ausnmp.h'\" unpacked with wrong size!
  1830.   fi
  1831.   # end of 'netramet/src/snmplib/include/ausnmp.h'
  1832. fi
  1833. echo shar: End of archive 6 \(of 25\).
  1834. cp /dev/null ark6isdone
  1835. MISSING=""
  1836. 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
  1837.     if test ! -f ark${I}isdone ; then
  1838.     MISSING="${MISSING} ${I}"
  1839.     fi
  1840. done
  1841. if test "${MISSING}" = "" ; then
  1842.     echo You have unpacked all 25 archives.
  1843.     rm -f ark[1-9]isdone ark[1-9][0-9]isdone
  1844. else
  1845.     echo You still must unpack the following archives:
  1846.     echo "        " ${MISSING}
  1847. fi
  1848. exit 0
  1849. exit 0 # Just in case...
  1850.