funcs.c

来自「RADIUS协议的认证计费服务」· C语言 代码 · 共 2,608 行 · 第 1/5 页

			"%s: FATAL: Couldn't find attribute %d(%ld)",
			func, attr, vendor_id);
		dumpcore = 1;		/* Force a core dump to find out why */
		abort ();
	}

	if ((attribute->flags & ATTR_ENCAPS) != 0)
	{
		av_flags |= VPF_ENCAPS;
	}

	ret = insert_attribute (attribute, auth, max, valptr,
				len, av_flags, veps, tag);

	if (ret <= 0)
	{
		logit (LOG_DAEMON, LOG_ALERT,
	"%s: insert_attribute(%s(%d), ..., %d, 0x%p, %d, 0x%x, %s) returns %d",
			func, attribute->name, attr, max, valptr, len,
			av_flags, vendor_list_toa (veps), ret);
	}

	return ret;
} /* end of attribute_out_tag () */

/******************************************************************************
 *
 *	Function: attribute_pw_out
 *
 *	Purpose: Directly add a password attribute (w/o an avpair)
 *		 to the output buffer
 *
 *	Returns: Length of output buffer.
 *
 *****************************************************************************/

int
attribute_pw_out (auth, maxlen, passwd, secret)

AUTH_HDR     *auth;
UINT4         maxlen;
char         *passwd;
char         *secret;

{
	int             i;
	int             len;
	int             pass;
	int             passes;
	int             secretlen;
	u_char         *ptr;
	u_char         *vector_ptr;
	u_char          digest[AUTH_VECTOR_LEN];
	u_char          md5buf[MAX_SECRET_LENGTH + AUTH_VECTOR_LEN];
	u_char          passbuf[AUTH_PASS_LEN];
	static char    *func = "attribute_pw_out";

	dprintf(3, (LOG_DAEMON, LOG_DEBUG, "%s: entered", func));

	if (auth->code == PW_EXTENDED_FORMAT)
	{
		vector_ptr = auth->vector;
	}
	else
	{
		vector_ptr = ((AUTH_HDR1 *) auth)->vector;
	}
		
	/* Encrypt the Password */
	len = strlen (passwd);
	if (len > AUTH_PASS_LEN)
	{
		len = AUTH_PASS_LEN;
	}

	memset ((char *) passbuf, '\0', AUTH_PASS_LEN);
	memcpy ((char *) passbuf, passwd, len);

	/* Calculate the MD5 Digest */
	secretlen = strlen (secret);
	strcpy ((char *) md5buf, secret);
	memcpy ((char *) md5buf + secretlen, vector_ptr, AUTH_VECTOR_LEN);

	/* Compute number of encryption passes needed */
	passes = MAX(1, (len + AUTH_VECTOR_LEN - 1) / AUTH_VECTOR_LEN);
	ptr = passbuf;
	for (pass = 0; pass < passes; pass++)
	{
		md5_calc (digest, md5buf, secretlen + AUTH_VECTOR_LEN);

		/* Xor the password into the MD5 digest */
		for (i = 0; i < AUTH_VECTOR_LEN; i++)
		{
			ptr[i] ^= digest[i];
		}
		memcpy ((char *) md5buf + secretlen, (char *) ptr,
							AUTH_VECTOR_LEN);
		ptr += AUTH_VECTOR_LEN;
	}

	memset (md5buf, 0, secretlen);
	pass = attribute_out (auth, maxlen, PW_USER_PASSWORD, 0, passbuf,
					ptr - passbuf, 0, (VENDOR_LIST *) NULL);
	if (pass <= 0)
	{
		logit (LOG_DAEMON, LOG_ALERT,
 "%s: attribute_out(..., %d, PW_USER_PASSWORD, 0, 0x%p, %d, NULL) returns %d)",
			func, maxlen, passbuf, (int) (ptr - passbuf), pass);
	}

	return pass;
} /* end of attribute_pw_out () */

/******************************************************************************
 *
 *	Function: authtype_toa
 *
 *	Purpose: Return a string representation of the authreq code.
 *
 *	Returns: pointer to static string.
 *
 *****************************************************************************/

char *
authtype_toa (code)

int             code;		/* code indicating authen, acct, etc. */

