radiud.mp.c

国际标准协议的

/*Just for test*/
/*-------
sprintf(msg,"Auth:1 result - %d\n",result);
msg[127]='\0';
log_err(msg);
-------*/
if(result == 0) {
	/* Check the simultaneous user */
	if(check_simultaneous_file(authreq->request) != 0) {	
	/*-------
	if(check_simultaneous_cache(authreq->request) != 0) {
	-------*/
		result = -1;
	}	
}
/*Just for test*/
/*------
sprintf(msg,"Auth:2 result - %d\n",result);
msg[127]='\0';
log_err(msg);
------*/
	if(result != 0) {
		send_reject(authreq, user_msg, activefd);
	}
	else {
		send_accept(authreq, user_reply, user_msg, activefd);
	}

	pairfree(authreq->request);
	memset(authreq, 0, sizeof(AUTH_REQ));
	free(authreq);
	pairfree(user_check);
	pairfree(user_reply);
	return;
}/* end of if(authreq->proxy_state) */
}

/*************************************************************************
 *
 *	Function: send_reject
 *
 *	Purpose: Reply to the request with a REJECT.  Also attach
 *		 any user message provided.
 *
 *************************************************************************/

send_reject(authreq, msg, activefd)
AUTH_REQ	*authreq;
char		*msg;
int		activefd;
{
	AUTH_HDR		*auth;
	struct	sockaddr	saremote;
	struct	sockaddr_in	*sin;
	char			*ip_hostname();
	char			digest[AUTH_VECTOR_LEN];
	int			secretlen;
	int			total_length;
	u_char			*ptr;
	int			len;

	auth = (AUTH_HDR *)send_buffer;

	/* Build standard response header */
	if(authreq->code == PW_PASSWORD_REQUEST) {
		auth->code = PW_PASSWORD_REJECT;
	}
	else {
		auth->code = PW_AUTHENTICATION_REJECT;
	}
	auth->id = authreq->id;
	memcpy(auth->vector, authreq->vector, AUTH_VECTOR_LEN);
	total_length = AUTH_HDR_LEN;

	/* Append the user message */
	if(msg != (char *)NULL) {
		len = strlen(msg);
		if(len > 0 && len < AUTH_STRING_LEN) {
			ptr = auth->data;
			*ptr++ = PW_PORT_MESSAGE;
			*ptr++ = len + 2;
			memcpy(ptr, msg, len);
			ptr += len;
			total_length += len + 2;
		}
	}

	/* Set total length in the header */
	auth->length = htons(total_length);

	/* Calculate the response digest */
	secretlen = strlen(authreq->secret);
	memcpy(send_buffer + total_length, authreq->secret, secretlen);
	md5_calc(digest, (char *)auth, total_length + secretlen);
	memcpy(auth->vector, digest, AUTH_VECTOR_LEN);
	memset(send_buffer + total_length, 0, secretlen);

	sin = (struct sockaddr_in *) &saremote;
        memset ((char *) sin, '\0', sizeof (saremote));
	sin->sin_family = AF_INET;
	sin->sin_addr.s_addr = htonl(authreq->ipaddr);
	sin->sin_port = htons(authreq->udp_port);

	DEBUG("Sending Reject of id %d to %lx (%s)\n",
		authreq->id, (u_long)authreq->ipaddr,
		ip_hostname(authreq->ipaddr));
	
	/* Send it to the user */
	sendto(activefd, (char *)auth, (int)total_length, (int)0,
			(struct sockaddr *) &saremote, sizeof(struct sockaddr_in));
}

/*************************************************************************
 *
 *	Function: send_challenge
 *
 *	Purpose: Reply to the request with a CHALLENGE.  Also attach
 *		 any user message provided and a state value.
 *
 *************************************************************************/

