#!/bin/sh
# This is `snmp2.28' (part 28 of snmp2).
# Do not concatenate these parts, unpack them in order with `/bin/sh'.
# File `snmp2/snmptcl/htext2.c' is being continued...
#
touch -am 1231235999 $$.touch >/dev/null 2>&1
if test ! -f 1231235999 && test -f $$.touch; then
  shar_touch=touch
else
  shar_touch=:
  echo
  echo 'WARNING: not restoring timestamps.  Consider getting and'
  echo "installing GNU \`touch', distributed in GNU File Utilities..."
  echo
fi
rm -f 1231235999 $$.touch
#
if test ! -r _sharseq.tmp; then
  echo 'Please unpack part 1 first!'
  exit 1
fi
shar_sequence=`cat _sharseq.tmp`
if test "$shar_sequence" != 28; then
  echo "Please unpack part $shar_sequence next!"
  exit 1
fi
if test ! -f _sharnew.tmp; then
  echo 'x - still skipping snmp2/snmptcl/htext2.c'
else
  echo 'x - continuing file snmp2/snmptcl/htext2.c'
  sed 's/^X//' << 'SHAR_EOF' >> 'snmp2/snmptcl/htext2.c' &&
X	    newCommand[dest++] = c;
X	    break;
X	}
X	if (dest == HUGE_COMMAND_SIZE) {
X	    textPtr->interp->result = "Command block is too long";
X
X	    return (NULL);
X	}
X    }
X    textPtr->interp->result = "Premature end of TCL command block";
X    return (NULL);
}
X
X
static void
FreeLines (textPtr)
X    Hypertext *textPtr;
{
X    register int i;
X
X    for (i = 0; i < textPtr->numLines; i++) {
X	DestroyLine (textPtr->lineArr[i]);
X    }
X    if (textPtr->lineArr != NULL)
X	free ((char *)textPtr->lineArr);
X    textPtr->lineArr = NULL;
X    textPtr->arraySize = textPtr->numLines = 0;
}
X
X
static void
AdjustLinesAllocated (textPtr)
X    Hypertext *textPtr;
{
X    if (textPtr->arraySize > 0) {
X	Line **newPtr;
X
X	newPtr = (Line **) reallocate ((char *)textPtr->lineArr,
X				       textPtr->numLines * sizeof (Line *),
X				       textPtr->arraySize * sizeof (Line *));
X	textPtr->arraySize = textPtr->numLines;
X	textPtr->lineArr = newPtr;
X    }
}
X
static void
SetLineText (linePtr, text, size)
X    Line *linePtr;
X    char *text;
X    int size;
{
X    linePtr->textLength = size;
X    linePtr->text = (char *)malloc (size + 1);
X    strcpy (linePtr->text, text);
}
X
/* ARGSUSED */
static char *
FileVarProc (clientData, interp, name1, name2, flags)
X    ClientData clientData;   /* Information about widget. */
X    Tcl_Interp *interp;	     /* Interpreter containing variable. */
X    char *name1;	     /* Name of variable. */
X    char *name2;	     /* Second part of variable name. */
X    int flags;		     /* Information about what happened. */
{
X    Hypertext *textPtr = (Hypertext *) clientData;
X    Hypertext *lastTextPtr;
X
X    /* Check to see of this is the most recent trace */
X    lastTextPtr = (Hypertext *) Tcl_VarTraceInfo (interp, name1, flags,
X						  FileVarProc,
X						  (ClientData) NULL);
X    if (lastTextPtr != textPtr)
X	return (NULL);	     /* Ignore all but most current trace */
X
X    if (flags & TCL_TRACE_READS) {
X	if (strcmp (name1, "thisFile") == 0) {
X	    if (textPtr->fileName == NULL)
X		Tcl_SetVar (interp, name1, "", flags);
X	    else
X		Tcl_SetVar (interp, name1, textPtr->fileName, flags);
X	} else if (strcmp (name1, "thisLine") == 0) {
X	    char buf[80];
X
X	    sprintf (buf, "%d", textPtr->numLines);
X	    Tcl_SetVar (interp, name1, buf, flags);
X	} else if (strcmp (name1, "this") == 0) {
X	    Tcl_SetVar (interp, name1, Tk_PathName (textPtr->tkwin), flags);
X	} else {
X	    return ("Unknown variable");
X	}
X    }
X    return (NULL);
}
X
static void
CreateTraces (textPtr)
X    Hypertext *textPtr;
{
X    register Tcl_Interp *interp = textPtr->interp;
X    int flags = (TCL_GLOBAL_ONLY | TCL_TRACE_READS);
X
X    Tcl_TraceVar (interp, "this", flags, FileVarProc, (ClientData) textPtr);
X    Tcl_TraceVar (interp, "thisLine", flags, FileVarProc, (ClientData) textPtr);
X    Tcl_TraceVar (interp, "thisFile", flags, FileVarProc, (ClientData) textPtr);
X    /* Make the traced variables global to the widget */
X    Tcl_Eval (interp, "global this thisFile thisLine", 0, (char **)NULL);
}
X
static void
DeleteTraces (textPtr)
X    Hypertext *textPtr;
{
X    register Tcl_Interp *interp = textPtr->interp;
X    int flags = (TCL_GLOBAL_ONLY | TCL_TRACE_READS);
X
X    /* Destroy the current variable traces */
X    Tcl_UntraceVar (interp, "thisFile", flags, FileVarProc,
X		    (ClientData) textPtr);
X    Tcl_UntraceVar (interp, "thisLine", flags, FileVarProc,
X		    (ClientData) textPtr);
X    Tcl_UntraceVar (interp, "this", flags, FileVarProc,
X		    (ClientData) textPtr);
X
}
X
/*
X * ----------------------------------------------------------------------
X *
X * FindChild --
X *	Searches for a child widget matching the pattern given by
X *	*childName*.  If found, the pointer to the child structure is
X *	returned, otherwise NULL.
X *
X * Results:
X *	The pointer to the child structure. If not found, NULL.
X *
X * ----------------------------------------------------------------------
X */
X
static Child *
FindChild (interp, textPtr, pathName)
X    Tcl_Interp *interp;
X    Hypertext *textPtr;
X    char *pathName;
{
X    register Child *childPtr;
X    register Line *linePtr;
X    register int cnt;
X    int relative;
X
X    relative = (*pathName != '.');
X
X    /* Try matching pattern *pathName* to child widget name */
X    for (cnt = 0; cnt < textPtr->numLines; cnt++) {
X
X	linePtr = textPtr->lineArr[cnt];
X	for (childPtr = linePtr->children; childPtr != NULL;
X	     childPtr = childPtr->nextPtr) {
X	    if (childPtr->tkwin != NULL) {
X		char *name;
X
X		name = (relative) ? Tk_Name (childPtr->tkwin)
X		    : Tk_PathName (childPtr->tkwin);
X		if (Tcl_StringMatch (name, pathName))
X		    return (childPtr);
X	    }
X	}
X    }
X    return (NULL);
}
X
/*
X *--------------------------------------------------------------
X *
X * ChildGeometryProc --
X *
X *	This procedure is invoked by Tk_GeometryRequest for
X *	subwindows managed by the hypertext widget.
X *
X * Results:
X *	None.
X *
X * Side effects:
X *	Arranges for tkwin, and all its managed siblings, to
X *	be repacked and drawn at the next idle point.
X *
X *--------------------------------------------------------------
X */
X
X /* ARGSUSED */
static void
ChildGeometryProc (clientData, tkwin)
X    ClientData clientData;   /* Information about window that got new
X			      * preferred geometry.  */
X    Tk_Window tkwin;	     /* Other Tk-related information about the
X			      * window. */
{
X    register Child *childPtr = (Child *) clientData;
X
X    if (childPtr->widthWanted == 0)
X	childPtr->width = Tk_ReqWidth (childPtr->tkwin);
X    if (childPtr->heightWanted == 0)
X	childPtr->height = Tk_ReqHeight (childPtr->tkwin);
X
X    if (childPtr->width != Tk_Width (childPtr->tkwin) ||
X	childPtr->height != Tk_Height (childPtr->tkwin)) {
X	EventuallyRedraw (childPtr->parent);
X	childPtr->parent->flags |= LAYOUT_NEEDED;
X    }
}
X
X
X
static void
SendExposeEvent (tkwin)
X    register Tk_Window tkwin;
{
X    enum {
X	DontPropagate = 0
X    };
X    XEvent event;
X
X    event.xexpose.type = Expose;
X    event.type = Expose;
X    event.xexpose.window = Tk_WindowId (tkwin);
X    event.xexpose.display = Tk_Display (tkwin);
X    event.xexpose.count = 0;
X    event.xexpose.x = 0;
X    event.xexpose.y = 0;
X    event.xexpose.width = Tk_Width (tkwin);
X    event.xexpose.height = Tk_Height (tkwin);
X    XSendEvent (Tk_Display (tkwin), Tk_WindowId (tkwin), DontPropagate,
X		ExposureMask, &event);
}
X
X
static char *
reallocate (oldPtr, newSize, oldSize)
X    char *oldPtr;
X    unsigned int newSize;
X    unsigned int oldSize;
{
X    register char *newPtr = NULL;
X
X    if (newSize > 0) {
X
X	/* Allocate a new chunk of memory */
X	newPtr = (char *)malloc (newSize);
X	if (newPtr == NULL) {
X	    fprintf (stderr, "reallocate: line %d of `%s': %s\n\
Can't allocate object\n", __LINE__, __FILE__, sys_errlist[errno]);
X	    exit (1);
X	}
X	/* Copy whatever the old contents are */
X	if (oldPtr != NULL && oldSize > 0)
X	    bcopy (oldPtr, newPtr, MIN (oldSize, newSize));
X
X	/* and clear the new contents */
X	if (newSize > oldSize)
X	    bzero (newPtr + oldSize, newSize - oldSize);
X    }
X    free (oldPtr);
X    return (newPtr);
}
SHAR_EOF
  echo 'File snmp2/snmptcl/htext2.c is complete' &&
  $shar_touch -am 1015123693 'snmp2/snmptcl/htext2.c' &&
  chmod 0444 'snmp2/snmptcl/htext2.c' ||
  echo 'restore of snmp2/snmptcl/htext2.c failed'
  shar_count="`wc -c < 'snmp2/snmptcl/htext2.c'`"
  test 80287 -eq "$shar_count" ||
    echo "snmp2/snmptcl/htext2.c: original size 80287, current size $shar_count"
  rm -f _sharnew.tmp