{
	static char      *typelist[] =
	{
		"invalid(0)",		/*  0 invalid */
		"access",		/*  1 PW_ACCESS_REQUEST */
		"accept",		/*  2 PW_ACCESS_ACCEPT */
		"reject",		/*  3 PW_ACCESS_REJECT */
		"acct-req",		/*  4 PW_ACCOUNTING_REQUEST */
		"acct-resp",		/*  5 PW_ACCOUNTING_RESPONSE */
		"acct-status",		/*  6 PW_ACCOUNTING_STATUS */
		"pw-request",		/*  7 PW_PASSWORD_REQUEST */
		"pw-ack",		/*  8 PW_PASSWORD_ACK */
		"pw-reject",		/*  9 PW_PASSWORD_REJECT */
		"acct-msg",		/* 10 PW_ACCOUNTING_MESSAGE */
		"access-challenge",	/* 11 PW_ACCESS_CHALLENGE */
		"status-server",	/* 12 PW_STATUS_SERVER */
		"status-client",	/* 13 PW_STATUS_CLIENT */
		"unknown(14)",		/* 14 *unknown* */
		"unknown(15)",		/* 15 *unknown* */
		"unknown(16)",		/* 16 *unknown* */
		"unknown(17)",		/* 17 *unknown* */
		"unknown(18)",		/* 18 *unknown* */
		"unknown(19)",		/* 19 *unknown* */
		"unknown(20)",		/* 20 *unknown* */
		"resource-free-req",	/* 21 PW_RESOURCE_FREE_REQ */
		"resource-free-resp",	/* 22 PW_RESOURCE_FREE_RESP */
		"resource-query-req",	/* 23 PW_RESOURCE_QUERY_REQ */
		"resource-query-resp",  /* 24 PW_RESOURCE_QUERY_RESP */
		"unknown(25)",		/* 25 *unknown* */
		"nas-reb-req",		/* 26 PW_NAS_REB_REQ */
		"nas-reb-resp",		/* 27 PW_NAS_REB_RESP */
		"unknown(28)",		/* 28 *unknown* */
		"unknown(29)",		/* 29 *unknown* */
		"unknown(30)",		/* 30 *unknown* */
		"ascend-term-sess",	/* 31 PW_TERMINATE_SESSION */
		"ascend-pw-exp",	/* 32 PW_PASSWORD_EXPIRED */
		"ascend-ev-req",	/* 33 PW_ASCEND_EVENT_REQUEST */
		"ascend-ev-resp",	/* 34 PW_ASCEND_EVENT_RESPONSE */
		"unknown(35)",		/* 35 *unknown* */
		"unknown(36)",		/* 36 *unknown* */
		"unknown(37)",		/* 37 *unknown* */
		"unknown(38)",		/* 38 *unknown* */
		"unknown(39)",		/* 39 *unknown* */
		"unknown(40)",		/* 40 *unknown* */
		"unknown(41)",		/* 41 *unknown* */
		"unknown(42)",		/* 42 *unknown* */
		"unknown(43)",		/* 43 *unknown* */
		"unknown(44)",		/* 44 *unknown* */
		"unknown(45)",		/* 45 *unknown* */
		"unknown(46)",		/* 46 *unknown* */
		"unknown(47)",		/* 47 *unknown* */
		"unknown(48)",		/* 48 *unknown* */
		"unknown(49)",		/* 49 *unknown* */
		"ascend-ip-alloc",	/* 50 PW_ASCEND_RADIPA_ALLOCATE */
		"ascend-ip-rel",	/* 51 PW_ASCEND_RADIPA_RELEASE */
	};

	static char      *v2_typelist[] =
	{
		"v2-unknown(256)",	/* 256 *unknown* */
		"v2-unknown(257)",	/* 257 *unknown* */
		"v2-unknown(258)",	/* 258 *unknown* */
		"v2-unknown(259)",	/* 259 *unknown* */
		"v2-unknown(260)",	/* 260 *unknown* */
		"v2-resource-free-req",	/* 261 PW_RESOURCE_FREE_REQ */
		"v2-resource-free-resp",/* 262 PW_RESOURCE_FREE_RESP */
		"v2-resource-query-req", /* 263 PW_RESOURCE_QUERY_REQ */
		"v2-resource-query-resp", /* 264 PW_RESOURCE_QUERY_RESP */
		"v2-resource-reclaim-req", /* 265 PW_RESOURCE_RECLAIM_REQ */
		"v2-resource-reclaim-resp", /* 266 PW_RESOURCE_RECLAIM_RESP */
		"v2-nas-reb-req",	/* 267 PW_NAS_REB_REQ */
		"v2-nas-reb-resp",	/* 268 PW_NAS_REB_RESP */
		"v2-change-filter-req",	/* 304 PW_CHANGE_FILTER_REQ */
		"v2-change-filter-ack",	/* 305 PW_CHANGE_FILTER_ACK */
		"v2-change-filter-nak",	/* 306 PW_CHANGE_FILTER_NAK */
		"v2-access-error",	/* 402 PW_ACCESS_ERROR */
		"v2-acct-error",	/* 405 PW_ACCOUNTING_ERROR */
	};


	static char      unknown[20];
	static char     *func = "authtype_toa";

	dprintf(4, (LOG_DAEMON, LOG_DEBUG, "%s: entered", func));

	if ((code <= 0) || ((sizeof (typelist) / sizeof (typelist[0])) <= code))
	{
		if (code == PW_FORWARDING)
		{
			return "forwarding";
		}
		else if (code >= 256)
		{
			if ((sizeof (v2_typelist) / sizeof (v2_typelist[0]))
								> (code - 256))
			{
				return v2_typelist[code-256];
			}
		}

		sprintf (unknown, "invalid(%d)", code);
		return unknown;
	}

	return typelist[code];
} /* end of authtype_toa () */

