snmp.c

ftam等标准协议服务器和客户端的源代码。

    if (snmp_id >= 0x7fffffff)
	snmp_id = 0;
    snmp_id++;

    parm -> request__id = sr -> r_id = snmp_id;
    parm -> variable__bindings = sr -> r_bindings;

    if (sr -> r_msg)
	free_SNMP_Message (sr -> r_msg), sr -> r_msg = NULL;
    if (sr -> r_pe)
	pe_free (sr -> r_pe), sr -> r_pe = NULL;

    return encode_SNMP_Message (&sr -> r_pe, 1, 0, NULLCP, &msgs);
}

/*    SET */

void	snmp_set ()
{
    int	    gotone,
	    result,
	    retries,
	    status = -1;
    struct type_SNMP_Message *msg = &msgs;
    register struct type_SNMP_PDU *parm = msg -> data -> un.get__request;
    register struct type_SNMP_VarBind *v =
					parm -> variable__bindings -> VarBind;
    PE	    pe = NULLPE,
	    p = NULLPE,
	   *pep = NULLPEP;
    OID	    oid;
    NODE   *ptr = SET_node,
	   *value = NULL;
    OT	    ot = (OT) ptr -> magic;

    SET_node = NULL;
    if (snmp_ready (1) == NOTOK)
	goto out;

    parm -> request__id = snmp_id;
    if (v -> name)
	free_SNMP_ObjectName (v -> name), v -> name = NULL;

    if (!SET_inst) {
	if (ot -> ot_getfnx || snmp_scalars_as_arrays) {
	    register struct snmp_search *s;

	    for (s = tail; s; s = s -> s_prev) {
		register struct snmp_req *sr;

		if (ot -> ot_name -> oid_nelem
			   != (oid = s -> s_parent -> ot_name) -> oid_nelem + 1
		        || bcmp ((char *) ot -> ot_name -> oid_elements,
				 (char *) oid -> oid_elements,
				 oid -> oid_nelem
				         * sizeof ot -> ot_name -> oid_elements[0]))
		    continue;
		for (sr = s -> s_reqs; sr -> r_bindings; sr++) {
		    register struct type_SNMP_VarBindList *vp;

		    for (vp = sr -> r_bindings; vp; vp = vp -> next) {
			register struct type_SNMP_VarBind *vv;

			if (ot -> ot_name -> oid_nelem
			        >= (vv = vp -> VarBind) -> name -> oid_nelem)
			    fatal ("snmp_get: internal error");
			if (bcmp ((char *) vv -> name -> oid_elements,
				  (char *) ot -> ot_name -> oid_elements,
				  ot -> ot_name -> oid_nelem
				      * sizeof ot -> ot_name 
							-> oid_elements[0]))
			    continue;

			if ((oid = v -> name = oid_cpy (vv -> name)) == NULL)
			    goto no_mem_for_inst;
			pep = &vv -> value;
			goto set_value;
		    }
		}
		status = int_SNMP_error__status_noSuchName;
		goto out;
	    }
	    if (ot -> ot_getfnx) {
		snmp_diag (NULLCP,
			   "can't use SNMP array variable as scalar unless within for-in construct");
		goto out;
	    }
	}

	if ((oid = v -> name = oid_extend (ot -> ot_name, 1)) == NULL) {
no_mem_for_inst: ;
	    snmp_diag (NULLCP, "oid_extend: out of memory");
	    goto out;
	}
	v -> name -> oid_elements[v -> name -> oid_nelem - 1] = 0;
    }
    else {
	register int	i;
	register unsigned int *ip,
			      *jp;
	char   *instname = force_string (SET_inst) -> stptr;
	OID	inst = str2oid (instname);

	if (inst == NULL) {
	    snmp_diag (NULLCP, "str2oid: bad instance identifier \"%s\"",
		       instname);
	    goto out;
	}
	if ((oid = v -> name = oid_extend (ot -> ot_name, inst -> oid_nelem))
	        == NULL)
	    goto no_mem_for_inst;
	ip = oid -> oid_elements + oid -> oid_nelem - inst -> oid_nelem;
	jp = inst -> oid_elements;
	for (i = inst -> oid_nelem; i > 0; i--)
	    *ip++ = *jp++;
    }
set_value: ;

    if ((*ot -> ot_syntax -> os_encode) (ptr -> var_value, &pe) == NOTOK) {
	snmp_diag (NULLCP, "encode error for variable \"%s\": %s",
		 oid2ode (v -> name), PY_pepy);
	goto out;
    }

    msgs.data -> offset = type_SNMP_PDUs_set__request;
    p = v -> value, v -> value = pe, pe = NULL;
    result = encode_SNMP_Message (&pe, 1, 0, NULLCP, msg);
    msgs.data -> offset = type_SNMP_PDUs_get__request;
    pe_free (v -> value), v -> value = p, p = NULLPE;
    if (result == NOTOK) {
	snmp_diag (NULLCP, "encode_SNMP_Message: %s", PY_pepy);
	goto out;
    }

    msg = NULL, gotone = 0;
    for (retries = snmp_retries; retries > 0; ) {
	int	len;
	fd_set	rfds;

	if (debug > 1)
	    print_SNMP_Message (pe, 1, NULLIP, NULLVP, NULLCP);
	len = ps -> ps_byteno;
	if (pe2ps (ps, pe) == NOTOK) {
	    snmp_diag (NULLCP, "pe2ps: %s", ps_error (ps -> ps_errno));
	    goto error_x;
	}
	if (debug > 0 && (len = ps -> ps_byteno - len) > 484)
	    fprintf (stderr, "sent message of %d octets\n", len);

	FD_ZERO (&rfds);
	FD_SET (snmp_fd, &rfds);

	switch (xselect (snmp_fd + 1, &rfds, NULLFD, NULLFD, snmp_timeout)) {
	    case NOTOK:
	        snmp_diag ("failed", "xselect");
		goto error_x;

	    default:
		if (FD_ISSET (snmp_fd, &rfds))
		    break;
		/* else fall... */
	    case OK:
		if (debug > 0)
		    fprintf (stderr, "timeout...\n");
		retries--;
		continue;
	}

	if ((p = ps2pe (ps)) == NULLPE) {
	    snmp_diag (NULLCP, "ps2pe: %s", ps_error (ps -> ps_errno));
	    goto error_x;
	}
	if (decode_SNMP_Message (p, 1, NULLIP, NULLVP, &msg) == NOTOK) {
	    snmp_diag (NULLCP, "decode_SNMP_Message: %s", PY_pepy);
	    goto out;
	}
	if (debug > 1)
	    print_SNMP_Message (p, 1, NULLIP, NULLVP, NULLCP);

	if (msg -> data -> offset != type_SNMP_PDUs_get__response) {
	    snmp_diag (NULLCP, "unexpected message type %d",
		       msg -> data -> offset);
	    goto out;
	}

	if ((parm = msg -> data -> un.get__response) -> request__id == snmp_id)
	    break;

	if (debug > 0)
	    fprintf (stderr, "bad ID (got %ld, wanted %ld)\n",
		     (long) parm -> request__id, (long) snmp_id);

	if (msg)
	    free_SNMP_Message (msg), msg = NULL;
	if (p)
	    pe_free (p), p = NULLPE;

	gotone++;
    }
    if (retries <= 0) {
	snmp_diag (NULLCP,
		   "no %sresponse within %d retries of %s%d second%s each",
		   gotone ? "acceptable " : "", snmp_retries + gotone,
		   gotone ? "upto " : "",
		   snmp_timeout, snmp_timeout != 1 ? "s" : "");
	goto out;
    }

    if ((status = parm -> error__status) != int_SNMP_error__status_noError) {
	char   *cp = snmp_variable (parm, parm -> error__index);

	snmp_diag (NULLCP, cp ? "%s at position %d (%s)" : "%s at position %d",
		   snmp_error (status), parm -> error__index, cp);
	goto out;
    }

    if (parm -> variable__bindings == NULL
	    || (v = parm -> variable__bindings -> VarBind) == NULL) {
	snmp_diag (NULLCP, "missing variable in response");
	goto out;
    }
    if (debug > 0 && parm -> variable__bindings -> next)
	fprintf (stderr, "too many responses starting with: %s\n",
		 oid2ode (parm -> variable__bindings -> next -> VarBind -> name));

    if (oid_cmp (oid, v -> name)) {
	char    buffer[BUFSIZ];

	(void) strcpy (buffer, oid2ode (v -> name));
	snmp_diag (NULLCP, "wrong variable returned (got %s, wanted %s)",
		 buffer, oid2ode (oid));
	goto out;
    }
		 
/* needed in case of x = y = value, where "y" is an SNMP variable */
    if ((*ot -> ot_syntax -> os_decode) (&value, v -> value) == NOTOK) {
	snmp_diag (NULLCP, "decode error for variable \"%s\": %s",
		 oid2ode (v -> name), PY_pepy);
	goto out;
    }
    if (pep) {
	pe_free (*pep);
	*pep = v -> value, v -> value = NULL;
    }

    goto out;

error_x: ;
    if (ps)
	ps_free (ps), ps = NULLPS;
    if (snmp_fd != NOTOK)
	(void) close_udp_socket (snmp_fd), snmp_fd = NOTOK;

out: ;
    if (msg && msg != &msgs)
	free_SNMP_Message (msg);
    if (p)
	pe_free (p);
    if (pe)
	pe_free (pe);

    deref = ptr -> var_value;
    do_deref ();
/* needed in case of x = y = value, where "y" is an SNMP variable */
    ptr -> var_value = value ? value : Nnull_string;

    assign_number (&ERROR_node -> var_value, (AWKNUM) status);

    if (SET_inst) {
	deref = SET_inst;
	do_deref ();
	SET_inst = NULL;
    }
}