fi
# ============= snmp2/snmptcl/main.c ==============
if test -f 'snmp2/snmptcl/main.c' && test X"$1" != X"-c"; then
  echo 'x - skipping snmp2/snmptcl/main.c (file already exists)'
  rm -f _sharnew.tmp
else
  > _sharnew.tmp
  echo 'x - extracting snmp2/snmptcl/main.c (text)'
  sed 's/^X//' << 'SHAR_EOF' > 'snmp2/snmptcl/main.c' &&
/* main.c
X * Main-program for
X *	tclnmm
X *	tclsnmp
X *	tclcurses
X * 
X * Poul-Henning Kamp, phk@data.fls.dk
X * 920318 0.00
X * 920319 0.01
X * 920324 0.02
X */
X
#include <curses.h>
X
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include "tcl.h"
X
extern int exit();
X
Tcl_Interp *interp;
Tcl_CmdBuf buffer;
int quitFlag = 0;
X
int
main(argc,argv)
X    int argc;
X    char **argv;
X    {
X    char line[1000], *cmd;
X    int result, gotPartial;
X
X    interp = Tcl_CreateInterp();
#ifndef NO_SNMP
X    snmp_init(interp);
#endif
#ifndef NO_CURSES
X    curses_init(interp);
#endif
X    if(argc > 1)
X	{
X	cmd = Tcl_Merge(argc-1,argv+1);
X	Tcl_SetVar(interp,"argv",cmd,TCL_GLOBAL_ONLY);
X	sprintf(line,"%d",argc-1);
X	Tcl_SetVar(interp,"argc",line,TCL_GLOBAL_ONLY);
X	if(TCL_OK == Tcl_EvalFile(interp,*++argv))
X	    exit(0);
X	cmd=Tcl_GetVar(interp,"errorInfo",TCL_GLOBAL_ONLY);
X	if(!cmd)
X	    cmd=interp->result;
X	fprintf(stderr,"%s\n",cmd );
X	exit(1);
X	}
X    else
X	{
X	buffer = Tcl_CreateCmdBuf();
X	gotPartial = 0;
X	while (1) 
X	    {
X	    clearerr(stdin);
X	    if (!gotPartial) 
X		{
X		fputs("tclnet: ", stdout);
X		fflush(stdout);
X		}
X	    if (fgets(line, 1000, stdin) == NULL) 
X		{
X		if (!gotPartial) 
X		    exit(0);
X		line[0] = 0;
X		}
X	    cmd = Tcl_AssembleCmd(buffer, line);
X	    if (cmd == NULL) 
X	        {
X		gotPartial = 1;
X		continue;
X		}
X
X	    gotPartial = 0;
X	    result = Tcl_RecordAndEval(interp, cmd, 0);
X	    if (result == TCL_OK) 
X		{
X		if (*interp->result != 0) 
X		    printf("%s\n", interp->result);
X		if (quitFlag) 
X		    {
X		    Tcl_DeleteInterp(interp);
X		    Tcl_DeleteCmdBuf(buffer);
X		    exit(0);
X		    }
X		} 
X	    else 
X		{
X		if (result == TCL_ERROR) 
X		    printf("Error");
X		else 
X		    printf("Error %d", result);
X		if (*interp->result != 0) 
X		    printf(": %s\n", interp->result);
X		else 
X		    printf("\n");
X		}
X	    }
X	}
X    }
SHAR_EOF
  $shar_touch -am 1015123693 'snmp2/snmptcl/main.c' &&
  chmod 0444 'snmp2/snmptcl/main.c' ||
  echo 'restore of snmp2/snmptcl/main.c failed'
  shar_count="`wc -c < 'snmp2/snmptcl/main.c'`"
  test 1842 -eq "$shar_count" ||
    echo "snmp2/snmptcl/main.c: original size 1842, current size $shar_count"
  rm -f _sharnew.tmp
fi
# ============= snmp2/snmptcl/tcl_snmp.c ==============
if test -f 'snmp2/snmptcl/tcl_snmp.c' && test X"$1" != X"-c"; then
  echo 'x - skipping snmp2/snmptcl/tcl_snmp.c (file already exists)'
  rm -f _sharnew.tmp
else
  > _sharnew.tmp
  echo 'x - extracting snmp2/snmptcl/tcl_snmp.c (text)'
  sed 's/^X//' << 'SHAR_EOF' > 'snmp2/snmptcl/tcl_snmp.c' &&