#define	AUTH_VECTORTOA_BUFS	20

/*************************************************************************
 *
 *	Function: auth_vectortoa
 *
 *	Purpose: Produce hexadecimal dump of authreq->vector.
 *
 *	Returns: pointer to auth_vector hex buffer.
 *
 *************************************************************************/

char *
auth_vectortoa (authvec, sws)

u_char         *authvec;
int             sws;

{
	int             i;
	static char     buffers[AUTH_VECTORTOA_BUFS][(3*AUTH_VECTOR_LEN)+1];
	static int      ndx = 0;
	char           *buffer = buffers[ndx];
	char           *put = buffer;

	ndx++;

	if (ndx >= AUTH_VECTORTOA_BUFS)
	{
		ndx = 0;
	}

	for (i = 0; i <= AUTH_VECTOR_LEN; i++)
	{
		if ((sws & 0x01) && ((i % 4) == 3))
		{
			*put = ' ';
			put++;
		}

		sprintf (put, "%2.2X", *authvec);
		authvec++;
		put += 2;
	}
	*put = '\0';

	return (buffer);
} /* end of auth_vectortoa () */

/******************************************************************************
 *
 *	Function: avpair_add
 *
 *	Purpose: Add an attribute-value pair to the given list.
 *
 *	Returns: pointer to added a/v pair upon success,
 *		 NULL pointer, upon failure.
 *
 *	Remarks: Always appends the new pair to the end of the list.
 *
 *****************************************************************************/

VALUE_PAIR *
avpair_add (list, attrid, pval, len)

VALUE_PAIR    **list;	/* A list of attribute-value pairs. */
int             attrid;	/* Attribute id number. */
void           *pval;	/* Pointer to value. */
int             len;	/* for strings: */
			/*    len < 0  ==> null-terminated ASCII string */
			/*    len == 0 ==> this is a zero length string (!) */
			/*    len > 0  ==> len is length of raw binary data */
			/* for non-strings: */
			/*    len == 0 ==> just plain data, just gets copied */
			/*    len > 0  ==> convert data from network ... */
			/*		   ... representation before copying */

{
	DICT_ATTR      *pda;
	static char    *func = "avpair_add";

	dprintf(3, (LOG_DAEMON, LOG_DEBUG, "%s: entered", func));

	if ((pda = dict_attrget (attrid, VC_RADIUS)) == (DICT_ATTR *) NULL)
	{
		logit (LOG_DAEMON, LOG_ERR,
			"%s: Unknown standard attribute %d", func, attrid);

		return NULL_VP;
	}

	if (pda->type == PW_TYPE_TAG_INT)
	{
		logit (LOG_DAEMON, LOG_ALERT,
			"%s: Doesn't support type tag-int for %s",
			func, pda->name);
		return (NULL_VP);
	}
	else
	{
		if (pda->type == PW_TYPE_TAG_STR)
		{
			logit (LOG_DAEMON, LOG_ALERT,
				"%s: Doesn't support type tag-str for %s",
				func, pda->name);
			return (NULL_VP);
		}
	}

	return avpair_add_attr_tag (list, pda, pval, len, 0);
} /* end of avpair_add */

/******************************************************************************
 *
 *	Function: avpair_add_attr_tag
 *
 *	Purpose: Add a Vendor Specific attribute-value pair to the given list.
 *
 *	Returns: pointer to added a/v pair upon success,
 *		 NULL pointer, upon failure.
 *
 *	Remarks: Always appends the new pair to the end of the list.
 *
 *****************************************************************************/

VALUE_PAIR *
avpair_add_attr_tag (list, attr, pval, len, tag)

VALUE_PAIR    **list;	 /* A list of attribute-value pairs. */
DICT_ATTR      *attr;	 /* Dictionary entry for attribute */
void           *pval;	 /* Pointer to value. */
int             len;	 /* for strings: */
			 /*    len < 0  ==> null-terminated ASCII string */
			 /*    len == 0 ==> this is a zero length string (!) */
			 /*    len > 0  ==> len is length of raw binary data */
			 /* for non-strings: */
			 /*    len == 0 ==> just plain data, just gets copied */
			 /*    len > 0  ==> convert data from network ... */
			 /*		   ... representation before copying */
int             tag;	 /* The tag for tagged attributes */

