netauth.c

UCOS-ii对于网络的支持代码

/*
 * np_down - a network protocol has gone down.
 */
#pragma argsused
void np_down(int unit, int proto)
{
	AUTHDEBUG((LOG_INFO, "np_down: %d proto=%X", unit, proto));
	if (--num_np_up == 0 && idle_time_limit > 0) {
		UNTIMEOUT(check_idle, NULL);
	}
}

/*
 * np_finished - a network protocol has finished using the link.
 */
#pragma argsused
void np_finished(int unit, int proto)
{
	AUTHDEBUG((LOG_INFO, "np_finished: %d proto=%X", unit, proto));
	if (--num_np_open <= 0) {
		/* no further use for the link: shut up shop. */
		lcp_close(0, "No network protocols running");
	}
}

/*
 * auth_reset - called when LCP is starting negotiations to recheck
 * authentication options, i.e. whether we have appropriate secrets
 * to use for authenticating ourselves and/or the peer.
 */
void auth_reset(int unit)
{
	lcp_options *go = &lcp_gotoptions[unit];
	lcp_options *ao = &lcp_allowoptions[0];
	ipcp_options *ipwo = &ipcp_wantoptions[0];
	u_int32_t remote;
	
	AUTHDEBUG((LOG_INFO, "auth_reset: %d", unit));
	ao->neg_upap = !refuse_pap && (passwd[0] != 0 || get_pap_passwd(unit));
	ao->neg_chap = !refuse_chap	&& have_chap_secret(user, remote_name, (u_int32_t)0);
	
	if (go->neg_upap && !have_pap_secret())
		go->neg_upap = 0;
	if (go->neg_chap) {
		remote = ipwo->accept_remote? 0: ipwo->hisaddr;
		if (!have_chap_secret(remote_name, our_name, remote))
			go->neg_chap = 0;
	}
}


#if PAP_SUPPORT > 0
/*
 * check_passwd - Check the user name and passwd against the PAP secrets
 * file.  If requested, also check against the system password database,
 * and login the user if OK.
 *
 * returns:
 *	UPAP_AUTHNAK: Authentication failed.
 *	UPAP_AUTHACK: Authentication succeeded.
 * In either case, msg points to an appropriate message.
 */
int check_passwd(
	int unit,
	char *auser,
	int userlen,
	char *apasswd,
	int passwdlen,
	char **msg,
	int *msglen
)
{
	int ret = 0;
	struct wordlist *addrs = NULL;
	char passwd[256], user[256];
	char secret[MAXWORDLEN];
	static int attempts = 0;
	
	/*
	 * Make copies of apasswd and auser, then null-terminate them.
	 */
	BCOPY(apasswd, passwd, passwdlen);
	passwd[passwdlen] = '\0';
	BCOPY(auser, user, userlen);
	user[userlen] = '\0';
	*msg = (char *) 0;

	/* XXX Validate user name and password. */
	ret = UPAP_AUTHACK;		/* XXX Assume all entries OK. */
		
	if (ret == UPAP_AUTHNAK) {
		if (*msg == (char *) 0)
			*msg = "Login incorrect";
		*msglen = strlen(*msg);
		/*
		 * Frustrate passwd stealer programs.
		 * Allow 10 tries, but start backing off after 3 (stolen from login).
		 * On 10'th, drop the connection.
		 */
		if (attempts++ >= 10) {
			trace(LOG_WARNING, "%d LOGIN FAILURES BY %s", attempts, user);
			panic("Excess Bad Logins");
		}
		if (attempts > 3)
			sleep((UINT) (attempts - 3) * 5);
		if (addrs != NULL)
			free_wordlist(addrs);
	} else {
		attempts = 0;			/* Reset count */
		if (*msg == (char *) 0)
			*msg = "Login ok";
		*msglen = strlen(*msg);
		set_allowed_addrs(unit, addrs);
	}
	
	BZERO(passwd, sizeof(passwd));
	BZERO(secret, sizeof(secret));
	
	return ret;
}
#endif


/*
 * auth_ip_addr - check whether the peer is authorized to use
 * a given IP address.  Returns 1 if authorized, 0 otherwise.
 */
int auth_ip_addr(int unit, u_int32_t addr)
{
	return ip_addr_check(addr, addresses[unit]);
}

