ntp_config.c

网络时间协议NTP 源码 版本v4.2.0b 该源码用于linux平台下

			else
			    hmode = MODE_BROADCAST;

			if (ntokens < 2) {
				msyslog(LOG_ERR,
					"No address for %s, line ignored",
					tokens[0]);
				break;
			}

			istart = 1;
			memset((char *)&peeraddr, 0, sizeof(peeraddr));
			peeraddr.ss_family = default_ai_family;
			switch (matchkey(tokens[istart], addr_type, 0)) {
			case CONF_ADDR_IPV4:
				peeraddr.ss_family = AF_INET;
				istart++;
				break;
			case CONF_ADDR_IPV6:
				peeraddr.ss_family = AF_INET6;
				istart++;
				break;
			}

			status = getnetnum(tokens[istart], &peeraddr, 0, t_UNK);
			if (status == -1)
				break;		/* Found IPv6 address */
			if(status != 1) {
				errflg = -1;
			} else {
				errflg = 0;

				if (
#ifdef REFCLOCK
					!ISREFCLOCKADR(&peeraddr) &&
#endif
					ISBADADR(&peeraddr)) {
					msyslog(LOG_ERR,
						"attempt to configure invalid address %s",
						stoa(&peeraddr));
					break;
				}
				/*
				 * Shouldn't be able to specify multicast
				 * address for server/peer!
				 * and unicast address for manycastclient!
				 */
				if (peeraddr.ss_family == AF_INET) {
					if (((tok == CONFIG_SERVER) ||
				     	(tok == CONFIG_PEER)) &&
#ifdef REFCLOCK
				    	!ISREFCLOCKADR(&peeraddr) &&
#endif
				    	IN_CLASSD(ntohl(((struct sockaddr_in*)&peeraddr)->sin_addr.s_addr))) {
						msyslog(LOG_ERR,
							"attempt to configure invalid address %s",
							stoa(&peeraddr));
						break;
					}
					if ((tok == CONFIG_MANYCASTCLIENT) &&
				    	!IN_CLASSD(ntohl(((struct sockaddr_in*)&peeraddr)->sin_addr.s_addr))) {
						msyslog(LOG_ERR,
							"attempt to configure invalid address %s",
							stoa(&peeraddr));
						break;
					}
				}
				else if(peeraddr.ss_family == AF_INET6) {
                                if (((tok == CONFIG_SERVER) ||
                                     (tok == CONFIG_PEER)) &&
#ifdef REFCLOCK
                                    !ISREFCLOCKADR(&peeraddr) &&
#endif
                                        IN6_IS_ADDR_MULTICAST(&((struct sockaddr_in6*)&peeraddr)->sin6_addr)) {
                                                msyslog(LOG_ERR,
                                                        "attempt to configure in valid address %s",
                                                        stoa(&peeraddr));
                                                break;
                                        }
                                        if ((tok == CONFIG_MANYCASTCLIENT) &&
                                            !IN6_IS_ADDR_MULTICAST(&((struct sockaddr_in6*)&peeraddr)->sin6_addr)) {
                                                        msyslog(LOG_ERR,
                                                        "attempt to configure in valid address %s",
                                                        stoa(&peeraddr));
                                                break;
					}
				}
			}
			if (peeraddr.ss_family == AF_INET6 &&
			    isc_net_probeipv6() != ISC_R_SUCCESS)
				break;

			peerversion = NTP_VERSION;
			minpoll = NTP_MINDPOLL;
			maxpoll = NTP_MAXDPOLL;
			peerkey = 0;
			peerkeystr = (u_char *)"*";
			peerflags = 0;
			ttl = 0;
			istart++;
			for (i = istart; i < ntokens; i++)
			    switch (matchkey(tokens[i], mod_keywords, 1)) {
				case CONF_MOD_VERSION:
				    if (i >= ntokens-1) {
					    msyslog(LOG_ERR,
						    "peer/server version requires an argument");
					    errflg = 1;
					    break;
				    }
				    peerversion = atoi(tokens[++i]);
				    if ((u_char)peerversion > NTP_VERSION
					|| (u_char)peerversion < NTP_OLDVERSION) {
					    msyslog(LOG_ERR,
						    "inappropriate version number %s, line ignored",
						    tokens[i]);
					    errflg = 1;
				    }
				    break;
					
				case CONF_MOD_KEY:
				    if (i >= ntokens-1) {
					    msyslog(LOG_ERR,
						    "key: argument required");
					    errflg = 1;
					    break;
				    }
				    peerkey = (int)atol(tokens[++i]);
				    peerflags |= FLAG_AUTHENABLE;
				    break;

				case CONF_MOD_MINPOLL:
				    if (i >= ntokens-1) {
					    msyslog(LOG_ERR,
						    "minpoll: argument required");
					    errflg = 1;
					    break;
				    }
				    minpoll = atoi(tokens[++i]);
				    if (minpoll < NTP_MINPOLL) {
					    msyslog(LOG_INFO,
						    "minpoll: provided value (%d) is below minimum (%d)",
						    minpoll, NTP_MINPOLL);
					minpoll = NTP_MINPOLL;
				    }
				    break;

				case CONF_MOD_MAXPOLL:
				    if (i >= ntokens-1) {
					    msyslog(LOG_ERR,
						    "maxpoll: argument required"
						    );
					    errflg = 1;
					    break;
				    }
				    maxpoll = atoi(tokens[++i]);
				    if (maxpoll > NTP_MAXPOLL) {
					    msyslog(LOG_INFO,
						    "maxpoll: provided value (%d) is above maximum (%d)",
						    maxpoll, NTP_MAXPOLL);
					maxpoll = NTP_MAXPOLL;
				    }
				    break;

				case CONF_MOD_PREFER:
				    peerflags |= FLAG_PREFER;
				    break;

				case CONF_MOD_PREEMPT:
				    peerflags |= FLAG_PREEMPT;
				    break;

				case CONF_MOD_NOSELECT:
				    peerflags |= FLAG_NOSELECT;
				    break;

				case CONF_MOD_TRUE:
				    peerflags |= FLAG_TRUE;

				case CONF_MOD_BURST:
				    peerflags |= FLAG_BURST;
				    break;

				case CONF_MOD_IBURST:
				    peerflags |= FLAG_IBURST;
				    break;
#ifdef OPENSSL
				case CONF_MOD_SKEY:
				    peerflags |= FLAG_SKEY |
					FLAG_AUTHENABLE;
				    break;
#endif /* OPENSSL */

				case CONF_MOD_TTL:
				    if (i >= ntokens-1) {
					msyslog(LOG_ERR,
					    "ttl: argument required");
				        errflg = 1;
				        break;
				    }
				    ttl = atoi(tokens[++i]);
				    if (ttl >= MAX_TTL) {
					msyslog(LOG_ERR,
					    "ttl: invalid argument");
					errflg = 1;
				    }
				    break;

				case CONF_MOD_MODE:
				    if (i >= ntokens-1) {
					msyslog(LOG_ERR,
					    "mode: argument required");
					errflg = 1;
					break;
				    }
				    ttl = atoi(tokens[++i]);
				    break;

				case CONFIG_UNKNOWN:
				    errflg = 1;
				    break;
			    }
			if (minpoll > maxpoll) {
				msyslog(LOG_ERR,
				    "config error: minpoll > maxpoll");
				errflg = 1;
			}
			if (errflg == 0) {
			    if (peer_config(&peeraddr,
				ANY_INTERFACE_CHOOSE(&peeraddr), hmode,
				peerversion, minpoll, maxpoll, peerflags,
				ttl, peerkey, peerkeystr) == 0) {
					msyslog(LOG_ERR,
						"configuration of %s failed",
						stoa(&peeraddr));
			    }
			} else if (errflg == -1) {
				save_resolve(tokens[1], hmode, peerversion,
				    minpoll, maxpoll, peerflags, ttl,
				    peerkey, peerkeystr);
			}
			break;

		    case CONFIG_DRIFTFILE:
			if (ntokens >= 2)
			    stats_config(STATS_FREQ_FILE, tokens[1]);
			else
			    stats_config(STATS_FREQ_FILE, (char *)0);
			break;
	
		    case CONFIG_PIDFILE:
			if (ntokens >= 2)
			    stats_config(STATS_PID_FILE, tokens[1]);
			else
			    stats_config(STATS_PID_FILE, (char *)0);
			break;

		    case CONFIG_END:
			for ( i = 0; i <= includelevel; i++ ) {
				fclose(fp[i]);
			}
			break;
			
		    case CONFIG_INCLUDEFILE:
			if (ntokens < 2) {
			    msyslog(LOG_ERR, "includefile needs one argument");
			    break;
			}
			if (includelevel >= MAXINCLUDELEVEL) {
			    fprintf(stderr, "getconfig: Maximum include file level exceeded.\n");
			    msyslog(LOG_INFO, "getconfig: Maximum include file level exceeded.");
			    break;
			}
			includefile = fopen(FindConfig(tokens[1]), "r");
			if (includefile == NULL) {
			    fprintf(stderr, "getconfig: Couldn't open <%s>\n", FindConfig(tokens[1]));
			    msyslog(LOG_INFO, "getconfig: Couldn't open <%s>", FindConfig(tokens[1]));
			    break;
			}
			fp[++includelevel] = includefile;
			break;

		    case CONFIG_LOGFILE:
			if (ntokens >= 2) {
				FILE *new_file;

				new_file = fopen(tokens[1], "a");
				if (new_file != NULL) {
					NLOG(NLOG_SYSINFO) /* conditional if clause for conditional syslog */
					    msyslog(LOG_NOTICE, "logging to file %s", tokens[1]);
					if (syslog_file != NULL &&
					    fileno(syslog_file) != fileno(new_file))
					    (void)fclose(syslog_file);

					syslog_file = new_file;
					syslogit = 0;
				}
				else
				    msyslog(LOG_ERR,
					    "Cannot open log file %s",
					    tokens[1]);
			}
			else
			    msyslog(LOG_ERR, "logfile needs one argument");
			break;

		    case CONFIG_LOGCONFIG:
			for (i = 1; i < ntokens; i++)
			{
				int add = 1;
				int equals = 0;
				char * s = &tokens[i][0];

				switch (*s) {
				    case '+':
				    case '-':
				    case '=':
					add = *s == '+';
					equals = *s == '=';
					s++;
					break;

				    default:
					break;
				}
				if (equals) {
					ntp_syslogmask = get_logmask(s);
				} else {				
					if (add) {
						ntp_syslogmask |= get_logmask(s);
					} else {
						ntp_syslogmask &= ~get_logmask(s);
					}
				}
#ifdef DEBUG
				if (debug)
				    printf("ntp_syslogmask = 0x%08lx (%s)\n", ntp_syslogmask, tokens[i]);
#endif
			}
			break;

		    case CONFIG_BROADCASTCLIENT:
			if (ntokens == 1) {
				proto_config(PROTO_BROADCLIENT, 1, 0., NULL);
			} else {
				proto_config(PROTO_BROADCLIENT, 2, 0., NULL);
			}
			break;

		    case CONFIG_MULTICASTCLIENT:
		    case CONFIG_MANYCASTSERVER:
			if (ntokens > 1) {
				istart = 1;
				memset((char *)&peeraddr, 0, sizeof(peeraddr));
				peeraddr.ss_family = default_ai_family;
				switch (matchkey(tokens[istart],
				    addr_type, 0)) {
				case CONF_ADDR_IPV4:
					peeraddr.ss_family = AF_INET;
					istart++;
					break;
				case CONF_ADDR_IPV6:
					peeraddr.ss_family = AF_INET6;
					istart++;
					break;
				}
				/*
				 * Abuse maskaddr to store the prefered ip
				 * version.
				 */
				memset((char *)&maskaddr, 0, sizeof(maskaddr));
				maskaddr.ss_family = peeraddr.ss_family;

				for (i = istart; i < ntokens; i++) {
					memset((char *)&peeraddr, 0,
					    sizeof(peeraddr));
					peeraddr.ss_family = maskaddr.ss_family;
					if (getnetnum(tokens[i], &peeraddr, 1,
						      t_UNK)  == 1)
					    proto_config(PROTO_MULTICAST_ADD,
							 0, 0., &peeraddr);
				}
			} else
			    proto_config(PROTO_MULTICAST_ADD,
					 0, 0., NULL);
			if (tok == CONFIG_MULTICASTCLIENT)
				proto_config(PROTO_MULTICAST_ADD, 1, 0., NULL);
			else if (tok == CONFIG_MANYCASTSERVER)
				sys_manycastserver = 1;
			break;

		    case CONFIG_KEYS:
			if (ntokens >= 2) {
				getauthkeys(tokens[1]);
			}
			break;

		    case CONFIG_KEYSDIR:
			if (ntokens < 2) {
			    msyslog(LOG_ERR,
				"Keys directory name required");
			    break;
			}
			keysdir = (char *)emalloc(strlen(tokens[1]) + 1);
			strcpy(keysdir, tokens[1]);
			break;

		    case CONFIG_TINKER:
			for (i = 1; i < ntokens; i++) {
			    int temp;
			    double ftemp;

			    temp = matchkey(tokens[i++], tinker_keywords, 1);
			    if (i > ntokens - 1) {
				msyslog(LOG_ERR,
				    "tinker: missing argument");
				errflg++;
				break;
			    }
			    sscanf(tokens[i], "%lf", &ftemp);
			    switch(temp) {

			    case CONF_CLOCK_MAX:
                                loop_config(LOOP_MAX, ftemp);
				break;

			    case CONF_CLOCK_PANIC:
				loop_config(LOOP_PANIC, ftemp);
				break;

			    case CONF_CLOCK_PHI:
				loop_config(LOOP_PHI, ftemp);
				break;

			    case CONF_CLOCK_MINSTEP:
				loop_config(LOOP_MINSTEP, ftemp);
				break;

			    case CONF_CLOCK_ALLAN:
				loop_config(LOOP_ALLAN, ftemp);
				break;

			    case CONF_CLOCK_HUFFPUFF:
				loop_config(LOOP_HUFFPUFF, ftemp);
				break;

			    case CONF_CLOCK_FREQ:
				loop_config(LOOP_FREQ, ftemp);
				break;  
			    }
			}
			break;

		    case CONFIG_TOS:
			for (i = 1; i < ntokens; i++) {
			    int temp;
			    double ftemp;

			    temp = matchkey(tokens[i++], tos_keywords, 1);
			    if (i > ntokens - 1) {
				msyslog(LOG_ERR,
				    "tos: missing argument");
				errflg++;
				break;
			    }
			    sscanf(tokens[i], "%lf", &ftemp);
			    switch(temp) {

			    case CONF_TOS_MINCLOCK:
				proto_config(PROTO_MINCLOCK, 0, ftemp, NULL);
				break;

			    case CONF_TOS_MAXCLOCK:
				proto_config(PROTO_MAXCLOCK, 0, ftemp, NULL);
				break;

			    case CONF_TOS_MINSANE:
				proto_config(PROTO_MINSANE, 0, ftemp, NULL);
				break;

			    case CONF_TOS_FLOOR:
				proto_config(PROTO_FLOOR, 0, ftemp, NULL);
				break;

			    case CONF_TOS_CEILING:
				proto_config(PROTO_CEILING, 0, ftemp, NULL);
				break;

			    case CONF_TOS_COHORT:
				proto_config(PROTO_COHORT, 0, ftemp, NULL);
				break;

			    case CONF_TOS_MINDISP:
				proto_config(PROTO_MINDISP, 0, ftemp, NULL);
				break;

			    case CONF_TOS_MAXDIST:
				proto_config(PROTO_MAXDIST, 0, ftemp, NULL);
				break;

			    case CONF_TOS_MAXHOP:
				proto_config(PROTO_MAXHOP, 0, ftemp, NULL);
				break;

			    case CONF_TOS_ORPHAN:
				proto_config(PROTO_ORPHAN, 0, ftemp, NULL);
				break;

			    case CONF_TOS_BEACON:
				proto_config(PROTO_BEACON, 0, ftemp, NULL);
				break;
			    }
			}
			break;

		    case CONFIG_TTL:
			for (i = 1; i < ntokens && i < MAX_TTL; i++) {
			    sys_ttl[i - 1] = (u_char) atoi(tokens[i]);
			    sys_ttlmax = i - 1;
			}
			break;

		    case CONFIG_DISCARD:
			for (i = 1; i < ntokens; i++) {
			    int temp;

			    temp = matchkey(tokens[i++],
				discard_keywords, 1);
			    if (i > ntokens - 1) {
				msyslog(LOG_ERR,
				    "discard: missing argument");
				errflg++;
				break;
			    }
			    switch(temp) {
			    case CONF_DISCARD_AVERAGE:
				res_avg_interval = atoi(tokens[i]);
				break;

			    case CONF_DISCARD_MINIMUM:
				res_min_interval = atoi(tokens[i]);
				break;

			    case CONF_DISCARD_MONITOR:
				mon_age = atoi(tokens[i]);
				break;

			    default:
				msyslog(LOG_ERR,
				    "discard: unknown keyword");
				break;
			    }
			}
			break;