{
	VALUE_PAIR     *vp;

#ifdef BINARY_FILTERS
	radgenfilter   *gen;
	radfilter      *last;
	radfilter      *this;
#endif	/* BINARY_FILTERS */

	static char    *func = "avpair_add_attr_tag";

	dprintf(3, (LOG_DAEMON, LOG_DEBUG, "%s: entered", func));

#ifdef PW_TYPE_FILTER_BINARY
	if (attr->value == PW_TYPE_FILTER_BINARY) /* do sanity checking */
	{
		this = (radfilter *) pval;
		if (this->type == FILTER_GENERIC_TYPE)
		{
			vp = get_last_vp_vend (*list, attr->value,
						attr->vendor_id);

			if (vp != NULL_VP)
			{
				last = (radfilter *) vp->strvalue;

				if ((last->type != FILTER_GENERIC_TYPE) ||
					(len <= 0) ||
					(last->input != this->input) ||
					(last->forward != this->forward))
				{
					gen = &last->u.generic;
					gen->more = FALSE;
					logit (LOG_DAEMON, LOG_ERR,
	"%s: 'more' of previous generic filter entry doesn't match this one %s",
						func, binary_vtoa (this));
				}
			}
		}
	}
#endif	/* PW_TYPE_FILTER_BINARY */

	vp = avpair_assign_tag (attr, pval, len, tag);

	if (debug_flag >= 2)
	{
		debug_pair (stdout, vp);
	}

	if (list != (VALUE_PAIR **) NULL && vp != NULL_VP)
	{
		insert_vp (list, NULL_VP, vp);
	}

	return vp;
} /* end of avpair_add_attr_tag () */

/******************************************************************************
 *
 *	Function: avpair_add_tag
 *
 *	Purpose: Add an attribute-value pair to the given list.
 *
 *	Returns: pointer to added a/v pair upon success,
 *		 NULL pointer, upon failure.
 *
 *	Remarks: Always appends the new pair to the end of the list.
 *
 *****************************************************************************/

VALUE_PAIR *
avpair_add_tag (list, attrid, pval, len, tag)

VALUE_PAIR    **list;	/* A list of attribute-value pairs. */
int             attrid;	/* Attribute id number. */
void           *pval;	/* Pointer to value. */
int             len;	/* for strings: */
			/*    len < 0  ==> null-terminated ASCII string */
			/*    len == 0 ==> this is a zero length string (!) */
			/*    len > 0  ==> len is length of raw binary data */
			/* for non-strings: */
			/*    len == 0 ==> just plain data, just gets copied */
			/*    len > 0  ==> convert data from network ... */
			/*		   ... representation before copying */
int             tag;	/* The tag for tagged attributes */

{
	DICT_ATTR      *pda;
	static char    *func = "avpair_add_tag";

	dprintf(3, (LOG_DAEMON, LOG_DEBUG, "%s: entered", func));

	if ((pda = dict_attrget (attrid, VC_RADIUS)) == (DICT_ATTR *) NULL)
	{
		logit (LOG_DAEMON, LOG_ERR,
			"%s: Unknown standard attribute %d", func, attrid);

		return NULL_VP;
	}

	return avpair_add_attr_tag (list, pda, pval, len, tag);
} /* end of avpair_add_tag */

/******************************************************************************
 *
 *	Function: avpair_add_vend
 *
 *	Purpose: Add a Vendor Specific attribute-value pair to the given list.
 *
 *	Returns: pointer to added a/v pair upon success,
 *		 NULL pointer, upon failure.
 *
 *	Remarks: Always appends the new pair to the end of the list.
 *
 *****************************************************************************/

VALUE_PAIR *
avpair_add_vend (list, attrid, pval, len, vend_id)

VALUE_PAIR    **list;	 /* A list of attribute-value pairs. */
int             attrid;	 /* Attribute id number. */
void           *pval;	 /* Pointer to value. */
int             len;	 /* for strings: */
			 /*    len < 0  ==> null-terminated ASCII string */
			 /*    len == 0 ==> this is a zero length string (!) */
			 /*    len > 0  ==> len is length of raw binary data */
			 /* for non-strings: */
			 /*    len == 0 ==> just plain data, just gets copied */
			 /*    len > 0  ==> convert data from network ... */
			 /*		   ... representation before copying */
UINT4           vend_id; /* Vendor ID */

{
	DICT_ATTR      *pda;
	static char    *func = "avpair_add_vend";

	dprintf(3, (LOG_DAEMON, LOG_DEBUG, "%s: entered", func));

	if ((pda = dict_attrget (attrid, vend_id)) == (DICT_ATTR *) NULL)
	{
		logit (LOG_DAEMON, LOG_ERR,
			"%s: Unknown vendor %ld attribute %d",
			func, vend_id, attrid);

		return NULL_VP;
	}