send_challenge(authreq, msg, state, activefd)
AUTH_REQ	*authreq;
char		*msg;
char		*state;
int		activefd;
{
	AUTH_HDR		*auth;
	struct	sockaddr_in	saremote;
	struct	sockaddr_in	*sin;
	char			*ip_hostname();
	char			digest[AUTH_VECTOR_LEN];
	int			secretlen;
	int			total_length;
	u_char			*ptr;
	int			len;

	auth = (AUTH_HDR *)send_buffer;

	/* Build standard response header */
	auth->code = PW_ACCESS_CHALLENGE;
	auth->id = authreq->id;
	memcpy(auth->vector, authreq->vector, AUTH_VECTOR_LEN);
	total_length = AUTH_HDR_LEN;

	/* Append the user message */
	if(msg != (char *)NULL) {
		len = strlen(msg);
		if(len > 0 && len < AUTH_STRING_LEN) {
			ptr = auth->data;
			*ptr++ = PW_PORT_MESSAGE;
			*ptr++ = len + 2;
			memcpy(ptr, msg, len);
			ptr += len;
			total_length += len + 2;
		}
	}

	/* Append the state info */
	if((state != (char *)NULL) && (strlen(state) > 0)) {
		len = strlen(state);
		*ptr++ = PW_STATE;
		*ptr++ = len + 2;
		memcpy(ptr, state, len);
		ptr += len;
		total_length += len + 2;
	}

	/* Set total length in the header */
	auth->length = htons(total_length);

	/* Calculate the response digest */
	secretlen = strlen(authreq->secret);
	memcpy(send_buffer + total_length, authreq->secret, secretlen);
	md5_calc(digest, (char *)auth, total_length + secretlen);
	memcpy(auth->vector, digest, AUTH_VECTOR_LEN);
	memset(send_buffer + total_length, 0, secretlen);

	sin = (struct sockaddr_in *) &saremote;
        memset ((char *) sin, '\0', sizeof (saremote));
	sin->sin_family = AF_INET;
	sin->sin_addr.s_addr = htonl(authreq->ipaddr);
	sin->sin_port = htons(authreq->udp_port);

	DEBUG("Sending Challenge of id %d to %lx (%s)\n",
		authreq->id, (u_long)authreq->ipaddr,
		ip_hostname(authreq->ipaddr));
	
	/* Send it to the user */
	sendto(activefd, (char *)auth, (int)total_length, (int)0,
			(struct sockaddr *) &saremote, sizeof(struct sockaddr_in));
}

/*************************************************************************
 *
 *	Function: send_pwack
 *
 *	Purpose: Reply to the request with an ACKNOWLEDGE.
 *		 User password has been successfully changed.
 *
 *************************************************************************/

send_pwack(authreq, activefd)
AUTH_REQ	*authreq;
int		activefd;
{
	AUTH_HDR		*auth;
	struct	sockaddr	saremote;
	struct	sockaddr_in	*sin;
	char			*ip_hostname();
	char			digest[AUTH_VECTOR_LEN];
	int			secretlen;

	auth = (AUTH_HDR *)send_buffer;

	/* Build standard response header */
	auth->code = PW_PASSWORD_ACK;
	auth->id = authreq->id;
	memcpy(auth->vector, authreq->vector, AUTH_VECTOR_LEN);
	auth->length = htons(AUTH_HDR_LEN);

	/* Calculate the response digest */
	secretlen = strlen(authreq->secret);
	memcpy(send_buffer + AUTH_HDR_LEN, authreq->secret, secretlen);
	md5_calc(digest, (char *)auth, AUTH_HDR_LEN + secretlen);
	memcpy(auth->vector, digest, AUTH_VECTOR_LEN);
	memset(send_buffer + AUTH_HDR_LEN, 0, secretlen);

	sin = (struct sockaddr_in *) &saremote;
        memset ((char *) sin, '\0', sizeof (saremote));
	sin->sin_family = AF_INET;
	sin->sin_addr.s_addr = htonl(authreq->ipaddr);
	sin->sin_port = htons(authreq->udp_port);

	DEBUG("Sending PW Ack of id %d to %lx (%s)\n",
		authreq->id, (u_long)authreq->ipaddr,
		ip_hostname(authreq->ipaddr));
	
	/* Send it to the user */
	sendto(activefd, (char *)auth, (int)AUTH_HDR_LEN, (int)0,
			&saremote, sizeof(struct sockaddr_in));
}

/*************************************************************************
 *
 *	Function: send_accept
 *
 *	Purpose: Reply to the request with an ACKNOWLEDGE.  Also attach
 *		 reply attribute value pairs and any user message provided.
 *
 *************************************************************************/