/*
 * bad_ip_adrs - return 1 if the IP address is one we don't want
 * to use, such as an address in the loopback net or a multicast address.
 * addr is in network byte order.
 */
int bad_ip_adrs(u_int32_t addr)
{
	addr = ntohl(addr);
	return (addr >> IN_CLASSA_NSHIFT) == IN_LOOPBACKNET
		|| IN_MULTICAST(addr) || IN_BADCLASS(addr);
}


#if CHAP_SUPPORT > 0
/*
 * get_secret - open the CHAP secret file and return the secret
 * for authenticating the given client on the given server.
 * (We could be either client or server).
 */
int get_secret(
	int unit,
	char *client,
	char *server,
	char *secret,
	int *secret_len,
	int save_addrs
)
{
	int ret = 0, len;
	struct wordlist *addrs;
	char secbuf[MAXWORDLEN];
	
	addrs = NULL;
	secbuf[0] = 0;

	/* XXX Find secret. */	
	if (ret < 0)
		return 0;
	
	if (save_addrs)
		set_allowed_addrs(unit, addrs);
	
	len = strlen(secbuf);
	if (len > MAXSECRETLEN) {
		trace(LOG_ERR, "Secret for %s on %s is too long", client, server);
		len = MAXSECRETLEN;
	}
	BCOPY(secbuf, secret, len);
	BZERO(secbuf, sizeof(secbuf));
	*secret_len = len;
	
	return 1;
}
#endif


#ifdef UNUSED
/*
 * auth_check_options - called to check authentication options.
 */
void auth_check_options(void)
{
	lcp_options *wo = &lcp_wantoptions[0];
	int can_auth;
	ipcp_options *ipwo = &ipcp_wantoptions[0];
	u_int32_t remote;
	
	/* Default our_name to hostname, and user to our_name */
	if (our_name[0] == 0 || usehostname)
		strcpy(our_name, hostname);
	if (user[0] == 0)
		strcpy(user, our_name);
	
	/* If authentication is required, ask peer for CHAP or PAP. */
	if (auth_required && !wo->neg_chap && !wo->neg_upap) {
		wo->neg_chap = 1;
		wo->neg_upap = 1;
	}
	
	/*
	 * Check whether we have appropriate secrets to use
	 * to authenticate the peer.
	 */
	can_auth = wo->neg_upap && have_pap_secret();
	if (!can_auth && wo->neg_chap) {
		remote = ipwo->accept_remote? 0: ipwo->hisaddr;
		can_auth = have_chap_secret(remote_name, our_name, remote);
	}
	
	if (auth_required && !can_auth) {
		panic("No auth secret");
	}
}
#endif


/**********************************/
/*** LOCAL FUNCTION DEFINITIONS ***/
/**********************************/
/*
 * Proceed to the network phase.
 */
static void network_phase(int unit)
{
	int i;
	struct protent *protp;
	lcp_options *go = &lcp_gotoptions[unit];
	
	/*
	 * If the peer had to authenticate, run the auth-up script now.
	 */
	if ((go->neg_chap || go->neg_upap) && !did_authup) {
		/* XXX Do setup for peer authentication. */
		did_authup = 1;
	}
	
#if CBCP_SUPPORT > 0
	/*
	 * If we negotiated callback, do it now.
	 */
	if (go->neg_cbcp) {
		lcp_phase[unit] = PHASE_CALLBACK;
		(*cbcp_protent.open)(unit);
		return;
	}
#endif
	
	lcp_phase[unit] = PHASE_NETWORK;
	for (i = 0; (protp = protocols[i]) != NULL; ++i)
		if (protp->protocol < 0xC000 && protp->enabled_flag
				&& protp->open != NULL) {
			(*protp->open)(unit);
			if (protp->protocol != PPP_CCP)
				++num_np_open;
		}
	
	if (num_np_open == 0)
		/* nothing to do */
		lcp_close(0, "No network protocols running");
}

/*
 * check_idle - check whether the link has been idle for long
 * enough that we can shut it down.
 */