/*    ENCODE */

static int  e_integer (x, pe)
NODE   *x;
PE     *pe;
{
    if ((*pe = int2prim ((integer) force_number (x))) == NULLPE) {
	(void) strcpy (PY_pepy, "int2prim failed");
	return NOTOK;
    }

    return OK;
}


extern char 	hex2nib[];

static int  e_octets (x, pe)
NODE   *x;
PE     *pe;
{
    int	    i;
    register char *cp,
		  *ep;
    char   *tmp = force_string (x) -> stptr;
    PE	    p;
    PElementData d;

    if ((i = strlen (tmp)) == 0
	    || i % 3 != 2
	    || !isxdigit (tmp[0])
	    || !isxdigit (tmp[1])
	    || !isxdigit (tmp[i - 2])
	    || !isxdigit (tmp[i - 1]))
	return e_display (x, pe);
    for (cp = tmp + 3, ep = tmp + i - 3; cp < ep; cp += 3)
	if (!isxdigit (cp[0]) || !isxdigit (cp[1]) || cp[2] != ':')
	    return e_display (x, pe);

    if ((p = pe_alloc (PE_CLASS_UNIV, PE_FORM_PRIM, PE_PRIM_OCTS)) == NULL) {
	(void) strcpy (PY_pepy, "pe_alloc failed");
	return NOTOK;
    }
    if ((d = p -> pe_prim = PEDalloc (p -> pe_len = (i / 3) + 1)) == NULL) {
	(void) strcpy (PY_pepy, "PEDalloc failed");
	pe_free (p);
	return NOTOK;
    }
    for (ep = (cp = tmp) + i; cp < ep; cp += 3)
	*d++ = (hex2nib[cp[0] & 0x7f] << 4) | (hex2nib[cp[1] & 0x7f]);

    *pe = p;
    return OK;
}