#ifdef OPENSSL
		    case CONFIG_REVOKE:
			if (ntokens >= 2)
			    sys_revoke = (u_char) max(atoi(tokens[1]), KEY_REVOKE);
			break;

		    case CONFIG_AUTOMAX:
			if (ntokens >= 2)
			    sys_automax = 1 << max(atoi(tokens[1]), 10);
			break;

		    case CONFIG_CRYPTO:
			if (ntokens == 1) {
				crypto_config(CRYPTO_CONF_NONE, NULL);
				break;
			}
			for (i = 1; i < ntokens; i++) {
			    int temp;

			    temp = matchkey(tokens[i++],
				 crypto_keywords, 1);
			    if (i > ntokens - 1) {
				msyslog(LOG_ERR,
				    "crypto: missing argument");
				errflg++;
				break;
			    }
			    switch(temp) {

			    case CONF_CRYPTO_CERT:
				crypto_config(CRYPTO_CONF_CERT,
				    tokens[i]);
				break;

			    case CONF_CRYPTO_RSA:
				crypto_config(CRYPTO_CONF_PRIV,
				    tokens[i]);
				break;

			    case CONF_CRYPTO_IDENT:
				crypto_config(CRYPTO_CONF_IDENT,
				    tokens[i]);
				break;

			    case CONF_CRYPTO_IFFPAR:
				crypto_config(CRYPTO_CONF_IFFPAR,
				    tokens[i]);
				break;

			    case CONF_CRYPTO_GQPAR:
				crypto_config(CRYPTO_CONF_GQPAR,
				    tokens[i]);
				break;

			    case CONF_CRYPTO_MVPAR:
				crypto_config(CRYPTO_CONF_MVPAR,
				    tokens[i]);
				break;

			    case CONF_CRYPTO_LEAP:
				crypto_config(CRYPTO_CONF_LEAP,
				    tokens[i]);
				break;

			    case CONF_CRYPTO_PW:
				crypto_config(CRYPTO_CONF_PW,
				    tokens[i]);
				break;

			    case CONF_CRYPTO_RAND:
				crypto_config(CRYPTO_CONF_RAND,
				    tokens[i]);
				break;