#pragma argsused
static void check_idle(void *arg)
{
	struct ppp_idle idle;
	u_short itime;
	
	if (!get_idle_time(0, &idle))
		return;
	itime = MIN(idle.xmit_idle, idle.recv_idle);
	if (itime >= idle_time_limit) {
		/* link is idle: shut it down. */
		trace(LOG_INFO, "Terminating connection due to lack of activity.");
		lcp_close(0, "Link inactive");
	} else {
		TIMEOUT(check_idle, NULL, idle_time_limit - itime);
	}
}

/*
 * connect_time_expired - log a message and close the connection.
 */
#pragma argsused
static void connect_time_expired(void *arg)
{
	trace(LOG_INFO, "Connect time expired");
	lcp_close(0, "Connect time expired");	/* Close connection */
}

#ifdef XXX
/*
 * login - Check the user name and password against the system
 * password database, and login the user if OK.
 *
 * returns:
 *	UPAP_AUTHNAK: Login failed.
 *	UPAP_AUTHACK: Login succeeded.
 * In either case, msg points to an appropriate message.
 */
#pragma argsused
static int login(char *user, char *passwd, char **msg, int *msglen)
{
	/* XXX Fail until we decide that we want to support logins. */
	return (UPAP_AUTHNAK);
}
#endif

/*
 * logout - Logout the user.
 */
static void logout(void)
{
	logged_in = FALSE;
}


/*
 * null_login - Check if a username of "" and a password of "" are
 * acceptable, and iff so, set the list of acceptable IP addresses
 * and return 1.
 */
#pragma argsused
static int null_login(int unit)
{
	/* XXX Fail until we decide that we want to support logins. */
	return FALSE;
}


/*
 * get_pap_passwd - get a password for authenticating ourselves with
 * our peer using PAP.  Returns 1 on success, 0 if no suitable password
 * could be found.
 */
static int get_pap_passwd(int unit)
{
	return upap[unit].us_user[0] != '\0';
}


/*
 * have_pap_secret - check whether we have a PAP file with any
 * secrets that we could possibly use for authenticating the peer.
 */
static int have_pap_secret(void)
{
	/* XXX Fail until we set up our passwords. */
	return 0;
}


/*
 * have_chap_secret - check whether we have a CHAP file with a
 * secret that we could possibly use for authenticating `client'
 * on `server'.  Either can be the null string, meaning we don't
 * know the identity yet.
 */
#pragma argsused
static int have_chap_secret(char *client, char *server, u_int32_t remote)
{
	/* XXX Fail until we set up our passwords. */
	return 0;
}


#if PAP_SUPPORT > 0 || CHAP_SUPPORT > 0
/*
 * set_allowed_addrs() - set the list of allowed addresses.
 */
static void set_allowed_addrs(int unit, struct wordlist *addrs)
{
	if (addresses[unit] != NULL)
		free_wordlist(addresses[unit]);
	addresses[unit] = addrs;

#ifdef XXX
	/*
	 * If there's only one authorized address we might as well
	 * ask our peer for that one right away
	 */
	if (addrs != NULL && addrs->next == NULL) {
		char *p = addrs->word;
		struct ipcp_options *wo = &ipcp_wantoptions[unit];
		u_int32_t a;
		struct hostent *hp;
		
		if (wo->hisaddr == 0 && *p != '!' && *p != '-'
				&& strchr(p, '/') == NULL) {
			hp = gethostbyname(p);
			if (hp != NULL && hp->h_addrtype == AF_INET)
				a = *(u_int32_t *)hp->h_addr;
			else
				a = inet_addr(p);
			if (a != (u_int32_t) -1)
				wo->hisaddr = a;
		}
	}
#endif
}
#endif

static int ip_addr_check(u_int32_t addr, struct wordlist *addrs)
{
	
	/* don't allow loopback or multicast address */
	if (bad_ip_adrs(addr))
		return 0;
	
	if (addrs == NULL)
		return !auth_required;		/* no addresses authorized */
	
	/* XXX All other addresses allowed. */
	return 1;
}

#if PAP_SUPPORT > 0 || CHAP_SUPPORT
/*
 * free_wordlist - release memory allocated for a wordlist.
 */
static void free_wordlist(struct wordlist *wp)
{
	struct wordlist *next;
	
	while (wp != NULL) {
		next = wp->next;
		free(wp);
		wp = next;
	}
}
#endif