static int  e_display (x, pe)
NODE   *x;
PE     *pe;
{
    char   *tmp = force_string (x) -> stptr;

    if ((*pe = str2prim (tmp, strlen (tmp), PE_CLASS_UNIV, PE_PRIM_OCTS))
	    == NULLPE) {
	(void) strcpy (PY_pepy, "str2prim failed");
	return NOTOK;
    }

    return OK;
}


static int  e_objectID (x, pe)
NODE   *x;
PE     *pe;
{
    char   *tmp = force_string (x) -> stptr;
    OID	    oid = str2oid (tmp);

    if (oid == NULLOID) {
#ifndef	original
bad_oid: ;
#endif
	(void) sprintf (PY_pepy, "str2oid: bad instance identifier \"%s\"",
			tmp);
	return NOTOK;
    }
#ifndef	original
    if (oid -> oid_elements[0] > 2
	    || (oid -> oid_nelem > 1
		    && oid -> oid_elements[0] < 2
		    && oid -> oid_elements[1] < 39))
	goto bad_oid;
#endif
    
    if ((*pe = oid2prim (oid)) == NULLPE) {
	(void) strcpy (PY_pepy, "oid2prim failed");
	return NOTOK;
    }

    return OK;
}


/* ARGSUSED */

static int  e_null (x, pe)
NODE   *x;
PE     *pe;
{
    if ((*pe = pe_alloc (PE_CLASS_UNIV, PE_FORM_PRIM, PE_PRIM_NULL))
	    == NULLPE) {
	(void) strcpy (PY_pepy, "pe_alloc failed");
	return NOTOK;
    }

    return OK;
}