/* tcl_snmp.c
X * SNMP interface for Tcl
X * 
X * Poul-Henning Kamp, phk@data.fls.dk
X * 920319 0.00
X * 920322 0.01
X * 920324 0.02
X */
X
#include <stdio.h>
#include <malloc.h>
#include <sys/types.h>
#include <sys/time.h>
#include <netinet/in.h>
#include <netdb.h>
X
X
#include <snmp.h>
#include <asn1.h>
#include <snmp_impl.h>
#include <snmp_api.h>
#include <snmp_client.h>
#include <party.h>
#include <context.h>
#include <mib.h>
X
#include <tcl.h>
#include "tcl_misc.h"
X
static char *TraceDebug();
static int SnmpProc();
static int SessProc();
X
int snmp_dump_packet = 0;
X
typedef struct
{
X    int		debug;
X    char	where[64];
} t_cldat;
X
typedef struct
{
X    t_cldat	*cd;
X    char	name[64] ;
X    struct snmp_session *sess,ss;
X    struct snmp_pdu *pdu,*response;
X    int		status;
X    char	where[64];
} t_cldat2;
X
/****************************************************************************
X *
X * snmp_init(interp)
X * =================
X * 
X * Initialize the snmp interface.
X *
X ****************************************************************************/
X
void
X    snmp_init(interp)
Tcl_Interp	*interp;
{
X    t_cldat *cd;
X    
X    init_mib();
X    cd = (t_cldat *)ckalloc(sizeof *cd);
X    memset((void*)cd,0,sizeof *cd);
X    Tcl_CreateCommand(interp,"snmp",SnmpProc,cd,0);
X    Tcl_SetVar(interp,"snmp_debug","0",0);
X    Tcl_TraceVar(interp,"snmp_debug",
X		 TCL_TRACE_WRITES|TCL_TRACE_UNSETS,TraceDebug,cd);
}
X
static char*
X    TraceDebug(cd,interp,name1,name2,flags)
t_cldat *cd;
Tcl_Interp	*interp;
char *name1;
char *name2;
int flags;
{
X    cd->debug=0;
X    if(flags & TCL_TRACE_WRITES) 
X	cd->debug = atoi(Tcl_GetVar(interp,"snmp_debug",flags&TCL_GLOBAL_ONLY));
X    if(flags & TCL_TRACE_UNSETS) 
X	Tcl_SetVar(interp,"snmp_debug","0",flags&TCL_GLOBAL_ONLY);
X    if(flags & TCL_TRACE_DESTROYED)
X	Tcl_TraceVar(interp,"snmp_debug",
X		     TCL_TRACE_WRITES|TCL_TRACE_UNSETS,TraceDebug,cd);
X    fprintf(stderr,"[SNMP]: debug is now %d\n",cd->debug);
X    if(cd->debug > 99)
X	snmp_dump_packet = 1;
X    else
X	snmp_dump_packet = 0;
X    return 0;
}
X
static char *
X    stralloc(s)
char *s;
{
X    char *t = (char *)ckalloc(strlen(s)+1);
X    strcpy(t,s);
X    return t;
}
X
OidCpy(d,dl,s,sl)
X    oid *d,*s;
X    int *dl,*sl;
{
X    memcpy(d,s,(*sl) * sizeof(*d));
X    *dl = *sl;
}
X
int
X    OidCmp(d,s,l)
oid *d,*s;
int l;
{
X    return memcmp(d,s,l * sizeof(*d));
}
X
static int
X    NextOid(interp,cd2,type,nvar)
Tcl_Interp  *interp;
t_cldat2 *cd2;
int type;
int *nvar;
{
X    int i;
X    struct variable_list *vars;
X    oid name[MAX_NAME_LEN];
X    int name_length;
X    
X    cd2->pdu = snmp_pdu_create(type);
X    i=0;
X    for(vars=cd2->response->variables;vars;vars=vars->next_variable)
X	{
X	    OidCpy(name,&name_length,vars->name,&vars->name_length);
X	    snmp_add_null_var(cd2->pdu, name, name_length);
X	    i++;
X	}
X    *nvar = i;
X    return TCL_OK;
}
X
X
static char*
X    VarVal(vars)
struct variable_list *vars;
{
X    static char buf[8192], *s;
X    
X    sprint_value(buf,vars->name,vars->name_length,vars);
X    for(s=buf;*s && *s != ':';s++) ;
X    for(s++;*s && isspace(*s);s++) ;
X    return s;
}
X
static char*
X    Raw_Value(vars)
struct variable_list *vars;
{
X    char *s1;
X    int err = 0;
X
X    static char tmp1[500], tmp2[500], tmp3[500], tmp4[500];
X    char *retval;
X
X    /* The tmp's are for a 
X     * 1. result string
X     * 2. result type
X     * 3. result oid
X     * 4. result err status
X     */ 
X
X    /* Get the result value.
X     */
X
X    sprintf(tmp1, "null");
X    sprintf(tmp2, "null");
X    sprintf(tmp3, "null");
X    sprintf(tmp4, "null");
X    err = 0;
X
X    switch(vars->type) {
X	/* Check for "errors", first */
X	case SNMP_ENDOFMIBVIEW: {
X	    /* End of MIB... */
X	    err = SNMP_ENDOFMIBVIEW;
X	    sprintf(tmp1, "null");
X	    sprintf(tmp2, "null");
X	    sprintf(tmp3, "null");
X	    sprintf(tmp4, "end_of_mib");
X	    break;
X	}
X	case SNMP_NOSUCHOBJECT: {
X	    /* No such object */
X	    err = SNMP_NOSUCHOBJECT;
X	    sprintf(tmp1, "null");
X	    sprintf(tmp2, "null");
X	    sprintf(tmp3, "null");
X	    sprintf(tmp4, "no_such_object");
X	    break;
X	}
X	case SNMP_NOSUCHINSTANCE: {
X	    /* No such instance */
X	    err = SNMP_NOSUCHINSTANCE;
X	    sprintf(tmp1, "null");
X	    sprintf(tmp2, "null");
X	    sprintf(tmp3, "null");
X	    sprintf(tmp4, "no_such_instance");
X	    break;
X	}
X	case OBJID: {
X	    int j;
X	    int noid;
X	    int i = 0;
X
X	    sprintf(tmp2, "oid");
X	    
X	    noid = vars->val_len / sizeof(oid);
X	    tmp1[0] = 0;
X	    for(j = 0; j < noid; j++) {
X		i = strlen(tmp1);
X		if (i == 0) {
X		    sprintf(&(tmp1[i]), "%i", vars->val.objid[j]);
X		} else {
X		    sprintf(&(tmp1[i]), ".%i", vars->val.objid[j]);
X		}
X	    }
X	    break;
X	}
X	case STRING: {
X	    /* Some special case code-- check for non-printable chars. */
X	    int i, j;
X
X	    i = j = 0;
X
X	    for (i = 0; i < vars->val_len; i++) {
X		if (!(isprint(vars->val.string[i]))) {
X		    /* Non-print character... We'll parse it differently. */
X		    j = 1;
X		}
X	    }
X	    if (!j) {
X		sprintf(tmp2, "string");
X		
X		tmp1[0] = '"';
X		bcopy(vars->val.string, (char *) &(tmp1[1]), vars->val_len);
X		tmp1[vars->val_len + 1] = '"';
X		tmp1[vars->val_len + 2] = 0;
X	    } else {
X		/* We'll display this sucker in hex. */
X		sprintf(tmp2, "hex");
X		tmp1[0] = '"';
X		tmp1[1] = 0;
X		for (i = 0; i < vars->val_len; i++) {
X		    j = strlen(tmp1);
X		    sprintf(&tmp1[j], " %02X ", (int) vars->val.string[i]);
X		}
X	        j = strlen(tmp1);
X		sprintf(&tmp1[j], " \"");
X	    }
X	    break;
X	}
X	case INTEGER: {
X	    sprintf(tmp2, "integer");
X	    
X	    sprintf(tmp1, "%i", *vars->val.integer);
X	    break;
X	}
X	case GAUGE: {
X	    sprintf(tmp2, "gauge");
X	    sprintf(tmp1, "%i", *vars->val.integer);
X	    break;
X	}
X	case COUNTER: {
X	    sprintf(tmp2, "counter");
X	    sprintf(tmp1, "%i", *vars->val.integer);
X	    break;
X	}
X	case TIMETICKS: {
X	    sprintf(tmp2, "timeticks");
X	    sprintf(tmp1, "%i", *vars->val.integer);
X	    break;
X	}
X	default: {
X	    sprintf(tmp2, "unrecognized");
X	    sprintf(tmp1, "Cannot_Parse_Result");
X	    break;
X	}
X    }
X    if (!err) {
X	/* Create the oid returned. */
X	{
X	    int j;
X	    int noid;
X	    int i = 0;
X	    
X	    noid = vars->name_length;
X	    tmp3[0] = 0;
X	    for(j = 0; j < noid; j++) {
X		i = strlen(tmp3);
X		if (i == 0) {
X		    sprintf(&(tmp3[i]), "%i", vars->name[j]);
X		} else {
X		    sprintf(&(tmp3[i]), ".%i", vars->name[j]);
X		}
X	    }
X	}
X    }
X    retval = (char *) malloc (strlen(tmp1) + 
X			      strlen(tmp2) +
X			      strlen(tmp3) +
X			      strlen(tmp4) + 10);
X    sprintf(retval, "{%s %s %s %s}", tmp1, tmp2, tmp3, tmp4);
X    return(retval);
X
X    /* 128.2.232.132 */
}
X
static int
X    ParseOid(interp,arg,cd2,type,nvar)
Tcl_Interp  *interp;
char *arg;
t_cldat2 *cd2;
int type;
int *nvar;
{
X    int i;
X    oid name[MAX_NAME_LEN];
X    int name_length;
X    char *s,*t;
X    
X    cd2->pdu = snmp_pdu_create(type);
X    for(i=0,s=arg;*s;s=t,i++)
X	{
X	    for(;*s && isspace(*s);s++) ;
X	    if(!*s) break;
X	    for(t=s;*t && !isspace(*t);t++) ;
X	    if(*t) *t++ = 0;
X	    name_length = MAX_NAME_LEN;
X	    if (!read_objid(s, name, &name_length))
X		return Error(interp,cd2->where,"OID argument error.");
X	    snmp_add_null_var(cd2->pdu, name, name_length);
X	}
X    if(!i)
X	return Error(interp,cd2->where,"OID argument empty.");
X    *nvar=i;
X    return TCL_OK;
}
X
static int parse_setoid(interp, cd2, list, length)
X    Tcl_Interp  *interp;
X    t_cldat2 *cd2;
X    char *list;
X    int length;
{
X    char *value;
X    int   value_length;
X    char *type;
X    int   type_length;
X    char *oid_name;
X    int   oid_name_length;
X
X    char value_str[100];
X    char oid_str[100];
X
X    char *element;
X    char *next;
X    int   sizePtr;
X    int   braced;
X
X    struct variable_list *vars;
X
X    int i;
X    oid name[MAX_NAME_LEN];
X    int name_length;
X    char *s,*t;
X
X    if (!cd2->pdu) {
X	cd2->pdu = snmp_pdu_create(SET_REQ_MSG);
X    }
X
X    if (!cd2->pdu->variables) {
X	cd2->pdu->variables = (struct variable_list *) malloc (sizeof(struct variable_list));
X	vars = cd2->pdu->variables;
X	vars->next_variable = NULL;
X    } else {
X	for (vars = cd2->pdu->variables; vars->next_variable; vars = vars->next_variable);
X	vars->next_variable = (struct variable_list *) malloc (sizeof(struct variable_list));
X	vars = vars->next_variable;
X	vars->next_variable = NULL;
X    }
X    /* At this point, vars points at a subject variable list entry to add. */
X    
X    value = list;
X  
X    TclFindElement(interp, list, &element, &next, &sizePtr, &braced);
X    value_length = sizePtr;
X    type = next;
X    list = next;
X
X    TclFindElement(interp, list, &element, &next, &sizePtr, &braced);
X    
X    type_length = sizePtr;
X    oid_name = next;
X    list = next;
X    oid_name_length = length - ((int)oid_name - (int)value);
X
X    /* At this point, we have delimited the arguments. */
X
X    bcopy(value, value_str, value_length);
X    value_str[value_length] = 0;
X
X    bcopy(oid_name, oid_str, oid_name_length);
X    oid_str[oid_name_length] = 0;
X
X    /* Okay, now special case for each type... */
X
X    if (!strncmp(type, "integer", 7)) {
X	/* We write an integer... */
X	vars->type = INTEGER;
X	vars->val.integer = (int *) malloc (sizeof(int));
X	vars->val_len = sizeof(int);
X	*(vars->val.integer) = atoi(value_str);
X    } else if (!strncmp(type, "string", 6)) {
X	/* We write a string... */
X	vars->type = STRING;
X	vars->val.string = (u_char *) malloc (value_length);
X	bcopy(value_str, vars->val.string, value_length);
X    	vars->val_len = value_length;
X    } else {
X	printf("Haven't done this type yet.");
X    }
X
X    /* Okay, parse the oid */
X    
X    name_length = MAX_NAME_LEN;
X    if (!read_objid(oid_str, name, &name_length)) {
X	printf("Error parsing oid string");
X    }
X
X    vars->name = (oid *) malloc (sizeof(oid) * name_length);
X    bcopy((char *) name, (char *) vars->name, name_length * sizeof(oid));
X    vars->name_length = name_length;
X
X    return TCL_OK;
}
X
static int SnmpSet(interp, argc, argv, cd2)
X    Tcl_Interp  *interp;
X    int argc;
X    char **argv;
X    t_cldat2 *cd2;
{
X    char  *list;
X    char *element;
X    char *next;
X    int   sizePtr;
X    int   braced;
X
X    /* We get to parse this list of stuff...
X     * (Yay!)
X     * (Not!)
X     */
X
X    /*
X     * Format for snmpset:  
X     *  session set "{value type name} [{value type name} [...]]"
X     */
X
X    /* There's a handy dandy utility for finding an element. 
X     * It's called "TclFindElement".
X     */
X
X    if(cd2->response)
X	snmp_free_pdu(cd2->response);
X    cd2->response = NULL;
X
X    cd2->pdu = NULL;
X
X    next = (char *)1;
X    list = argv[1];
X    sizePtr = 5;
X    while(next && sizePtr) {
X	TclFindElement(interp, list, &element, &next, &sizePtr, &braced);
X	if (sizePtr) {
X	    parse_setoid(interp, cd2, element, sizePtr);
X	    list = next;
X	}
X    }
X
X    /* At this point, we should have a set request ready.
X     */
X    cd2->status = snmp_synch_response(cd2->sess, cd2->pdu, &cd2->response);
X
X    if (cd2->status == STAT_SUCCESS) {
X	if (cd2->response->errstat == SNMP_ERR_NOERROR) {
X	    Tcl_SetResult(interp, "Success", TCL_VOLATILE);
X	} else {
X	    switch (cd2->response->errstat) {
X		case SNMP_ERR_READONLY: {
X		    Tcl_SetResult(interp, "readonly", TCL_VOLATILE);
X		    break;
X		} 
X		case SNMP_ERR_BADVALUE: {
X		    Tcl_SetResult(interp, "badvalue", TCL_VOLATILE);
X		    break;
X		}
X		default: {
X		    Tcl_SetResult(interp, "error", TCL_VOLATILE);
X		    break;
X		}
X	    }
X	}
X    } else {
X	Tcl_SetResult(interp, "network_error", TCL_VOLATILE);
X    }
X
X    return (TCL_OK);
}
X
static int SnmpGet(interp,argc,argv,cd2)
X    Tcl_Interp  *interp;
X    int argc;
X    char **argv;
X    t_cldat2 *cd2;
{
X    int i,j;
X    char *responses[200];
X    int nresp = 0;
X    struct variable_list *vars;
X    char *retval;
X    int tlen = 0;
X
X    if((j = ParseOid(interp,argv[1],cd2,GET_REQ_MSG,&i)) != TCL_OK)
X	return j;
X    if(cd2->response)
X	snmp_free_pdu(cd2->response);
X    cd2->response = NULL;
X
X    cd2->status = snmp_synch_response(cd2->sess,cd2->pdu,&cd2->response);
X
X    if(i >= 1) {
X	/* Let's check for a response, too! */
X	if (cd2->status == STAT_SUCCESS) {
X	    if (cd2->response->errstat == SNMP_ERR_NOERROR) {
X		/* We have a valid response! 
X		 * Let's return the sucker.  However, 
X		 */
X		for (nresp = 0, vars = cd2->response->variables; vars; vars = vars->next_variable) {
X		    responses[nresp] = Raw_Value(vars);
X		    nresp++;
X		}
X		tlen = 0;
X		for (i = 0; i < nresp; i++) {
X		    tlen += strlen(responses[i]);
X		}
X		retval = (char *) malloc(tlen + nresp + 5);
X		retval[0] = 0;
X		for (i = 0; i < nresp; i++) {
X		    j = strlen(retval);
X		    sprintf(&retval[j], "%s ", responses[i]);
X		}
X		Tcl_SetResult(interp, 
X			      retval,
X			      TCL_DYNAMIC);
X	    } else {
X		/* We have an error in the get request.
X		 * We'll do something about this eventually.
X		 */
X		if (cd2->response->errstat == SNMP_ERR_NOSUCHNAME) {
X		    Tcl_SetResult(interp, "{No_Such_name}", TCL_VOLATILE);
X		} else {
X		    printf("We have an error, dudes0.\n");
X		}
X	    }
X	} else if (cd2->status == STAT_TIMEOUT) {
X	    /* We have a timeout */
X	    Tcl_SetResult(interp, "{Timeout}", TCL_VOLATILE);
X	} else {
X	    /* We have a nastier error of some kind */
X	    printf("We have an error, dudes3.\n");
X	}
X    }
X    return TCL_OK;
}
X
static int SnmpGetNext(interp,argc,argv,cd2)
X    Tcl_Interp  *interp;
X    int argc;
X    char **argv;
X    t_cldat2 *cd2;
{
X    int i,j;
X    char *responses[200];
X    int nresp = 0;
X    struct variable_list *vars;
X    char *retval;
X    int tlen = 0;
X
X    if((j = ParseOid(interp,argv[1],cd2,GETNEXT_REQ_MSG,&i)) != TCL_OK)
X	return j;
X    if(cd2->response)
X	snmp_free_pdu(cd2->response);
X    cd2->response = NULL;
X
X    cd2->status = snmp_synch_response(cd2->sess,cd2->pdu,&cd2->response);
X
X    if(i >= 1) {
X	/* Let's check for a response, too! */
X	if (cd2->status == STAT_SUCCESS) {
X	    if (cd2->response->errstat == SNMP_ERR_NOERROR) {
X		/* We have a valid response! 
X		 * Let's return the sucker.  However, 
X		 */
X		for (nresp = 0, vars = cd2->response->variables; vars; vars = vars->next_variable) {
X		    responses[nresp] = Raw_Value(vars);
X		    nresp++;
X		}
X		tlen = 0;
X		for (i = 0; i < nresp; i++) {
X		    tlen += strlen(responses[i]);
X		}
X		retval = (char *) malloc(tlen + nresp + 5);
X		retval[0] = 0;
X		for (i = 0; i < nresp; i++) {
X		    j = strlen(retval);
X		    sprintf(&retval[j], "%s ", responses[i]);
X		}
X		Tcl_SetResult(interp, 
X			      retval,
X			      TCL_DYNAMIC);
X	    } else {
X		/* We have an error in the get request.
X		 * We'll do something about this eventually.
X		 */
X		if (cd2->response->errstat == SNMP_ERR_NOSUCHNAME) {
X		    Tcl_SetResult(interp, "{No_Such_name}", TCL_VOLATILE);
X		} else {
X		    printf("We have an error, dudes0.\n");
X		}
X	    }
X	} else if (cd2->status == STAT_TIMEOUT) {
X	    /* We have a timeout */
X	    Tcl_SetResult(interp, "{Timeout}", TCL_VOLATILE);
X	} else {
X	    /* We have a nastier error of some kind */
X	    printf("We have an error, dudes3.\n");
X	}
X    }
X    return TCL_OK;
}
X
static int SnmpWalk(interp,argc,argv,cd2)
X    Tcl_Interp  *interp;
X    int argc;
X    char **argv;
X    t_cldat2 *cd2;
{
X
#define WIDTH  50
X    
X    oid rname[WIDTH][MAX_NAME_LEN];
X    int rname_length[WIDTH];
X    oid oname[WIDTH][MAX_NAME_LEN];
X    int oname_length[WIDTH];
X    int dead[WIDTH];
X    int finished = 0;
X
X    char *retval;
X
X    char *responses[100];
X
X    struct variable_list *vars;
X
X    int i,j;
X
X    int tlen = 0;
X
X    int nvars;
X    int nresp;
X
X    bzero((char *) dead, sizeof(dead));
X
X    
X    if((j = ParseOid(interp,argv[1],cd2,GETNEXT_REQ_MSG,&i)) != TCL_OK)
X	return j;
X
X    nvars = i;
X    i = 0;
X    for (vars = cd2->pdu->variables; vars; vars = vars->next_variable) {
X	/* Copy all the names/lengths out... */
X	OidCpy(&(oname[i][0]), &oname_length[i], vars->name, &vars->name_length);
X	OidCpy(&(rname[i][0]), &rname_length[i], vars->name, &vars->name_length);
X	i++;
X    }
X
X    /* Let's nuke that pdu ParseOid created: I'd rather make my own. */
X
X    snmp_free_pdu(cd2->pdu);
X    cd2->pdu = NULL;
X
X
X    /* At this point, oname and rname contain the oids/lengths to request. */
X    while (!finished) {
X	/* For all the threads not dead... We'll request a packet. */
X	finished = 1;
X	cd2->pdu = NULL;
X	for (i = 0; i < nvars; i++) {
X	    if (!dead[i]) {
X		if (!cd2->pdu) {
X		    finished = 0;
X		    cd2->pdu = snmp_pdu_create(GETNEXT_REQ_MSG);
X		}
X		snmp_add_null_var(cd2->pdu, rname[i], rname_length[i]);
X	    }
X	}
X	if (!finished) {
X	    cd2->status = snmp_synch_response(cd2->sess, cd2->pdu, &cd2->response);
X	    if (cd2->status == STAT_SUCCESS) {
X		if (cd2->response->errstat == SNMP_ERR_NOERROR) {
X		    /* We got a successful packet...
X		     * I'm going to copy the response parsing code from get.
X		     * The name stuff is my own, though.
X		     */
X		    vars = cd2->response->variables;
X		    finished = 1;
X		    for (i = 0; i < nvars; i++) {
X			if (!dead[i]) {
X			    /* If we made a request, read the response. */
X			    OidCpy(&(rname[i][0]), &rname_length[i], vars->name, &vars->name_length);
X			    
X			    /* Check the result value. 
X			     * We need to see if we need to stop.
X			     */
X
X			    if (rname_length[i] < oname_length[i] || bcmp(oname[i], rname[i], oname_length[i] * sizeof(oid))) {
X				/* This is no longer a part of the subtree... */
X				dead[i] = 1;
X			    } else {
X				/* At least one valid response... */
X				finished = 0;
X			    }
X			    vars = vars->next_variable;
X			}
X		    }
X		    /* Now, we want to parse ONLY those values that are alive...
X		     * remembering that some of the resoponses just died.
X		     * This introduces two "dead" states: state
X		     * 1 = Just died; it exists in this packet.
X		     * 2 = Long dead; it does not exist in this packet.
X		     */
X		    nresp = 0;
X		    vars = cd2->response->variables;
X		    /* Note that this creates a complete response set, filling in blanks. */
X		    for (i = 0; i < nvars; i++) {
X			if (!dead[i] || dead[i] == 1) {
X			    /* We have to do this one...
X			     * I'm taking this stuff all from snmpget, now. 
X			     */
X			    if (dead[i] == 1) {
X				dead[i] = 2;
X				responses[i] = "{done}";
X			    } else {
X				responses[i] = Raw_Value(vars);
X			    }
X			    vars = vars->next_variable;
X			    nresp++;
X			} else {
X			    responses[i] = "{done}";
X			}
X		    }
X		    tlen = 0;
X		    for (i = 0; i < nvars; i++) {
X			tlen += strlen(responses[i]);
X		    }
X		    retval = (char *) malloc(tlen + nresp * 2 + 5);
X		    retval[0] = 0;
X		    for (i = 0; i < nvars; i++) {
X			j = strlen(retval);
X			sprintf(&retval[j], " %s ", responses[i]);
X		    }
X		    
X		    if(TCL_OK != Tcl_VarEval(interp,argv[2], retval, 0))
X			return TCL_ERROR;
X
X		} else {
X		    /* We have an error... Probably an end of mib. */
X		    Tcl_SetResult(interp, "{End_Of_Mib}", TCL_VOLATILE);
X		    return TCL_OK;
X		}
X	    } else {
X		/* We might have a timeout */
X		if (cd2->status == STAT_TIMEOUT) {
X		    Tcl_SetResult(interp, "{Timeout}", TCL_VOLATILE);
X		    return TCL_OK;
X		    /* We timed out */
X		} else {
X		    Tcl_SetResult(interp, "{Error}", TCL_VOLATILE);
X		    return TCL_OK;
X		    /* Something else bad happened. */
X		}
X	    }
X	}
X    }
X    Tcl_SetResult(interp, "{Success}", TCL_VOLATILE);
X    return TCL_OK;
}
X
static int SnmpBulk(interp,argc,argv,cd2)
X    Tcl_Interp  *interp;
X    int argc;
X    char **argv;
X    t_cldat2 *cd2;
{
X
#define WIDTH  50
X    
X    oid rname[WIDTH][MAX_NAME_LEN];
X    int rname_length[WIDTH];
X    oid oname[WIDTH][MAX_NAME_LEN];
X    int oname_length[WIDTH];
X    int dead[WIDTH];
X    int finished = 0;
X
X    int depth = 0;
X    int width = 0;
X    int z;
X
X    char *retval;
X
X    char *responses[100];
X
X    struct variable_list *vars, *start;
X
X    int i,j;
X
X    int tlen = 0;
X
X    int nvars;
X    int nresp;
X
X    bzero((char *) dead, sizeof(dead));
X
X    
X    if((j = ParseOid(interp,argv[1],cd2,GETNEXT_REQ_MSG,&i)) != TCL_OK)
X	return j;
X
X    nvars = i;
X    i = 0;
X    for (vars = cd2->pdu->variables; vars; vars = vars->next_variable) {
X	/* Copy all the names/lengths out... */
X	OidCpy(&(oname[i][0]), &oname_length[i], vars->name, &vars->name_length);
X	OidCpy(&(rname[i][0]), &rname_length[i], vars->name, &vars->name_length);
X	i++;
X    }
X
X    /* Let's nuke that pdu ParseOid created: I'd rather make my own. */
X
X    snmp_free_pdu(cd2->pdu);
X    cd2->pdu = NULL;
X
X
X    /* At this point, oname and rname contain the oids/lengths to request. */
X    while (!finished) {
X	/* For all the threads not dead... We'll request a packet. */
X	finished = 1;
X	cd2->pdu = NULL;
X	width = 0;
X	for (i = 0; i < nvars; i++) {
X	    if (!dead[i]) {
X		if (!cd2->pdu) {
X		    finished = 0;
X		    cd2->pdu = snmp_pdu_create(BULK_REQ_MSG);
X		    cd2->pdu->non_repeaters = 0;
X		    cd2->pdu->max_repetitions = 1000;
X		}
X		width++;
X		snmp_add_null_var(cd2->pdu, rname[i], rname_length[i]);
X	    }
X	}
X	if (!finished) {
X	    cd2->status = snmp_synch_response(cd2->sess, cd2->pdu, &cd2->response);
X	    if (cd2->status == STAT_SUCCESS) {
X		if (cd2->response->errstat == SNMP_ERR_NOERROR) {
X		    /* We got a successful packet...
X		     * I'm going to copy the response parsing code from get.
X		     * The name stuff is my own, though.
X		     *
X		     * For bulk: I'm going to count the # response packets.
X		     */
X		    z = 0;
X		    for (vars = cd2->response->variables; vars; vars = vars->next_variable, z++);
X		    
X		    /* z has the # elements returned... 
X		     * divide z/width to get depth..
X		     */
X		    
X		    depth = z / width;
X
X		    /* We want to pass through all this stuff "depth" times...
X		     */
X		    
X		    
X		    vars = cd2->response->variables;
X		    start = vars;
X		    for (z = 0; z < depth && !finished; z++) {
X			finished = 1;
X			start = vars;
X			for (i = 0; i < nvars; i++) {
X			    if (!dead[i] || dead[i] == 1) {
X				/* If we made a request, read the response. */
X				OidCpy(&(rname[i][0]), &rname_length[i], vars->name, &vars->name_length);
X				
X				/* Check the result value. 
X				 * We need to see if we need to stop.
X				 */
X				
X				if (rname_length[i] < oname_length[i] || bcmp(oname[i], rname[i], oname_length[i] * sizeof(oid))) {
X				    /* This is no longer a part of the subtree... */
X				    dead[i] = 1;
X				} else {
X				    /* At least one valid response... */
X				    finished = 0;
X				}
X				vars = vars->next_variable;
X			    }
X			}
X			/* Now, we want to parse ONLY those values that are alive...
X			 * remembering that some of the resoponses just died.
X			 * This introduces two "dead" states: state
X			 * 1 = Just died; it exists in this packet.
X			 * 2 = Long dead; it does not exist in this packet.
X			 */
X			nresp = 0;
X			vars = start;
X			/* Note that this creates a complete response set, filling in blanks. */
X			for (i = 0; i < nvars; i++) {
X			    if (!dead[i] || dead[i] == 1) {
X				/* We have to do this one...
X				 * I'm taking this stuff all from snmpget, now. 
X				 */
X				if (dead[i] == 1) {
X				    responses[i] = "{done}";
X				} else {
X				    responses[i] = Raw_Value(vars);
X				}
X				vars = vars->next_variable;
X				nresp++;
X			    } else {
X				responses[i] = "{done}";
X			    }
X			}
X			start = vars;
X			tlen = 0;
X			for (i = 0; i < nvars; i++) {
X			    tlen += strlen(responses[i]);
X			}
X			retval = (char *) malloc(tlen + nresp * 2 + 5);
X			retval[0] = 0;
X			for (i = 0; i < nvars; i++) {
X			    j = strlen(retval);
X			    sprintf(&retval[j], " %s ", responses[i]);
X			}
X			
X			if(TCL_OK != Tcl_VarEval(interp,argv[2], retval, 0))
X			    return TCL_ERROR;
X		    }
X		    for (i = 0; i < nvars; i++) {
X			if (dead[i] == 1) { 
X			    dead[i] = 2;
X			}
X		    }
X		} else {
X		    /* We have an error... Probably an end of mib. */
X		    Tcl_SetResult(interp, "{End_Of_Mib}", TCL_VOLATILE);
X		    return TCL_OK;
X		}
X	    } else {
X		/* We might have a timeout */
X		if (cd2->status == STAT_TIMEOUT) {
X		    Tcl_SetResult(interp, "{Timeout}", TCL_VOLATILE);
X		    return TCL_OK;
X		    /* We timed out */
X		} else {
X		    Tcl_SetResult(interp, "{Error}", TCL_VOLATILE);
X		    return TCL_OK;
X		    /* Something else bad happened. */
X		}
X	    }
X	}
X    }
X    Tcl_SetResult(interp, "{Success}", TCL_VOLATILE);
X    return TCL_OK;
}
X
X
static int
X    SnmpGetTable(interp,argc,argv,cd2)
Tcl_Interp  *interp;
int argc;
char **argv;
t_cldat2 *cd2;
{
X    oid rname[MAX_NAME_LEN];
X    int rname_length;
X    int i,j;
X    
X    if((j = ParseOid(interp,argv[1],cd2,GETNEXT_REQ_MSG,&i)) != TCL_OK)
X	return j;
X    OidCpy(rname,&rname_length,
X	   cd2->pdu->variables->name,&cd2->pdu->variables->name_length);
X    
X    for(;;)
X	{
X	    if(cd2->response)
X		snmp_free_pdu(cd2->response);
X	    cd2->response=0;
X	    cd2->status = snmp_synch_response(cd2->sess,cd2->pdu,&cd2->response);
X	    if(cd2->response->errstat == SNMP_ERR_NOSUCHNAME)
X		return TCL_OK;
X	    if(cd2->response->variables->name_length >= rname_length)
X		if(OidCmp(rname, cd2->response->variables->name, rname_length))
X		    return TCL_OK;
X	    if(TCL_OK != Tcl_VarEval(interp,argv[2],0))
X		return TCL_ERROR;
X	    if((j = NextOid(interp,cd2,GETNEXT_REQ_MSG,&i)) != TCL_OK)
X		return j;
X	}
}
X
X
static int
X    SnmpClose(interp,argc,argv,cd2)
Tcl_Interp  *interp;
int argc;
char **argv;
t_cldat2 *cd2;
{
X    if(cd2->response)
X	snmp_free_pdu(cd2->response);
X    cd2->response=0;
X    ckfree(cd2->sess);
X    Tcl_DeleteCommand(interp,cd2->name);
X    ckfree(cd2);
X    return TCL_OK;
}
X
static int
X    SnmpOid(interp,argc,argv,cd2)
Tcl_Interp  *interp;
int argc;
char **argv;
t_cldat2 *cd2;
{
X    struct variable_list *vars;
X    int i;
X    char buf[8192];
X    
X    i = 0;
X    /* process options here */
X    if(argc > 1)
X	i = atoi(argv[1]);
X    for(vars=cd2->response->variables;vars;vars=vars->next_variable)
X	if(!i--)
X	    break;
X    if(!vars)
X	return TCL_ERROR;
X    *buf = 0;
X    for(i=0;i<vars->name_length;i++)
X	sprintf(buf+strlen(buf)," %d",vars->name[i]);
X    Tcl_SetResult(interp,buf+1,TCL_VOLATILE);
X    return TCL_OK;
}
X
static int
X    SnmpPrettyOid(interp,argc,argv,cd2)
Tcl_Interp  *interp;
int argc;
char **argv;
t_cldat2 *cd2;
{
X    struct variable_list *vars;
X    int i;
X    char buf[8192];
X    
X    i = 0;
X    /* process options here */
X    if(argc > 1)
X	i = atoi(argv[1]);
X    for(vars=cd2->response->variables;vars;vars=vars->next_variable)
X	if(!i--)
X	    break;
X    if(!vars)
X	return TCL_ERROR;
X    *buf = 0;
X    sprint_objid(buf, vars->name, vars->name_length);
X    Tcl_SetResult(interp,buf,TCL_VOLATILE);
X    return TCL_OK;
}
X
static int
X    SnmpVal(interp,argc,argv,cd2)
Tcl_Interp  *interp;
int argc;
char **argv;
t_cldat2 *cd2;
{
X    struct variable_list *vars;
X    int i;
X    
X    i = 0;
X    /* process options here */
X    if(argc > 1)
X	i = atoi(argv[1]);
X    for(vars=cd2->response->variables;vars;vars=vars->next_variable)
X	if(!i--)
X	    break;
X    if(!vars)
X	return TCL_ERROR;
X    Tcl_SetResult(interp,VarVal(vars),TCL_VOLATILE);
X    return TCL_OK;
}
X
X
snmp_usage(){
X    fprintf(stderr, "Usage: open snmp sess-name -v 1 hostname community      or:\n");
X    fprintf(stderr, "Usage: open snmp sess-name [-v 2 ] hostname noAuth      or:\n");
X    fprintf(stderr, "Usage: open snmp sess-name [-v 2 ] hostname srcParty dstParty context\n");
}
X
X
static int
X    SnmpProc(cd,interp,argc,argv)
t_cldat *cd;
Tcl_Interp  *interp;
int argc;
char **argv;
{
X    /* Variables from snmpwalk.c for parsing*/
X    struct snmp_pdu *pdu, *response;
X    struct variable_list *vars;
X    int arg;
X    char *hostname = NULL;
X    char *community = NULL;
X    int gotroot = 0, version = 2;
X    oid name[MAX_NAME_LEN];
X    int name_length;
X    oid root[MAX_NAME_LEN];
X    int rootlen, count;
X    int running;
X    int status;
X    int port_flag = 0;
X    int dest_port = 0;
X    oid src[MAX_NAME_LEN], dst[MAX_NAME_LEN], context[MAX_NAME_LEN];
X    int srclen = 0, dstlen = 0, contextlen = 0;
X    u_long      srcclock, dstclock;
X    int clock_flag = 0;
X    struct partyEntry *pp;
X    struct contextEntry *cxp;
X    int trivialSNMPv2 = FALSE;
X    struct hostent *hp;
X    u_long destAddr;
X    char result[1000];
X    /* End of snmmpwalk.c vars for parsing*/
X    
X    int exit_flag=FALSE;
X    int sess_num = 0;
X    int i;    
X    t_cldat2 *cd2;
X    
X    if(cd->debug)
X	{
X	    fprintf(stderr,"[SNMP]: SnmpProc %d ",argc);
X	    for(i=0;i<argc;i++)
X		fprintf(stderr,"{%s} ",argv[i]);
X	    fprintf(stderr,"\n");
X	}
X    
X    strcpy(cd->where,"[SNMP] ");
X    strcat(cd->where,argv[0]);
X    argc--; argv++;
X    if(argc < 2){
X	return Error(interp,cd->where,"no args.");
X    }
X    strcat(cd->where," ");
X    strcat(cd->where,argv[0]);
X
X    IFW("tran") {
X	CHKNARG(2, 2, cd->where);
X	name_length = MAX_NAME_LEN;
X	if (!read_objid(argv[1], name, &name_length)) {
X	    /* Error */
X	    Tcl_SetResult(interp, "{Invalid_Oid}", TCL_VOLATILE);
X	} else {
X	    /* Not error */
X	    bzero((char *) result, sizeof(result));
X	    sprint_objid(result, name, name_length);
X	    Tcl_SetResult(interp, result, TCL_VOLATILE);
X	}
X    }	
X
X    IFW("open")
X	/*
X	 * snmpwalk -v 1 hostname community
X	 * snmpwalk [-v 2 ] hostname noAuth
X	 * snmpwalk [-v 2 ] hostname srcParty dstParty context
X	 */
X
X	{
X	    /*    CHKNARG(3,4,cd->where); */
X	    /* Snmpwalk parsing code */
X	    for(arg = 1; arg < argc; arg++){
X		if (argv[arg][0] == '-'){
X		    switch(argv[arg][1]){
X			case 'd': {
X			    snmp_dump_packet++;
X			    break;
X			}
X			case 'p':{
X			    port_flag++;
X			    dest_port = atoi(argv[++arg]);
X			    break;
X			}
X			case 'c':{
X			    clock_flag++;
X			    srcclock = atoi(argv[++arg]);
X			    dstclock = atoi(argv[++arg]);
X			    break;
X			}
X			case 'v':{
X			    version = atoi(argv[++arg]);
X			    break;
X			}
X			default:{
X			    printf("invalid option: -%c\n", argv[arg][1]);
X			    break;
X			}
X		    }
X		    continue;
X		}
X		if (sess_num == 0){
X		    sess_num = arg;
X		} else if (hostname == NULL){
X		    hostname = argv[arg];
X		} else if (version == 1 && community == NULL){
X		    community = argv[arg];
X		} else if (version == 2 && srclen == 0 && !trivialSNMPv2){
X		    if (read_party_database("/etc/party.conf") > 0){
X			fprintf(stderr,
X				"Couldn't read party database from /etc/party.conf\n");
X			exit_flag=1;
X		    }
X		    if (read_context_database("/etc/context.conf") > 0){
X			fprintf(stderr,
X				"Couldn't read context database from /etc/context.conf\n");
X			exit_flag=1;
X		    }
X		    if (read_acl_database("/etc/acl.conf") > 0){
X			fprintf(stderr,"Couldn't read access control database from /etc/acl.conf\n");
X			exit_flag=1;
X		    }
X		    if (!strcasecmp(argv[arg], "noauth")){
X			trivialSNMPv2 = TRUE;
X		    } else {
X			party_scanInit();
X			for(pp = party_scanNext(); pp; pp = party_scanNext()){
X			    if (!strcasecmp(pp->partyName, argv[arg])){
X				srclen = pp->partyIdentityLen;
X				bcopy(pp->partyIdentity, src,
X				      srclen * sizeof(oid));
X				break;
X			    }
X			}
X			if (!pp){
X			    srclen = MAX_NAME_LEN;
X			    if (!read_objid(argv[arg], src, &srclen)){
X				printf("Invalid source party: %s\n",
X				       argv[arg]);
X				srclen = 0;
X				snmp_usage();
X				exit_flag=1;
X			    }
X			}
X		    }
X		} else if (version == 2 && dstlen == 0 && !trivialSNMPv2){
X		    dstlen = MAX_NAME_LEN;
X		    party_scanInit();
X		    for(pp = party_scanNext(); pp; pp = party_scanNext()){
X			if (!strcasecmp(pp->partyName, argv[arg])){
X			    dstlen = pp->partyIdentityLen;
X			    bcopy(pp->partyIdentity, dst, dstlen * sizeof(oid));
X			    break;
X			}
X		    }
X		    if (!pp){
X			if (!read_objid(argv[arg], dst, &dstlen)){
X			    printf("Invalid destination party: %s\n", argv[arg]);
X			    dstlen = 0;
X			    snmp_usage();
X			    exit_flag=1;
X			}
X		    }
X		} else if (version == 2 && contextlen == 0 && !trivialSNMPv2){
X		    contextlen = MAX_NAME_LEN;
X		    context_scanInit();
X		    for(cxp = context_scanNext(); cxp;
X			cxp = context_scanNext()){
X			if (!strcasecmp(cxp->contextName, argv[arg])){
X			    contextlen = cxp->contextIdentityLen;
X			    bcopy(cxp->contextIdentity, context,
X				  contextlen * sizeof(oid));
X			    break;
X			}
X		    }
X		    if (!cxp){
X			if (!read_objid(argv[arg], context, &contextlen)){
X			    printf("Invalid context: %s\n", argv[arg]);
X			    contextlen = 0;
X			    snmp_usage();
X			    exit_flag = 1;
X			}
X		    }
X		}
X	    }
X	    
X	    if (!hostname || (version < 1) || (version > 2)
X		|| (version == 1 && !community)
X		|| (version == 2 && (!srclen || !dstlen || !contextlen)
X		    && !trivialSNMPv2)){
X		snmp_usage();
X		exit_flag=1;
X	    }
X	    
X	    if (trivialSNMPv2){
X		if ((destAddr = inet_addr(hostname)) == -1){
X		    hp = gethostbyname(hostname);
X		    if (hp == NULL){
X			fprintf(stderr, "unknown host: %s\n", hostname);
X			exit(1);
X		    } else {
X			bcopy((char *)hp->h_addr, (char *)&destAddr,
X			      hp->h_length);
X		    }
X		}
X		srclen = dstlen = contextlen = MAX_NAME_LEN;
X		ms_party_init(destAddr, src, &srclen, dst, &dstlen,
X			      context, &contextlen);
X	    }
X
X	    if (clock_flag){
X		pp = party_getEntry(src, srclen);
X		if (pp){
X		    pp->partyAuthClock = srcclock;
X		    gettimeofday(&pp->tv, (struct timezone *)0);
X		    pp->tv.tv_sec -= pp->partyAuthClock;
X		}
X		pp = party_getEntry(dst, dstlen);
X		if (pp){
X		    pp->partyAuthClock = dstclock;
X		    gettimeofday(&pp->tv, (struct timezone *)0);
X		    pp->tv.tv_sec -= pp->partyAuthClock;
X		}
X	    }
X	    
X	    if(!exit_flag) {
X		cd2 = (t_cldat2 *)ckalloc(sizeof *cd2);
X		memset((void*)cd2,0,sizeof *cd2);
X		cd2->cd=cd;
X		cd2->sess = &cd2->ss;
X		cd2->sess->peername = hostname;
X		cd2->sess->timeout = 3000000;
X		if (version == 1){
X		    cd2->sess->version = SNMP_VERSION_1;
X		    cd2->sess->community = (u_char *)community;
X		    cd2->sess->community_len = strlen((char *)community);
X		} else if (version ==2){
X		    cd2->sess->version = SNMP_VERSION_2;
X		    cd2->sess->srcParty = src;
X		    cd2->sess->srcPartyLen = srclen;
X		    cd2->sess->dstParty = dst;
X		    cd2->sess->dstPartyLen = dstlen;
X		    cd2->sess->context = context;
X		    cd2->sess->contextLen = contextlen;
X		}
X		cd2->sess->retries = 4;
X		cd2->sess->timeout = 500000;
X		cd2->sess->authenticator = NULL;
X		snmp_synch_setup(cd2->sess);
X		cd2->sess = snmp_open(cd2->sess);
X		if(!cd2->sess)
X		    return Failed(interp,cd->where,"snmp_open");
X		Tcl_CreateCommand(interp,argv[sess_num],SessProc,cd2,0);
X		strcpy(cd2->name,argv[sess_num]);
X		return TCL_OK;
X	    } else{
X		return Error(interp, cd->where, "no args");
X	    }
X	}
X
X    return HUH(interp,cd->where);
}
X
X
X
static int
X    SessProc(cd2,interp,argc,argv)
t_cldat2 *cd2;
Tcl_Interp  *interp;
int argc;
char **argv;
{
X    int i;
X    
X    if(cd2->cd->debug)
X	{
X	    fprintf(stderr,"[SNMP]: SessProc %d ",argc);
X	    for(i=0;i<argc;i++)
X		fprintf(stderr,"{%s} ",argv[i]);
X	    fprintf(stderr,"\n");
X	}
X    
X    strcpy(cd2->where,"[SNMP] ");
X    strcat(cd2->where,argv[0]);
X    if(argc < 2)	
return Error(interp,cd2->where,"no args.");
X    argc--; argv++;
X    strcat(cd2->where," ");
X    strcat(cd2->where,argv[0]);
X    
X    IFW("get")
X	/*XX <sess> get {<oid>|<loid>}*/
X	{
X	    CHKNARG(2,2,cd2->where);
X	    return SnmpGet(interp,argc,argv,cd2);
X	}
X    IFW("getnext")
X	/*XX <sess> get {<oid>|<loid>}*/
X	{
X	    CHKNARG(2,2,cd2->where);
X	    return SnmpGetNext(interp,argc,argv,cd2);
X	}
X    IFW("set")
X	/*XX <sess> set {<oid>|<loid>}*/
X	{
X	    CHKNARG(2,2,cd2->where);
X	    return SnmpSet(interp,argc,argv,cd2);
X	}
X    IFW("gettable")
X	/*XX <sess> gettable {<oid>|<loid>} <proc> */
X	{
X	    CHKNARG(3,3,cd2->where);
X	    return SnmpGetTable(interp,argc,argv,cd2);
X	}
X    IFW("walk")
X	/*XX <sess> gettable {<oid>|<loid>} <proc> */
X	{
X	    CHKNARG(3,3,cd2->where);
X	    return SnmpWalk(interp,argc,argv,cd2);
X	}
X    IFW("bulk")
X	/*XX <sess> gettable {<oid>|<loid>} <proc> */
X	{
X	    CHKNARG(3,3,cd2->where);
X	    return SnmpBulk(interp,argc,argv,cd2);
X	}
X    IFW("val")
X	/*XX <sess> val [index] */
X	{
X	    CHKNARG(1,2,cd2->where);
X	    return SnmpVal(interp,argc,argv,cd2);
X	}
X    IFW("oid")
X	/*XX <sess> oid [index] */
X	{
X	    CHKNARG(1,2,cd2->where);
X	    return SnmpOid(interp,argc,argv,cd2);
X	}
X    IFW("prettyoid")
X	/*XX <sess> prettyoid [index] */
X	{
X	    CHKNARG(1,2,cd2->where);
SHAR_EOF
  : || echo 'restore of snmp2/snmptcl/tcl_snmp.c failed'
fi
echo 'End of snmp2 part 28'
echo 'File snmp2/snmptcl/tcl_snmp.c is continued in part 29'
echo 29 > _sharseq.tmp
exit 0