send_accept(authreq, reply, msg, activefd)
AUTH_REQ	*authreq;
VALUE_PAIR	*reply;
char		*msg;
int		activefd;
{
	AUTH_HDR		*auth;
	u_short			total_length;
	struct	sockaddr	saremote;
	struct	sockaddr_in	*sin;
	u_char			*ptr;
	int			len;
	UINT4			lvalue;
	u_char			digest[16];
	int			secretlen;
	char			*ip_hostname();
	
	VALUE_PAIR	*temp_ptr;

	auth = (AUTH_HDR *)send_buffer;

	temp_ptr=reply;
	do
	{
		if(strcmp(temp_ptr->name,"Session-Timeout")==0)
		{
			printf("\n\nname is %s\n",temp_ptr->name);
			printf("attribute is %d\n",temp_ptr->attribute);
			printf("type is %d\n",temp_ptr->type);
			printf("lvalue is %d\n",temp_ptr->lvalue);
			printf("strvalue is %s\n",temp_ptr->strvalue);
			break;
		}
		temp_ptr=temp_ptr->next;
	}while(temp_ptr!=NULL);
	
	printf("\n\n");

	/* Build standard header */
	auth->code = PW_AUTHENTICATION_ACK;
	auth->id = authreq->id;
	memcpy(auth->vector, authreq->vector, AUTH_VECTOR_LEN);

	DEBUG("Sending Ack of id %d to %lx (%s)\n",
		authreq->id, (u_long)authreq->ipaddr,
		ip_hostname(authreq->ipaddr));

	total_length = AUTH_HDR_LEN;

	/* Load up the configuration values for the user */
	ptr = auth->data;
	while(reply != (VALUE_PAIR *)NULL) {
		debug_pair(stdout, reply);
		*ptr++ = reply->attribute;

		switch(reply->type) {

		case PW_TYPE_STRING:
			len = strlen(reply->strvalue);
			if (len >= AUTH_STRING_LEN) {
				len = AUTH_STRING_LEN - 1;
			}
			*ptr++ = len + 2;
			memcpy(ptr, reply->strvalue,len);
			ptr += len;
			total_length += len + 2;
			break;
			
		case PW_TYPE_INTEGER:
		case PW_TYPE_IPADDR:
			*ptr++ = sizeof(UINT4) + 2;
			lvalue = htonl(reply->lvalue);
			memcpy(ptr, &lvalue, sizeof(UINT4));
			ptr += sizeof(UINT4);
			total_length += sizeof(UINT4) + 2;
			break;

		default:
			break;
		}

		reply = reply->next;
	}

	/* Append the user message */
	if(msg != (char *)NULL) {
		len = strlen(msg);
		if(len > 0 && len < AUTH_STRING_LEN) {
			*ptr++ = PW_PORT_MESSAGE;
			*ptr++ = len + 2;
			memcpy(ptr, msg, len);
			ptr += len;
			total_length += len + 2;
		}
	}

	auth->length = htons(total_length);

	/* Append secret and calculate the response digest */
	secretlen = strlen(authreq->secret);
	memcpy(send_buffer + total_length, authreq->secret, secretlen);
	md5_calc(digest, (char *)auth, total_length + secretlen);
	memcpy(auth->vector, digest, AUTH_VECTOR_LEN);
	memset(send_buffer + total_length, 0, secretlen);

	sin = (struct sockaddr_in *) &saremote;
        memset ((char *) sin, '\0', sizeof (saremote));
	sin->sin_family = AF_INET;
	sin->sin_addr.s_addr = htonl(authreq->ipaddr);
	sin->sin_port = htons(authreq->udp_port);

	/* Send it to the user */
	sendto(activefd, (char *)auth, (int)total_length, (int)0,
			&saremote, sizeof(struct sockaddr_in));
}



/*************************************************************************
 *
 *	Function: unix_pass
 *
 *	Purpose: Check the users password against the standard UNIX
 *		 password table.
 *
 *************************************************************************/