static int  e_ipaddr (x, pe)
NODE   *x;
PE     *pe;
{
    char   *tmp = force_string (x) -> stptr;
    struct hostent *hp;
    struct sockaddr_in lo_socket;
    register struct sockaddr_in *lsock = &lo_socket;

    if (!(hp = gethostbystring (tmp))) {
	(void) sprintf (PY_pepy, "invalid IP-address: \"%s\"", tmp);
	return NOTOK;
    }
    bzero ((char *) lsock, sizeof *lsock);
    lsock -> sin_family = hp -> h_addrtype;
    inaddr_copy (hp, lsock);
    
    if ((*pe = str2prim ((char *) &lsock -> sin_addr, 4, PE_CLASS_APPL, 0))
	    == NULLPE) {
	(void) strcpy (PY_pepy, "str2prim failed");
	return NOTOK;
    }

    return OK;
}


extern	PE ulong2prim ();

static int  e_ulong (x, pe, id)
NODE   *x;
PE     *pe;
PElementID id;
{
    if ((*pe = ulong2prim ((u_long) force_number (x), PE_CLASS_APPL, id))
	    == NULL) {
	(void) strcpy (PY_pepy, "ulong2prim failed");
	return NOTOK;
    }

    return OK;
}


static int  e_counter (x, pe)
NODE   *x;
PE     *pe;
{
    return e_ulong (x, pe, 1);
}


static int  e_gauge (x, pe)
NODE   *x;
PE     *pe;
{
    return e_ulong (x, pe, 2);
}


static int  e_timeticks (x, pe)
NODE   *x;
PE     *pe;
{
    return e_ulong (x, pe, 3);
}


static int  e_clnpaddr (x, pe)
NODE   *x;
PE     *pe;
{
    if (e_octets (x, pe) == NOTOK)
	return NOTOK;
    (*pe) -> pe_class = PE_CLASS_APPL, (*pe) -> pe_id = 5;

    return OK;
}

/*    DECODE */

static NODE *make_octet_node (base, len)
char   *base;
int	len;
{
    register char *bp,
		  *cp,
		  *ep;
    char   *s = "";
    register NODE *r;

    r = newnode (Node_val);
    emalloc (r -> stptr, char *, len * 3 + 1, "make_octet_node");
    bp = r -> stptr;
    for (ep = (cp = base) + len; cp < ep; cp++, s = ":") {
	(void) sprintf (bp, "%s%02x", s, *cp & 0xff);
	bp += strlen (bp);
    }
    *bp = NULL;		/* in case len == 0 */
    r -> stlen = bp - r -> stptr;
    r -> stref = 1;