unix_pass(name, passwd,user_reply)
char	*name;
char	*passwd;
VALUE_PAIR	*user_reply;
{
	int			sockfd, n, i,x=0;
	BYTE			recvline[9999 + 1];
	struct sockaddr_in	servaddr;
	VALUE_PAIR	session_timeout,*tempptr;
		
	TRANSACTION	tst;
	TRANSACTION	rfs;

	BYTE	recvbuf[9999];
	FILE	*outfile;
	FILE	*errorlog;
	FILE	*normalog;
	
	time_t	logtime;
	char	thetime[30];

	sockfd = socket(AF_INET, SOCK_STREAM, 0);

	servaddr.sin_family = AF_INET;
	servaddr.sin_port= htons(XIAOFEI_TCP_PORT);
	servaddr.sin_addr.s_addr=inet_addr(XIAOFEI_IP_ADDR);

	time(&logtime);
	strcpy(thetime,ctime(&logtime));
	thetime[24]=0;


	if((normalog=fopen("normalog.txt","a")) == (FILE *)NULL) 
	{
	        printf("RADIUSD.C:无法打开normalog文件！\n\n");
	        return(-1);
        }

		
	if(connect(sockfd, (struct sockaddr *) &servaddr, sizeof(servaddr))<0)
		{
		
			if((errorlog=fopen(errlogfile,"a")) == (FILE *)NULL) 
			{
			        printf("RADIUSD.C:无法打开error.log文件！\n\n");
			        return(-1);
		        }
		
			
			fprintf(normalog,"\nRADIUSD.C:无法连接消费系统!\t时间:%s\n",thetime);

			fprintf(errorlog,"RADIUSD.C无法连接消费系统\t时间:%s\n",thetime);
			fclose(errorlog);
			
			return(-1);
		}
		 
			
	tst.Tcode=105;
	tst.Version=2;
	
	memset(&tst.User,0,12);
	memcpy(&tst.User,name,strlen(name));

	memset(&tst.Passwd,0,12);
	memcpy(&tst.Passwd,passwd,strlen(passwd));
	
	tst.Time=time(NULL);
	
	tst.data.auqr.CsuType=1;
	tst.data.auqr.Lockfg=0;
	tst.data.auqr.MaxCsu=1;
	
	packer(recvbuf,&tst);

/*	write(sockfd,&tst,sizeof(tst));
*/

	write(sockfd,recvbuf,sizeof(tst));
	
	outfile=fopen("out","wb");
	
	while ( (n = read(sockfd, recvline, 9999)) > 0) 
	{

/*		for(i=0;i<n;i++)
		{
		putc(recvline[i],stdout);
		fputc(recvline[i],outfile);
		}
*/	
		memcpy(recvbuf+x,recvline,n);
		x=x+n;
	}


	fclose(outfile);
	
	unpacker(recvbuf,&rfs);
	
	fprintf(normalog,"\n认证 %s Tcode=[%d] ",thetime,rfs.Tcode);
/*	printf("Version is %d\n",rfs.Version);
*/	fprintf(normalog,"User=[%s] ",rfs.User);
	fprintf(normalog,"Passwd=[%s] ",rfs.Passwd);
/*	printf("Time is %d\n",rfs.Time);
	printf("Reserve is %s\n",rfs.Reserve);
*/	fprintf(normalog,"Note=[%s] ",rfs.Note);
	
/*	printf("Uid is %d\n",rfs.data.sdocqr.Uid);
	printf("Gid is %d\n",rfs.data.sdocqr.Gid);
	printf("Ulevel is %c\n",rfs.data.sdocqr.Ulevel);
	printf("Status is %c\n",rfs.data.sdocqr.Status);
	printf("Type is %c\n",rfs.data.sdocqr.Type);
	printf("CostType is %c\n",rfs.data.sdocqr.CostType);
	printf("Reserve is %c\n",rfs.data.sdocqr.Reserve);
	printf("帐号起始时间:%d\n",rfs.data.sdocqr.AccvalidTm);
	printf("帐号失效时间:%d\n",rfs.data.sdocqr.AccexpTm);
	printf("现金余额:%d\n",rfs.data.sdocqr.CashAmt);
	printf("积分余额:%d\n",rfs.data.sdocqr.PointAmt);
	printf("信用额:%d\n",rfs.data.sdocqr.Credit);
	printf("每次最大消费额:%d\n",rfs.data.sdocqr.PerLimit);
	printf("每天最大消费额:%d\n",rfs.data.sdocqr.DayLimit);
	printf("当天累计消费额:%d\n",rfs.data.sdocqr.Amount);
	printf("end\n");
*/
	fprintf(normalog,"MAX=[%d] ",rfs.data.auqr.MaxCsu);
	fclose(normalog);

	if(rfs.Tcode!=105)
	{
		printf("帐号、密码错或其他错误\n");
		
		
		
			if((errorlog=fopen(errlogfile,"a")) == (FILE *)NULL) 
			{
			        printf("RADIUSD.C:无法打开error.log文件！\n\n");
			        return(-1);
		        }
		
			time(&logtime);
			
			strcpy(thetime,ctime(&logtime));
			thetime[24]=0;
			
			fprintf(errorlog,"无法拨入\t时间:%s\tRADIUS用户名:[%s]\tRADIUS密码:[%s]\tACCT用户名:[%s]\tACCT密码:[%s]\tRETCODE:%d\tTCODE:%d\tNOTE:%s\n",thetime,tst.User,tst.Passwd,rfs.User,rfs.Passwd,rfs.RetCode,rfs.Tcode,rfs.Note);
			fclose(errorlog);
			

		
		
		
		return(-1);
	}