« back to all changes in this revision
Viewing changes to ntpd/ntp_request.c
- browse files at revision 3
- compare with another revision
- download diff
- download tarball
- view history from revision 3
- Committer: Bazaar Package Importer
- Author(s): Matt Zimmerman
- Date: 2004-10-11 16:10:27 UTC
- mfrom: (1.1.1 upstream)
- Revision ID: james.westby@ubuntu.com-20041011161027-icyjbji8ujym633o
Tags: 1:4.2.0a-10ubuntu2
Use ntp.ubuntulinux.org instead of pool.ntp.org
- files added:
- ChangeLog-4.1.0
- arlib
- html/drivers
- html/drivers/icons
- html/icons
- html/scripts
- include/isc
- libisc
- ports/winnt/include/isc
- ports/winnt/libisc
- ports/winnt/ntp-keygen
- sntp
- files removed:
- COPYRIGHT
- librsaref
- ntptrace
- files modified:
- ChangeLog
- depcomp *
- missing *
added
removed
ntpd/ntp_request.c
1
1
/*
2
2
* ntp_request.c - respond to information requests
3
3
*/
4
4
5
#ifdef HAVE_CONFIG_H
5
6
# include <config.h>
6
7
#endif
14
15
#include "ntp_stdlib.h"
15
16
16
17
#include <stdio.h>
18
#include <stddef.h>
17
19
#include <signal.h>
18
20
#include <netinet/in.h>
19
21
#include <arpa/inet.h>
31
33
#define AUTH 1
32
34
33
35
#define NO_REQUEST (-1)
36
/*
37
* Because we now have v6 addresses in the messages, we need to compensate
38
* for the larger size. Therefore, we introduce the alternate size to
39
* keep us friendly with older implementations. A little ugly.
40
*/
41
static int client_v6_capable = 0; /* the client can handle longer messages */
42
43
#define v6sizeof(type) (client_v6_capable ? sizeof(type) : v4sizeof(type))
34
44
35
45
struct req_proc {
36
46
short request_code; /* defined request code */
37
47
short needs_auth; /* true when authentication needed */
38
short sizeofitem; /* size of request data item */
39
void (*handler) P((struct sockaddr_in *, struct interface *,
48
short sizeofitem; /* size of request data item (older size)*/
49
short v6_sizeofitem; /* size of request data item (new size)*/
50
void (*handler) P((struct sockaddr_storage *, struct interface *,
40
51
struct req_pkt *)); /* routine to handle request */
41
52
};
42
53
47
58
{ NO_REQUEST, NOAUTH, 0, 0 }
48
59
};
49
60
50
static void req_ack P((struct sockaddr_in *, struct interface *, struct req_pkt *, int));
51
static char * prepare_pkt P((struct sockaddr_in *, struct interface *, struct req_pkt *, u_int));
61
static void req_ack P((struct sockaddr_storage *, struct interface *, struct req_pkt *, int));
62
static char * prepare_pkt P((struct sockaddr_storage *, struct interface *, struct req_pkt *, u_int));
52
63
static char * more_pkt P((void));
53
64
static void flush_pkt P((void));
54
static void peer_list P((struct sockaddr_in *, struct interface *, struct req_pkt *));
55
static void peer_list_sum P((struct sockaddr_in *, struct interface *, struct req_pkt *));
56
static void peer_info P((struct sockaddr_in *, struct interface *, struct req_pkt *));
57
static void peer_stats P((struct sockaddr_in *, struct interface *, struct req_pkt *));
58
static void sys_info P((struct sockaddr_in *, struct interface *, struct req_pkt *));
59
static void sys_stats P((struct sockaddr_in *, struct interface *, struct req_pkt *));
60
static void mem_stats P((struct sockaddr_in *, struct interface *, struct req_pkt *));
61
static void io_stats P((struct sockaddr_in *, struct interface *, struct req_pkt *));
62
static void timer_stats P((struct sockaddr_in *, struct interface *, struct req_pkt *));
63
static void loop_info P((struct sockaddr_in *, struct interface *, struct req_pkt *));
64
static void dns_a P((struct sockaddr_in *, struct interface *, struct req_pkt *));
65
static void do_conf P((struct sockaddr_in *, struct interface *, struct req_pkt *));
66
static void do_unconf P((struct sockaddr_in *, struct interface *, struct req_pkt *));
67
static void set_sys_flag P((struct sockaddr_in *, struct interface *, struct req_pkt *));
68
static void clr_sys_flag P((struct sockaddr_in *, struct interface *, struct req_pkt *));
69
static void setclr_flags P((struct sockaddr_in *, struct interface *, struct req_pkt *, u_long));
70
static void list_restrict P((struct sockaddr_in *, struct interface *, struct req_pkt *));
71
static void do_resaddflags P((struct sockaddr_in *, struct interface *, struct req_pkt *));
72
static void do_ressubflags P((struct sockaddr_in *, struct interface *, struct req_pkt *));
73
static void do_unrestrict P((struct sockaddr_in *, struct interface *, struct req_pkt *));
74
static void do_restrict P((struct sockaddr_in *, struct interface *, struct req_pkt *, int));
75
static void mon_getlist_0 P((struct sockaddr_in *, struct interface *, struct req_pkt *));
76
static void mon_getlist_1 P((struct sockaddr_in *, struct interface *, struct req_pkt *));
77
static void reset_stats P((struct sockaddr_in *, struct interface *, struct req_pkt *));
78
static void reset_peer P((struct sockaddr_in *, struct interface *, struct req_pkt *));
79
static void do_key_reread P((struct sockaddr_in *, struct interface *, struct req_pkt *));
80
static void trust_key P((struct sockaddr_in *, struct interface *, struct req_pkt *));
81
static void untrust_key P((struct sockaddr_in *, struct interface *, struct req_pkt *));
82
static void do_trustkey P((struct sockaddr_in *, struct interface *, struct req_pkt *, u_long));
83
static void get_auth_info P((struct sockaddr_in *, struct interface *, struct req_pkt *));
65
static void peer_list P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
66
static void peer_list_sum P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
67
static void peer_info P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
68
static void peer_stats P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
69
static void sys_info P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
70
static void sys_stats P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
71
static void mem_stats P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
72
static void io_stats P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
73
static void timer_stats P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
74
static void loop_info P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
75
static void do_conf P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
76
static void do_unconf P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
77
static void set_sys_flag P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
78
static void clr_sys_flag P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
79
static void setclr_flags P((struct sockaddr_storage *, struct interface *, struct req_pkt *, u_long));
80
static void list_restrict P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
81
static void do_resaddflags P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
82
static void do_ressubflags P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
83
static void do_unrestrict P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
84
static void do_restrict P((struct sockaddr_storage *, struct interface *, struct req_pkt *, int));
85
static void mon_getlist_0 P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
86
static void mon_getlist_1 P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
87
static void reset_stats P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
88
static void reset_peer P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
89
static void do_key_reread P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
90
static void trust_key P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
91
static void untrust_key P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
92
static void do_trustkey P((struct sockaddr_storage *, struct interface *, struct req_pkt *, u_long));
93
static void get_auth_info P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
84
94
static void reset_auth_stats P((void));
85
static void req_get_traps P((struct sockaddr_in *, struct interface *, struct req_pkt *));
86
static void req_set_trap P((struct sockaddr_in *, struct interface *, struct req_pkt *));
87
static void req_clr_trap P((struct sockaddr_in *, struct interface *, struct req_pkt *));
88
static void do_setclr_trap P((struct sockaddr_in *, struct interface *, struct req_pkt *, int));
89
static void set_request_keyid P((struct sockaddr_in *, struct interface *, struct req_pkt *));
90
static void set_control_keyid P((struct sockaddr_in *, struct interface *, struct req_pkt *));
91
static void get_ctl_stats P((struct sockaddr_in *, struct interface *, struct req_pkt *));
95
static void req_get_traps P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
96
static void req_set_trap P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
97
static void req_clr_trap P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
98
static void do_setclr_trap P((struct sockaddr_storage *, struct interface *, struct req_pkt *, int));
99
static void set_request_keyid P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
100
static void set_control_keyid P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
101
static void get_ctl_stats P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
92
102
#ifdef KERNEL_PLL
93
static void get_kernel_info P((struct sockaddr_in *, struct interface *, struct req_pkt *));
103
static void get_kernel_info P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
94
104
#endif /* KERNEL_PLL */
95
105
#ifdef REFCLOCK
96
static void get_clock_info P((struct sockaddr_in *, struct interface *, struct req_pkt *));
97
static void set_clock_fudge P((struct sockaddr_in *, struct interface *, struct req_pkt *));
106
static void get_clock_info P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
107
static void set_clock_fudge P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
98
108
#endif /* REFCLOCK */
99
109
#ifdef REFCLOCK
100
static void get_clkbug_info P((struct sockaddr_in *, struct interface *, struct req_pkt *));
110
static void get_clkbug_info P((struct sockaddr_storage *, struct interface *, struct req_pkt *));
101
111
#endif /* REFCLOCK */
102
112
103
113
/*
104
114
* ntpd request codes
105
115
*/
106
116
static struct req_proc ntp_codes[] = {
107
{ REQ_PEER_LIST, NOAUTH, 0, peer_list },
108
{ REQ_PEER_LIST_SUM, NOAUTH, 0, peer_list_sum },
109
{ REQ_PEER_INFO, NOAUTH, sizeof(struct info_peer_list), peer_info },
110
{ REQ_PEER_STATS, NOAUTH, sizeof(struct info_peer_list), peer_stats },
111
{ REQ_SYS_INFO, NOAUTH, 0, sys_info },
112
{ REQ_SYS_STATS, NOAUTH, 0, sys_stats },
113
{ REQ_IO_STATS, NOAUTH, 0, io_stats },
114
{ REQ_MEM_STATS, NOAUTH, 0, mem_stats },
115
{ REQ_LOOP_INFO, NOAUTH, 0, loop_info },
116
{ REQ_TIMER_STATS, NOAUTH, 0, timer_stats },
117
{ REQ_HOSTNAME_ASSOCID, AUTH, sizeof(struct info_dns_assoc), dns_a },
118
{ REQ_CONFIG, AUTH, sizeof(struct conf_peer), do_conf },
119
{ REQ_UNCONFIG, AUTH, sizeof(struct conf_unpeer), do_unconf },
120
{ REQ_SET_SYS_FLAG, AUTH, sizeof(struct conf_sys_flags), set_sys_flag },
121
{ REQ_CLR_SYS_FLAG, AUTH, sizeof(struct conf_sys_flags), clr_sys_flag },
122
{ REQ_GET_RESTRICT, NOAUTH, 0, list_restrict },
123
{ REQ_RESADDFLAGS, AUTH, sizeof(struct conf_restrict), do_resaddflags },
124
{ REQ_RESSUBFLAGS, AUTH, sizeof(struct conf_restrict), do_ressubflags },
125
{ REQ_UNRESTRICT, AUTH, sizeof(struct conf_restrict), do_unrestrict },
126
{ REQ_MON_GETLIST, NOAUTH, 0, mon_getlist_0 },
127
{ REQ_MON_GETLIST_1, NOAUTH, 0, mon_getlist_1 },
128
{ REQ_RESET_STATS, AUTH, sizeof(struct reset_flags), reset_stats },
129
{ REQ_RESET_PEER, AUTH, sizeof(struct conf_unpeer), reset_peer },
130
{ REQ_REREAD_KEYS, AUTH, 0, do_key_reread },
131
{ REQ_TRUSTKEY, AUTH, sizeof(u_long), trust_key },
132
{ REQ_UNTRUSTKEY, AUTH, sizeof(u_long), untrust_key },
133
{ REQ_AUTHINFO, NOAUTH, 0, get_auth_info },
134
{ REQ_TRAPS, NOAUTH, 0, req_get_traps },
135
{ REQ_ADD_TRAP, AUTH, sizeof(struct conf_trap), req_set_trap },
136
{ REQ_CLR_TRAP, AUTH, sizeof(struct conf_trap), req_clr_trap },
137
{ REQ_REQUEST_KEY, AUTH, sizeof(u_long), set_request_keyid },
138
{ REQ_CONTROL_KEY, AUTH, sizeof(u_long), set_control_keyid },
139
{ REQ_GET_CTLSTATS, NOAUTH, 0, get_ctl_stats },
117
{ REQ_PEER_LIST, NOAUTH, 0, 0, peer_list },
118
{ REQ_PEER_LIST_SUM, NOAUTH, 0, 0, peer_list_sum },
119
{ REQ_PEER_INFO, NOAUTH, v4sizeof(struct info_peer_list),
120
sizeof(struct info_peer_list), peer_info},
121
{ REQ_PEER_STATS, NOAUTH, v4sizeof(struct info_peer_list),
122
sizeof(struct info_peer_list), peer_stats},
123
{ REQ_SYS_INFO, NOAUTH, 0, 0, sys_info },
124
{ REQ_SYS_STATS, NOAUTH, 0, 0, sys_stats },
125
{ REQ_IO_STATS, NOAUTH, 0, 0, io_stats },
126
{ REQ_MEM_STATS, NOAUTH, 0, 0, mem_stats },
127
{ REQ_LOOP_INFO, NOAUTH, 0, 0, loop_info },
128
{ REQ_TIMER_STATS, NOAUTH, 0, 0, timer_stats },
129
{ REQ_CONFIG, AUTH, v4sizeof(struct conf_peer),
130
sizeof(struct conf_peer), do_conf },
131
{ REQ_UNCONFIG, AUTH, v4sizeof(struct conf_unpeer),
132
sizeof(struct conf_unpeer), do_unconf },
133
{ REQ_SET_SYS_FLAG, AUTH, sizeof(struct conf_sys_flags),
134
sizeof(struct conf_sys_flags), set_sys_flag },
135
{ REQ_CLR_SYS_FLAG, AUTH, sizeof(struct conf_sys_flags),
136
sizeof(struct conf_sys_flags), clr_sys_flag },
137
{ REQ_GET_RESTRICT, NOAUTH, 0, 0, list_restrict },
138
{ REQ_RESADDFLAGS, AUTH, v4sizeof(struct conf_restrict),
139
sizeof(struct conf_restrict), do_resaddflags },
140
{ REQ_RESSUBFLAGS, AUTH, v4sizeof(struct conf_restrict),
141
sizeof(struct conf_restrict), do_ressubflags },
142
{ REQ_UNRESTRICT, AUTH, v4sizeof(struct conf_restrict),
143
sizeof(struct conf_restrict), do_unrestrict },
144
{ REQ_MON_GETLIST, NOAUTH, 0, 0, mon_getlist_0 },
145
{ REQ_MON_GETLIST_1, NOAUTH, 0, 0, mon_getlist_1 },
146
{ REQ_RESET_STATS, AUTH, sizeof(struct reset_flags), 0, reset_stats },
147
{ REQ_RESET_PEER, AUTH, v4sizeof(struct conf_unpeer),
148
sizeof(struct conf_unpeer), reset_peer },
149
{ REQ_REREAD_KEYS, AUTH, 0, 0, do_key_reread },
150
{ REQ_TRUSTKEY, AUTH, sizeof(u_long), sizeof(u_long), trust_key },
151
{ REQ_UNTRUSTKEY, AUTH, sizeof(u_long), sizeof(u_long), untrust_key },
152
{ REQ_AUTHINFO, NOAUTH, 0, 0, get_auth_info },
153
{ REQ_TRAPS, NOAUTH, 0, 0, req_get_traps },
154
{ REQ_ADD_TRAP, AUTH, v4sizeof(struct conf_trap),
155
sizeof(struct conf_trap), req_set_trap },
156
{ REQ_CLR_TRAP, AUTH, v4sizeof(struct conf_trap),
157
sizeof(struct conf_trap), req_clr_trap },
158
{ REQ_REQUEST_KEY, AUTH, sizeof(u_long), sizeof(u_long),
159
set_request_keyid },
160
{ REQ_CONTROL_KEY, AUTH, sizeof(u_long), sizeof(u_long),
161
set_control_keyid },
162
{ REQ_GET_CTLSTATS, NOAUTH, 0, 0, get_ctl_stats },
140
163
#ifdef KERNEL_PLL
141
{ REQ_GET_KERNEL, NOAUTH, 0, get_kernel_info },
164
{ REQ_GET_KERNEL, NOAUTH, 0, 0, get_kernel_info },
142
165
#endif
143
166
#ifdef REFCLOCK
144
{ REQ_GET_CLOCKINFO, NOAUTH, sizeof(u_int32), get_clock_info },
145
{ REQ_SET_CLKFUDGE, AUTH, sizeof(struct conf_fudge), set_clock_fudge },
146
{ REQ_GET_CLKBUGINFO, NOAUTH, sizeof(u_int32), get_clkbug_info },
167
{ REQ_GET_CLOCKINFO, NOAUTH, sizeof(u_int32), sizeof(u_int32),
168
get_clock_info },
169
{ REQ_SET_CLKFUDGE, AUTH, sizeof(struct conf_fudge),
170
sizeof(struct conf_fudge), set_clock_fudge },
171
{ REQ_GET_CLKBUGINFO, NOAUTH, sizeof(u_int32), sizeof(u_int32),
172
get_clkbug_info },
147
173
#endif
148
{ NO_REQUEST, NOAUTH, 0, 0 }
174
{ NO_REQUEST, NOAUTH, 0, 0, 0 }
149
175
};
150
176
151
177
185
211
static int databytes;
186
212
static char exbuf[RESP_DATA_SIZE];
187
213
static int usingexbuf;
188
static struct sockaddr_in *toaddr;
214
static struct sockaddr_storage *toaddr;
189
215
static struct interface *frominter;
190
216
191
217
/*
211
237
*/
212
238
static void
213
239
req_ack(
214
struct sockaddr_in *srcadr,
240
struct sockaddr_storage *srcadr,
215
241
struct interface *inter,
216
242
struct req_pkt *inpkt,
217
243
int errcode
241
267
*/
242
268
static char *
243
269
prepare_pkt(
244
struct sockaddr_in *srcadr,
270
struct sockaddr_storage *srcadr,
245
271
struct interface *inter,
246
272
struct req_pkt *pkt,
247
273
u_int structsize
253
279
#endif
254
280
255
281
/*
256
* Fill in the implementation, reqest and itemsize fields
282
* Fill in the implementation, request and itemsize fields
257
283
* since these won't change.
258
284
*/
259
285
rpkt.implementation = pkt->implementation;
379
405
)
380
406
{
381
407
struct req_pkt *inpkt;
382
struct sockaddr_in *srcadr;
408
struct req_pkt_tail *tailinpkt;
409
struct sockaddr_storage *srcadr;
383
410
struct interface *inter;
384
411
struct req_proc *proc;
385
412
int ec;
413
short temp_size;
386
414
387
415
/*
388
416
* Initialize pointers, for convenience
409
437
|| (++ec, INFO_SEQ(inpkt->auth_seq) != 0)
410
438
|| (++ec, INFO_ERR(inpkt->err_nitems) != 0)
411
439
|| (++ec, INFO_MBZ(inpkt->mbz_itemsize) != 0)
412
|| (++ec, rbufp->recv_length > REQ_LEN_MAC)
413
|| (++ec, rbufp->recv_length < REQ_LEN_NOMAC)
440
|| (++ec, rbufp->recv_length < REQ_LEN_HDR)
414
441
) {
415
msyslog(LOG_ERR, "process_private: INFO_ERR_FMT: test %d failed", ec);
442
msyslog(LOG_ERR, "process_private: INFO_ERR_FMT: test %d failed, pkt from %s", ec, stoa(srcadr));
416
443
req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
417
444
return;
418
445
}
424
451
*/
425
452
if (inpkt->implementation == IMPL_UNIV)
426
453
proc = univ_codes;
427
else if (inpkt->implementation == IMPL_XNTPD)
454
else if ((inpkt->implementation == IMPL_XNTPD) ||
455
(inpkt->implementation == IMPL_XNTPD_OLD))
428
456
proc = ntp_codes;
429
457
else {
430
458
req_ack(srcadr, inter, inpkt, INFO_ERR_IMPL);
451
479
#endif
452
480
453
481
/*
482
* If we need data, check to see if we have some. If we
483
* don't, check to see that there is none (picky, picky).
484
*/
485
486
/* This part is a bit tricky, we want to be sure that the size
487
* returned is either the old or the new size. We also can find
488
* out if the client can accept both types of messages this way.
489
*
490
* Handle the exception of REQ_CONFIG. It can have two data sizes.
491
*/
492
temp_size = INFO_ITEMSIZE(inpkt->mbz_itemsize);
493
if ((temp_size != proc->sizeofitem &&
494
temp_size != proc->v6_sizeofitem) &&
495
!(inpkt->implementation == IMPL_XNTPD &&
496
inpkt->request == REQ_CONFIG &&
497
temp_size == sizeof(struct old_conf_peer))) {
498
if (debug > 2)
499
printf("process_private: wrong item size, received %d, should be %d or %d\n",
500
temp_size, proc->sizeofitem, proc->v6_sizeofitem);
501
req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
502
return;
503
}
504
if ((proc->sizeofitem != 0) &&
505
((temp_size * INFO_NITEMS(inpkt->err_nitems)) >
506
(rbufp->recv_length - REQ_LEN_HDR))) {
507
if (debug > 2)
508
printf("process_private: not enough data\n");
509
req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
510
return;
511
}
512
513
switch (inpkt->implementation) {
514
case IMPL_XNTPD:
515
client_v6_capable = 1;
516
break;
517
case IMPL_XNTPD_OLD:
518
client_v6_capable = 0;
519
break;
520
default:
521
req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
522
return;
523
}
524
525
/*
454
526
* If we need to authenticate, do so. Note that an
455
527
* authenticatable packet must include a mac field, must
456
528
* have used key info_auth_keyid and must have included
462
534
l_fp ftmp;
463
535
double dtemp;
464
536
537
if (rbufp->recv_length < (int)((REQ_LEN_HDR +
538
(INFO_ITEMSIZE(inpkt->mbz_itemsize) *
539
INFO_NITEMS(inpkt->err_nitems))
540
+ sizeof(struct req_pkt_tail)))) {
541
req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
542
}
543
tailinpkt = (struct req_pkt_tail *)((char *)&rbufp->recv_pkt +
544
rbufp->recv_length - sizeof(struct req_pkt_tail));
545
465
546
/*
466
547
* If this guy is restricted from doing this, don't let him
467
548
* If wrong key was used, or packet doesn't have mac, return.
468
549
*/
469
550
if (!INFO_IS_AUTH(inpkt->auth_seq) || info_auth_keyid == 0
470
|| ntohl(inpkt->keyid) != info_auth_keyid) {
551
|| ntohl(tailinpkt->keyid) != info_auth_keyid) {
471
552
#ifdef DEBUG
472
553
if (debug > 4)
473
554
printf("failed auth %d info_auth_keyid %lu pkt keyid %lu\n",
474
INFO_IS_AUTH(inpkt->auth_seq),
475
(u_long)info_auth_keyid,
476
(u_long)ntohl(inpkt->keyid));
555
INFO_IS_AUTH(inpkt->auth_seq),
556
(u_long)info_auth_keyid,
557
(u_long)ntohl(tailinpkt->keyid));
558
msyslog(LOG_DEBUG,
559
"process_private: failed auth %d info_auth_keyid %lu pkt keyid %lu\n",
560
INFO_IS_AUTH(inpkt->auth_seq),
561
(u_long)info_auth_keyid,
562
(u_long)ntohl(tailinpkt->keyid));
477
563
#endif
478
564
req_ack(srcadr, inter, inpkt, INFO_ERR_AUTH);
479
565
return;
484
570
printf("bad pkt length %d\n",
485
571
rbufp->recv_length);
486
572
#endif
487
msyslog(LOG_ERR, "process_private: bad pkt length %d",
488
rbufp->recv_length);
573
msyslog(LOG_ERR, "process_private: bad pkt length %d",
574
rbufp->recv_length);
489
575
req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
490
576
return;
491
577
}
493
579
#ifdef DEBUG
494
580
if (debug > 4)
495
581
printf("failed auth mod_okay %d\n", mod_okay);
582
msyslog(LOG_DEBUG,
583
"process_private: failed auth mod_okay %d\n",
584
mod_okay);
496
585
#endif
497
586
req_ack(srcadr, inter, inpkt, INFO_ERR_AUTH);
498
587
return;
502
591
* calculate absolute time difference between xmit time stamp
503
592
* and receive time stamp. If too large, too bad.
504
593
*/
505
NTOHL_FP(&inpkt->tstamp, &ftmp);
594
NTOHL_FP(&tailinpkt->tstamp, &ftmp);
506
595
L_SUB(&ftmp, &rbufp->recv_time);
507
596
LFPTOD(&ftmp, dtemp);
508
597
if (fabs(dtemp) >= INFO_TS_MAXSKEW) {
509
598
/*
510
599
* He's a loser. Tell him.
511
600
*/
601
#ifdef DEBUG
602
if (debug > 4)
603
printf("xmit/rcv timestamp delta > INFO_TS_MAXSKEW\n");
604
#endif
512
605
req_ack(srcadr, inter, inpkt, INFO_ERR_AUTH);
513
606
return;
514
607
}
517
610
* So far so good. See if decryption works out okay.
518
611
*/
519
612
if (!authdecrypt(info_auth_keyid, (u_int32 *)inpkt,
520
REQ_LEN_NOMAC, (int)(rbufp->recv_length - REQ_LEN_NOMAC))) {
613
rbufp->recv_length - sizeof(struct req_pkt_tail) +
614
REQ_LEN_HDR, sizeof(struct req_pkt_tail) - REQ_LEN_HDR)) {
615
#ifdef DEBUG
616
if (debug > 4)
617
printf("authdecrypt failed\n");
618
#endif
521
619
req_ack(srcadr, inter, inpkt, INFO_ERR_AUTH);
522
620
return;
523
621
}
524
622
}
525
623
526
/*
527
* If we need data, check to see if we have some. If we
528
* don't, check to see that there is none (picky, picky).
529
*/
530
if (INFO_ITEMSIZE(inpkt->mbz_itemsize) != proc->sizeofitem) {
531
msyslog(LOG_ERR, "INFO_ITEMSIZE(inpkt->mbz_itemsize) != proc->sizeofitem: %d != %d",
532
INFO_ITEMSIZE(inpkt->mbz_itemsize), proc->sizeofitem);
533
req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
534
return;
535
}
536
if (proc->sizeofitem != 0)
537
if (proc->sizeofitem*INFO_NITEMS(inpkt->err_nitems)
538
> sizeof(inpkt->data)) {
539
msyslog(LOG_ERR, "sizeofitem(%d)*NITEMS(%d) > data: %d > %ld",
540
proc->sizeofitem, INFO_NITEMS(inpkt->err_nitems),
541
proc->sizeofitem*INFO_NITEMS(inpkt->err_nitems),
542
(long)sizeof(inpkt->data));
543
req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
544
return;
545
}
546
624
#ifdef DEBUG
547
625
if (debug > 3)
548
626
printf("process_private: all okay, into handler\n");
560
638
*/
561
639
static void
562
640
peer_list(
563
struct sockaddr_in *srcadr,
641
struct sockaddr_storage *srcadr,
564
642
struct interface *inter,
565
643
struct req_pkt *inpkt
566
644
)
568
646
register struct info_peer_list *ip;
569
647
register struct peer *pp;
570
648
register int i;
649
register int skip = 0;
571
650
572
651
ip = (struct info_peer_list *)prepare_pkt(srcadr, inter, inpkt,
573
sizeof(struct info_peer_list));
574
for (i = 0; i < HASH_SIZE && ip != 0; i++) {
652
v6sizeof(struct info_peer_list));
653
for (i = 0; i < NTP_HASH_SIZE && ip != 0; i++) {
575
654
pp = peer_hash[i];
576
655
while (pp != 0 && ip != 0) {
577
ip->address = pp->srcadr.sin_addr.s_addr;
578
ip->port = pp->srcadr.sin_port;
579
ip->hmode = pp->hmode;
580
ip->flags = 0;
581
if (pp->flags & FLAG_CONFIG)
582
ip->flags |= INFO_FLAG_CONFIG;
583
if (pp == sys_peer)
584
ip->flags |= INFO_FLAG_SYSPEER;
585
if (pp->status == CTL_PST_SEL_SYNCCAND)
586
ip->flags |= INFO_FLAG_SEL_CANDIDATE;
587
if (pp->status >= CTL_PST_SEL_SYSPEER)
588
ip->flags |= INFO_FLAG_SHORTLIST;
589
ip = (struct info_peer_list *)more_pkt();
590
pp = pp->next;
656
if (pp->srcadr.ss_family == AF_INET6) {
657
if (client_v6_capable) {
658
ip->addr6 = GET_INADDR6(pp->srcadr);
659
ip->v6_flag = 1;
660
skip = 0;
661
} else {
662
skip = 1;
663
break;
664
}
665
} else {
666
ip->addr = GET_INADDR(pp->srcadr);
667
if (client_v6_capable)
668
ip->v6_flag = 0;
669
skip = 0;
670
}
671
672
if(!skip) {
673
ip->port = NSRCPORT(&pp->srcadr);
674
ip->hmode = pp->hmode;
675
ip->flags = 0;
676
if (pp->flags & FLAG_CONFIG)
677
ip->flags |= INFO_FLAG_CONFIG;
678
if (pp == sys_peer)
679
ip->flags |= INFO_FLAG_SYSPEER;
680
if (pp->status == CTL_PST_SEL_SYNCCAND)
681
ip->flags |= INFO_FLAG_SEL_CANDIDATE;
682
if (pp->status >= CTL_PST_SEL_SYSPEER)
683
ip->flags |= INFO_FLAG_SHORTLIST;
684
ip = (struct info_peer_list *)more_pkt();
685
}
686
pp = pp->next;
591
687
}
592
688
}
593
689
flush_pkt();
599
695
*/
600
696
static void
601
697
peer_list_sum(
602
struct sockaddr_in *srcadr,
698
struct sockaddr_storage *srcadr,
603
699
struct interface *inter,
604
700
struct req_pkt *inpkt
605
701
)
608
704
register struct peer *pp;
609
705
register int i;
610
706
l_fp ltmp;
707
register int skip;
611
708
612
709
#ifdef DEBUG
613
710
if (debug > 2)
614
711
printf("wants peer list summary\n");
615
712
#endif
616
617
713
ips = (struct info_peer_summary *)prepare_pkt(srcadr, inter, inpkt,
618
sizeof(struct info_peer_summary));
619
for (i = 0; i < HASH_SIZE && ips != 0; i++) {
714
v6sizeof(struct info_peer_summary));
715
for (i = 0; i < NTP_HASH_SIZE && ips != 0; i++) {
620
716
pp = peer_hash[i];
621
717
while (pp != 0 && ips != 0) {
622
718
#ifdef DEBUG
623
719
if (debug > 3)
624
720
printf("sum: got one\n");
625
721
#endif
626
ips->dstadr =
627
(pp->processed)
628
? pp->cast_flags == MDF_BCAST
629
? pp->dstadr->bcast.sin_addr.s_addr
630
: pp->cast_flags
631
? pp->dstadr->sin.sin_addr.s_addr
632
? pp->dstadr->sin.sin_addr.s_addr
633
: pp->dstadr->bcast.sin_addr.s_addr
634
: 1
635
: 5;
636
ips->srcadr = pp->srcadr.sin_addr.s_addr;
637
ips->srcport = pp->srcadr.sin_port;
638
ips->stratum = pp->stratum;
639
ips->hpoll = pp->hpoll;
640
ips->ppoll = pp->ppoll;
641
ips->reach = pp->reach;
642
ips->flags = 0;
643
if (pp == sys_peer)
644
ips->flags |= INFO_FLAG_SYSPEER;
645
if (pp->flags & FLAG_CONFIG)
646
ips->flags |= INFO_FLAG_CONFIG;
647
if (pp->flags & FLAG_REFCLOCK)
648
ips->flags |= INFO_FLAG_REFCLOCK;
649
if (pp->flags & FLAG_AUTHENABLE)
650
ips->flags |= INFO_FLAG_AUTHENABLE;
651
if (pp->flags & FLAG_PREFER)
652
ips->flags |= INFO_FLAG_PREFER;
653
if (pp->flags & FLAG_BURST)
654
ips->flags |= INFO_FLAG_BURST;
655
if (pp->status == CTL_PST_SEL_SYNCCAND)
656
ips->flags |= INFO_FLAG_SEL_CANDIDATE;
657
if (pp->status >= CTL_PST_SEL_SYSPEER)
658
ips->flags |= INFO_FLAG_SHORTLIST;
659
ips->hmode = pp->hmode;
660
ips->delay = HTONS_FP(DTOFP(pp->delay));
661
DTOLFP(pp->offset, <mp);
662
HTONL_FP(<mp, &ips->offset);
663
ips->dispersion = HTONS_FP(DTOUFP(pp->disp));
722
/*
723
* Be careful here not to return v6 peers when we
724
* want only v4.
725
*/
726
if (pp->srcadr.ss_family == AF_INET6) {
727
if (client_v6_capable) {
728
ips->srcadr6 = GET_INADDR6(pp->srcadr);
729
ips->v6_flag = 1;
730
ips->dstadr6 = GET_INADDR6(pp->dstadr->sin);
731
skip = 0;
732
} else {
733
skip = 1;
734
break;
735
}
736
} else {
737
ips->srcadr = GET_INADDR(pp->srcadr);
738
if (client_v6_capable)
739
ips->v6_flag = 0;
740
/* XXX PDM This code is buggy. Need to replace with a straightforward assignment */
741
ips->dstadr = (pp->processed) ?
742
pp->cast_flags == MDF_BCAST ?
743
GET_INADDR(pp->dstadr->bcast):
744
pp->cast_flags ?
745
GET_INADDR(pp->dstadr->sin) ?
746
GET_INADDR(pp->dstadr->sin):
747
GET_INADDR(pp->dstadr->bcast):
748
1 : GET_INADDR(pp->dstadr->sin);
664
749
665
pp = pp->next;
750
skip = 0;
751
}
752
if (!skip){
753
ips->srcport = NSRCPORT(&pp->srcadr);
754
ips->stratum = pp->stratum;
755
ips->hpoll = pp->hpoll;
756
ips->ppoll = pp->ppoll;
757
ips->reach = pp->reach;
758
ips->flags = 0;
759
if (pp == sys_peer)
760
ips->flags |= INFO_FLAG_SYSPEER;
761
if (pp->flags & FLAG_CONFIG)
762
ips->flags |= INFO_FLAG_CONFIG;
763
if (pp->flags & FLAG_REFCLOCK)
764
ips->flags |= INFO_FLAG_REFCLOCK;
765
if (pp->flags & FLAG_AUTHENABLE)
766
ips->flags |= INFO_FLAG_AUTHENABLE;
767
if (pp->flags & FLAG_PREFER)
768
ips->flags |= INFO_FLAG_PREFER;
769
if (pp->flags & FLAG_BURST)
770
ips->flags |= INFO_FLAG_BURST;
771
if (pp->status == CTL_PST_SEL_SYNCCAND)
772
ips->flags |= INFO_FLAG_SEL_CANDIDATE;
773
if (pp->status >= CTL_PST_SEL_SYSPEER)
774
ips->flags |= INFO_FLAG_SHORTLIST;
775
ips->hmode = pp->hmode;
776
ips->delay = HTONS_FP(DTOFP(pp->delay));
777
DTOLFP(pp->offset, <mp);
778
HTONL_FP(<mp, &ips->offset);
779
ips->dispersion = HTONS_FP(DTOUFP(SQRT(pp->disp)));
780
}
781
pp = pp->next;
666
782
ips = (struct info_peer_summary *)more_pkt();
667
783
}
668
784
}
675
791
*/
676
792
static void
677
793
peer_info (
678
struct sockaddr_in *srcadr,
794
struct sockaddr_storage *srcadr,
679
795
struct interface *inter,
680
796
struct req_pkt *inpkt
681
797
)
685
801
register struct info_peer *ip;
686
802
register int items;
687
803
register int i, j;
688
struct sockaddr_in addr;
804
struct sockaddr_storage addr;
689
805
extern struct peer *sys_peer;
690
806
l_fp ltmp;
691
807
692
808
memset((char *)&addr, 0, sizeof addr);
693
addr.sin_family = AF_INET;
694
809
items = INFO_NITEMS(inpkt->err_nitems);
695
810
ipl = (struct info_peer_list *) inpkt->data;
811
696
812
ip = (struct info_peer *)prepare_pkt(srcadr, inter, inpkt,
697
sizeof(struct info_peer));
813
v6sizeof(struct info_peer));
698
814
while (items-- > 0 && ip != 0) {
699
addr.sin_port = ipl->port;
700
addr.sin_addr.s_addr = ipl->address;
815
memset((char *)&addr, 0, sizeof(addr));
816
NSRCPORT(&addr) = ipl->port;
817
if (client_v6_capable && ipl->v6_flag != 0) {
818
addr.ss_family = AF_INET6;
819
GET_INADDR6(addr) = ipl->addr6;
820
} else {
821
addr.ss_family = AF_INET;
822
GET_INADDR(addr) = ipl->addr;
823
}
824
#ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR
825
addr.ss_len = SOCKLEN(&addr);
826
#endif
701
827
ipl++;
702
828
if ((pp = findexistingpeer(&addr, (struct peer *)0, -1)) == 0)
703
829
continue;
704
ip->dstadr =
705
(pp->processed)
706
? pp->cast_flags == MDF_BCAST
707
? pp->dstadr->bcast.sin_addr.s_addr
708
: pp->cast_flags
709
? pp->dstadr->sin.sin_addr.s_addr
710
? pp->dstadr->sin.sin_addr.s_addr
711
: pp->dstadr->bcast.sin_addr.s_addr
712
: 2
713
: 6;
714
ip->srcadr = NSRCADR(&pp->srcadr);
830
if (pp->srcadr.ss_family == AF_INET6) {
831
ip->dstadr6 = pp->cast_flags == MDF_BCAST ?
832
GET_INADDR6(pp->dstadr->bcast) :
833
GET_INADDR6(pp->dstadr->sin);
834
ip->srcadr6 = GET_INADDR6(pp->srcadr);
835
ip->v6_flag = 1;
836
} else {
837
/* XXX PDM This code is buggy. Need to replace with a straightforward assignment */
838
ip->dstadr = (pp->processed) ?
839
pp->cast_flags == MDF_BCAST ?
840
GET_INADDR(pp->dstadr->bcast):
841
pp->cast_flags ?
842
GET_INADDR(pp->dstadr->sin) ?
843
GET_INADDR(pp->dstadr->sin):
844
GET_INADDR(pp->dstadr->bcast):
845
2 : GET_INADDR(pp->dstadr->sin);
846
847
ip->srcadr = GET_INADDR(pp->srcadr);
848
if (client_v6_capable)
849
ip->v6_flag = 0;
850
}
715
851
ip->srcport = NSRCPORT(&pp->srcadr);
716
852
ip->flags = 0;
717
853
if (pp == sys_peer)
739
875
ip->precision = pp->precision;
740
876
ip->version = pp->version;
741
877
ip->reach = pp->reach;
742
ip->unreach = pp->unreach;
878
ip->unreach = (u_char) pp->unreach;
743
879
ip->flash = (u_char)pp->flash;
744
ip->flash2 = pp->flash;
880
ip->flash2 = (u_short) pp->flash;
745
881
ip->estbdelay = HTONS_FP(DTOFP(pp->estbdelay));
746
882
ip->ttl = pp->ttl;
747
883
ip->associd = htons(pp->associd);
759
895
ip->filtdelay[i] = HTONS_FP(DTOFP(pp->filter_delay[j]));
760
896
DTOLFP(pp->filter_offset[j], <mp);
761
897
HTONL_FP(<mp, &ip->filtoffset[i]);
762
ip->order[i] = (pp->filter_nextpt+NTP_SHIFT-1)
763
- pp->filter_order[i];
898
ip->order[i] = (u_char)((pp->filter_nextpt+NTP_SHIFT-1)
899
- pp->filter_order[i]);
764
900
if (ip->order[i] >= NTP_SHIFT)
765
901
ip->order[i] -= NTP_SHIFT;
766
902
}
780
916
*/
781
917
static void
782
918
peer_stats (
783
struct sockaddr_in *srcadr,
919
struct sockaddr_storage *srcadr,
784
920
struct interface *inter,
785
921
struct req_pkt *inpkt
786
922
)
789
925
register struct peer *pp;
790
926
register struct info_peer_stats *ip;
791
927
register int items;
792
struct sockaddr_in addr;
928
struct sockaddr_storage addr;
793
929
extern struct peer *sys_peer;
794
930
795
memset((char *)&addr, 0, sizeof addr);
796
addr.sin_family = AF_INET;
931
printf("peer_stats: called\n");
797
932
items = INFO_NITEMS(inpkt->err_nitems);
798
933
ipl = (struct info_peer_list *) inpkt->data;
799
934
ip = (struct info_peer_stats *)prepare_pkt(srcadr, inter, inpkt,
800
sizeof(struct info_peer_stats));
935
v6sizeof(struct info_peer_stats));
801
936
while (items-- > 0 && ip != 0) {
802
addr.sin_port = ipl->port;
803
addr.sin_addr.s_addr = ipl->address;
804
ipl++;
937
memset((char *)&addr, 0, sizeof(addr));
938
NSRCPORT(&addr) = ipl->port;
939
if (client_v6_capable && ipl->v6_flag) {
940
addr.ss_family = AF_INET6;
941
GET_INADDR6(addr) = ipl->addr6;
942
} else {
943
addr.ss_family = AF_INET;
944
GET_INADDR(addr) = ipl->addr;
945
}
946
#ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR
947
addr.ss_len = SOCKLEN(&addr);
948
#endif
949
printf("peer_stats: looking for %s, %d, %d\n", stoa(&addr),
950
ipl->port, ((struct sockaddr_in6 *)&addr)->sin6_port);
951
ipl = (struct info_peer_list *)((char *)ipl +
952
INFO_ITEMSIZE(inpkt->mbz_itemsize));
953
805
954
if ((pp = findexistingpeer(&addr, (struct peer *)0, -1)) == 0)
806
955
continue;
807
ip->dstadr =
808
(pp->processed)
809
? pp->cast_flags == MDF_BCAST
810
? pp->dstadr->bcast.sin_addr.s_addr
811
: pp->cast_flags
812
? pp->dstadr->sin.sin_addr.s_addr
813
? pp->dstadr->sin.sin_addr.s_addr
814
: pp->dstadr->bcast.sin_addr.s_addr
815
: 3
816
: 7;
817
ip->srcadr = NSRCADR(&pp->srcadr);
956
printf("peer_stats: found %s\n", stoa(&addr));
957
if (pp->srcadr.ss_family == AF_INET) {
958
ip->dstadr = (pp->processed) ?
959
pp->cast_flags == MDF_BCAST ?
960
GET_INADDR(pp->dstadr->bcast):
961
pp->cast_flags ?
962
GET_INADDR(pp->dstadr->sin) ?
963
GET_INADDR(pp->dstadr->sin):
964
GET_INADDR(pp->dstadr->bcast):
965
3 : 7;
966
ip->srcadr = GET_INADDR(pp->srcadr);
967
if (client_v6_capable)
968
ip->v6_flag = 0;
969
} else {
970
ip->dstadr6 = pp->cast_flags == MDF_BCAST ?
971
GET_INADDR6(pp->dstadr->bcast):
972
GET_INADDR6(pp->dstadr->sin);
973
ip->srcadr6 = GET_INADDR6(pp->srcadr);
974
ip->v6_flag = 1;
975
}
818
976
ip->srcport = NSRCPORT(&pp->srcadr);
819
977
ip->flags = 0;
820
978
if (pp == sys_peer)
855
1013
*/
856
1014
static void
857
1015
sys_info(
858
struct sockaddr_in *srcadr,
1016
struct sockaddr_storage *srcadr,
859
1017
struct interface *inter,
860
1018
struct req_pkt *inpkt
861
1019
)
881
1039
extern double sys_jitter;
882
1040
883
1041
is = (struct info_sys *)prepare_pkt(srcadr, inter, inpkt,
884
sizeof(struct info_sys));
1042
v6sizeof(struct info_sys));
885
1043
886
1044
if (sys_peer != 0) {
887
is->peer = NSRCADR(&sys_peer->srcadr);
1045
if (sys_peer->srcadr.ss_family == AF_INET) {
1046
is->peer = GET_INADDR(sys_peer->srcadr);
1047
if (client_v6_capable)
1048
is->v6_flag = 0;
1049
} else if (client_v6_capable) {
1050
is->peer6 = GET_INADDR6(sys_peer->srcadr);
1051
is->v6_flag = 1;
1052
}
888
1053
is->peer_mode = sys_peer->hmode;
889
1054
} else {
890
1055
is->peer = 0;
1056
if (client_v6_capable) {
1057
is->v6_flag = 0;
1058
}
891
1059
is->peer_mode = 0;
892
1060
}
1061
893
1062
is->leap = sys_leap;
894
1063
is->stratum = sys_stratum;
895
1064
is->precision = sys_precision;
903
1072
is->poll = sys_poll;
904
1073
905
1074
is->flags = 0;
1075
if (sys_authenticate)
1076
is->flags |= INFO_FLAG_AUTHENTICATE;
906
1077
if (sys_bclient)
907
is->flags |= INFO_FLAG_BCLIENT;
908
if (sys_authenticate)
909
is->flags |= INFO_FLAG_AUTHENTICATE;
1078
is->flags |= INFO_FLAG_BCLIENT;
1079
#ifdef REFCLOCK
1080
if (cal_enable)
1081
is->flags |= INFO_FLAG_CAL;
1082
#endif /* REFCLOCK */
910
1083
if (kern_enable)
911
is->flags |= INFO_FLAG_KERNEL;
1084
is->flags |= INFO_FLAG_KERNEL;
1085
if (mon_enabled != MON_OFF)
1086
is->flags |= INFO_FLAG_MONITOR;
912
1087
if (ntp_enable)
913
is->flags |= INFO_FLAG_NTP;
914
if (pll_control)
915
is->flags |= INFO_FLAG_PLL_SYNC;
916
if (pps_control)
917
is->flags |= INFO_FLAG_PPS_SYNC;
918
if (mon_enabled != MON_OFF)
919
is->flags |= INFO_FLAG_MONITOR;
1088
is->flags |= INFO_FLAG_NTP;
1089
if (pps_enable)
1090
is->flags |= INFO_FLAG_PPS_SYNC;
920
1091
if (stats_control)
921
is->flags |= INFO_FLAG_FILEGEN;
1092
is->flags |= INFO_FLAG_FILEGEN;
922
1093
is->bdelay = HTONS_FP(DTOFP(sys_bdelay));
923
1094
HTONL_UF(sys_authdelay.l_f, &is->authdelay);
924
1095
932
1103
*/
933
1104
static void
934
1105
sys_stats(
935
struct sockaddr_in *srcadr,
1106
struct sockaddr_storage *srcadr,
936
1107
struct interface *inter,
937
1108
struct req_pkt *inpkt
938
1109
)
942
1113
/*
943
1114
* Importations from the protocol module
944
1115
*/
945
extern u_long sys_stattime;
946
extern u_long sys_badstratum;
947
extern u_long sys_oldversionpkt;
948
extern u_long sys_newversionpkt;
949
extern u_long sys_unknownversion;
950
extern u_long sys_badlength;
951
extern u_long sys_processed;
952
extern u_long sys_badauth;
953
extern u_long sys_limitrejected;
954
955
1116
ss = (struct info_sys_stats *)prepare_pkt(srcadr, inter, inpkt,
956
sizeof(struct info_sys_stats));
957
1117
sizeof(struct info_sys_stats));
958
1118
ss->timeup = htonl((u_int32)current_time);
959
1119
ss->timereset = htonl((u_int32)(current_time - sys_stattime));
960
ss->badstratum = htonl((u_int32)sys_badstratum);
1120
ss->denied = htonl((u_int32)sys_restricted);
961
1121
ss->oldversionpkt = htonl((u_int32)sys_oldversionpkt);
962
1122
ss->newversionpkt = htonl((u_int32)sys_newversionpkt);
963
1123
ss->unknownversion = htonl((u_int32)sys_unknownversion);
965
1125
ss->processed = htonl((u_int32)sys_processed);
966
1126
ss->badauth = htonl((u_int32)sys_badauth);
967
1127
ss->limitrejected = htonl((u_int32)sys_limitrejected);
1128
ss->received = htonl((u_int32)sys_received);
968
1129
(void) more_pkt();
969
1130
flush_pkt();
970
1131
}
975
1136
*/
976
1137
static void
977
1138
mem_stats(
978
struct sockaddr_in *srcadr,
1139
struct sockaddr_storage *srcadr,
979
1140
struct interface *inter,
980
1141
struct req_pkt *inpkt
981
1142
)
986
1147
/*
987
1148
* Importations from the peer module
988
1149
*/
989
extern int peer_hash_count[HASH_SIZE];
1150
extern int peer_hash_count[NTP_HASH_SIZE];
990
1151
extern int peer_free_count;
991
1152
extern u_long peer_timereset;
992
1153
extern u_long findpeer_calls;
1004
1165
ms->allocations = htonl((u_int32)peer_allocations);
1005
1166
ms->demobilizations = htonl((u_int32)peer_demobilizations);
1006
1167
1007
for (i = 0; i < HASH_SIZE; i++) {
1168
for (i = 0; i < NTP_HASH_SIZE; i++) {
1008
1169
if (peer_hash_count[i] > 255)
1009
1170
ms->hashcount[i] = 255;
1010
1171
else
1021
1182
*/
1022
1183
static void
1023
1184
io_stats(
1024
struct sockaddr_in *srcadr,
1185
struct sockaddr_storage *srcadr,
1025
1186
struct interface *inter,
1026
1187
struct req_pkt *inpkt
1027
1188
)
1059
1220
*/
1060
1221
static void
1061
1222
timer_stats(
1062
struct sockaddr_in *srcadr,
1223
struct sockaddr_storage *srcadr,
1063
1224
struct interface *inter,
1064
1225
struct req_pkt *inpkt
1065
1226
)
1091
1252
*/
1092
1253
static void
1093
1254
loop_info(
1094
struct sockaddr_in *srcadr,
1255
struct sockaddr_storage *srcadr,
1095
1256
struct interface *inter,
1096
1257
struct req_pkt *inpkt
1097
1258
)
1127
1288
*/
1128
1289
static void
1129
1290
do_conf(
1130
struct sockaddr_in *srcadr,
1291
struct sockaddr_storage *srcadr,
1131
1292
struct interface *inter,
1132
1293
struct req_pkt *inpkt
1133
1294
)
1134
1295
{
1296
int items;
1135
1297
u_int fl;
1136
register struct conf_peer *cp;
1137
register int items;
1138
struct sockaddr_in peeraddr;
1298
struct conf_peer *cp;
1299
struct conf_peer temp_cp;
1300
struct sockaddr_storage peeraddr;
1301
struct sockaddr_in tmp_clock;
1139
1302
1140
1303
/*
1141
1304
* Do a check of everything to see that it looks
1144
1307
*/
1145
1308
items = INFO_NITEMS(inpkt->err_nitems);
1146
1309
cp = (struct conf_peer *)inpkt->data;
1147
1310
memset(&temp_cp, 0, sizeof(struct conf_peer));
1311
memcpy(&temp_cp, (char *)cp, INFO_ITEMSIZE(inpkt->mbz_itemsize));
1148
1312
fl = 0;
1149
1313
while (items-- > 0 && !fl) {
1150
if (((cp->version) > NTP_VERSION)
1151
|| ((cp->version) < NTP_OLDVERSION))
1152
fl = 1;
1153
if (cp->hmode != MODE_ACTIVE
1154
&& cp->hmode != MODE_CLIENT
1155
&& cp->hmode != MODE_BROADCAST)
1156
fl = 1;
1157
if (cp->flags & ~(CONF_FLAG_AUTHENABLE | CONF_FLAG_PREFER |
1158
CONF_FLAG_NOSELECT | CONF_FLAG_BURST | CONF_FLAG_IBURST |
1159
CONF_FLAG_SKEY))
1160
fl = 1;
1161
cp++;
1314
if (((temp_cp.version) > NTP_VERSION)
1315
|| ((temp_cp.version) < NTP_OLDVERSION))
1316
fl = 1;
1317
if (temp_cp.hmode != MODE_ACTIVE
1318
&& temp_cp.hmode != MODE_CLIENT
1319
&& temp_cp.hmode != MODE_BROADCAST)
1320
fl = 1;
1321
if (temp_cp.flags & ~(CONF_FLAG_AUTHENABLE | CONF_FLAG_PREFER
1322
| CONF_FLAG_BURST | CONF_FLAG_SKEY))
1323
fl = 1;
1324
cp = (struct conf_peer *)
1325
((char *)cp + INFO_ITEMSIZE(inpkt->mbz_itemsize));
1162
1326
}
1163
1327
1164
1328
if (fl) {
1165
msyslog(LOG_ERR, "do_conf: fl is nonzero!");
1166
1329
req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
1167
1330
return;
1168
1331
}
1171
1334
* Looks okay, try it out
1172
1335
*/
1173
1336
items = INFO_NITEMS(inpkt->err_nitems);
1174
cp = (struct conf_peer *)inpkt->data;
1175
memset((char *)&peeraddr, 0, sizeof(struct sockaddr_in));
1176
peeraddr.sin_family = AF_INET;
1177
peeraddr.sin_port = htons(NTP_PORT);
1178
1179
/*
1180
* Make sure the address is valid
1181
*/
1182
if (
1183
#ifdef REFCLOCK
1184
!ISREFCLOCKADR(&peeraddr) &&
1185
#endif
1186
ISBADADR(&peeraddr)) {
1187
#ifdef REFCLOCK
1188
msyslog(LOG_ERR, "do_conf: !ISREFCLOCK && ISBADADR");
1189
#else
1190
msyslog(LOG_ERR, "do_conf: ISBADADR");
1191
#endif
1192
req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
1193
return;
1194
}
1337
cp = (struct conf_peer *)inpkt->data;
1195
1338
1196
1339
while (items-- > 0) {
1340
memset(&temp_cp, 0, sizeof(struct conf_peer));
1341
memcpy(&temp_cp, (char *)cp, INFO_ITEMSIZE(inpkt->mbz_itemsize));
1342
memset((char *)&peeraddr, 0, sizeof(struct sockaddr_storage));
1343
1197
1344
fl = 0;
1198
if (cp->flags & CONF_FLAG_AUTHENABLE)
1199
fl |= FLAG_AUTHENABLE;
1200
if (cp->flags & CONF_FLAG_PREFER)
1201
fl |= FLAG_PREFER;
1202
if (cp->flags & CONF_FLAG_NOSELECT)
1203
fl |= FLAG_NOSELECT;
1204
if (cp->flags & CONF_FLAG_BURST)
1205
fl |= FLAG_BURST;
1206
if (cp->flags & CONF_FLAG_IBURST)
1207
fl |= FLAG_IBURST;
1208
if (cp->flags & CONF_FLAG_SKEY)
1345
if (temp_cp.flags & CONF_FLAG_AUTHENABLE)
1346
fl |= FLAG_AUTHENABLE;
1347
if (temp_cp.flags & CONF_FLAG_PREFER)
1348
fl |= FLAG_PREFER;
1349
if (temp_cp.flags & CONF_FLAG_BURST)
1350
fl |= FLAG_BURST;
1351
if (temp_cp.flags & CONF_FLAG_SKEY)
1209
1352
fl |= FLAG_SKEY;
1210
peeraddr.sin_addr.s_addr = cp->peeraddr;
1353
if (client_v6_capable && temp_cp.v6_flag != 0) {
1354
peeraddr.ss_family = AF_INET6;
1355
GET_INADDR6(peeraddr) = temp_cp.peeraddr6;
1356
} else {
1357
peeraddr.ss_family = AF_INET;
1358
GET_INADDR(peeraddr) = temp_cp.peeraddr;
1359
/*
1360
* Make sure the address is valid
1361
*/
1362
tmp_clock = *CAST_V4(peeraddr);
1363
if (
1364
#ifdef REFCLOCK
1365
!ISREFCLOCKADR(&tmp_clock) &&
1366
#endif
1367
ISBADADR(&tmp_clock)) {
1368
req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
1369
return;
1370
}
1371
1372
}
1373
NSRCPORT(&peeraddr) = htons(NTP_PORT);
1374
#ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR
1375
peeraddr.ss_len = SOCKLEN(&peeraddr);
1376
#endif
1377
1211
1378
/* XXX W2DO? minpoll/maxpoll arguments ??? */
1212
if (peer_config(&peeraddr, any_interface, cp->hmode,
1213
cp->version, cp->minpoll, cp->maxpoll, fl, cp->ttl,
1214
cp->keyid, cp->keystr) == 0) {
1379
if (peer_config(&peeraddr, (struct interface *)0,
1380
temp_cp.hmode, temp_cp.version, temp_cp.minpoll,
1381
temp_cp.maxpoll, fl, temp_cp.ttl, temp_cp.keyid,
1382
NULL) == 0) {
1215
1383
req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
1216
1384
return;
1217
1385
}
1218
cp++;
1386
cp = (struct conf_peer *)
1387
((char *)cp + INFO_ITEMSIZE(inpkt->mbz_itemsize));
1219
1388
}
1220
1389
1221
1390
req_ack(srcadr, inter, inpkt, INFO_OKAY);
1222
1391
}
1223
1392
1224
1393
#if 0
1394
/* XXX */
1225
1395
/*
1226
1396
* dns_a - Snarf DNS info for an association ID
1227
1397
*/
1228
1398
static void
1229
1399
dns_a(
1230
struct sockaddr_in *srcadr,
1400
struct sockaddr_storage *srcadr,
1231
1401
struct interface *inter,
1232
1402
struct req_pkt *inpkt
1233
1403
)
1294
1464
}
1295
1465
1296
1466
msyslog(LOG_INFO, "dns_a: <%s> for %s, AssocID %d, bogon %d",
1297
dp->hostname, inet_ntoa(peeraddr.sin_addr), associd,
1467
dp->hostname,
1468
stoa((struct sockaddr_storage *)&peeraddr), associd,
1298
1469
bogon);
1299
1470
1300
1471
if (bogon) {
1301
1472
/* If it didn't work */
1302
1473
req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
1308
1479
#endif /* PUBKEY */
1309
1480
#endif
1310
1481
}
1311
1482
1312
1483
dp++;
1313
1484
}
1314
1485
1315
1486
req_ack(srcadr, inter, inpkt, INFO_OKAY);
1316
1487
}
1317
1488
#endif /* 0 */
1318
1489
1319
1490
/*
1320
1491
* do_unconf - remove a peer from the configuration list
1321
1492
*/
1322
1493
static void
1323
1494
do_unconf(
1324
struct sockaddr_in *srcadr,
1495
struct sockaddr_storage *srcadr,
1325
1496
struct interface *inter,
1326
1497
struct req_pkt *inpkt
1327
1498
)
1328
1499
{
1329
1500
register struct conf_unpeer *cp;
1501
struct conf_unpeer temp_cp;
1330
1502
register int items;
1331
1503
register struct peer *peer;
1332
struct sockaddr_in peeraddr;
1504
struct sockaddr_storage peeraddr;
1333
1505
int bad, found;
1334
1506
1335
1507
/*
1338
1510
* configured. If so, we remove them. If not, we return
1339
1511
* an error.
1340
1512
*/
1341
peeraddr.sin_family = AF_INET;
1342
peeraddr.sin_port = htons(NTP_PORT);
1343
1344
1513
items = INFO_NITEMS(inpkt->err_nitems);
1345
1514
cp = (struct conf_unpeer *)inpkt->data;
1346
1515
1347
1516
bad = 0;
1348
1517
while (items-- > 0 && !bad) {
1349
peeraddr.sin_addr.s_addr = cp->peeraddr;
1518
memset(&temp_cp, 0, sizeof(temp_cp));
1519
memset(&peeraddr, 0, sizeof(peeraddr));
1520
memcpy(&temp_cp, cp, INFO_ITEMSIZE(inpkt->mbz_itemsize));
1521
if (client_v6_capable && temp_cp.v6_flag != 0) {
1522
peeraddr.ss_family = AF_INET6;
1523
GET_INADDR6(peeraddr) = temp_cp.peeraddr6;
1524
} else {
1525
peeraddr.ss_family = AF_INET;
1526
GET_INADDR(peeraddr) = temp_cp.peeraddr;
1527
}
1528
NSRCPORT(&peeraddr) = htons(NTP_PORT);
1529
#ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR
1530
peeraddr.ss_len = SOCKLEN(&peeraddr);
1531
#endif
1350
1532
found = 0;
1351
1533
peer = (struct peer *)0;
1534
printf("searching for %s\n", stoa(&peeraddr));
1352
1535
while (!found) {
1353
1536
peer = findexistingpeer(&peeraddr, peer, -1);
1354
1537
if (peer == (struct peer *)0)
1358
1541
}
1359
1542
if (!found)
1360
1543
bad = 1;
1361
cp++;
1544
cp = (struct conf_unpeer *)
1545
((char *)cp + INFO_ITEMSIZE(inpkt->mbz_itemsize));
1362
1546
}
1363
1547
1364
1548
if (bad) {
1373
1557
items = INFO_NITEMS(inpkt->err_nitems);
1374
1558
cp = (struct conf_unpeer *)inpkt->data;
1375
1559
while (items-- > 0) {
1376
peeraddr.sin_addr.s_addr = cp->peeraddr;
1560
memset(&temp_cp, 0, sizeof(temp_cp));
1561
memset(&peeraddr, 0, sizeof(peeraddr));
1562
memcpy(&temp_cp, cp, INFO_ITEMSIZE(inpkt->mbz_itemsize));
1563
if (client_v6_capable && temp_cp.v6_flag != 0) {
1564
peeraddr.ss_family = AF_INET6;
1565
GET_INADDR6(peeraddr) = temp_cp.peeraddr6;
1566
} else {
1567
peeraddr.ss_family = AF_INET;
1568
GET_INADDR(peeraddr) = temp_cp.peeraddr;
1569
}
1570
NSRCPORT(&peeraddr) = htons(NTP_PORT);
1571
#ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR
1572
peeraddr.ss_len = SOCKLEN(&peeraddr);
1573
#endif
1377
1574
peer_unconfig(&peeraddr, (struct interface *)0, -1);
1378
cp++;
1575
cp = (struct conf_unpeer *)
1576
((char *)cp + INFO_ITEMSIZE(inpkt->mbz_itemsize));
1379
1577
}
1380
1578
1381
1579
req_ack(srcadr, inter, inpkt, INFO_OKAY);
1387
1585
*/
1388
1586
static void
1389
1587
set_sys_flag(
1390
struct sockaddr_in *srcadr,
1588
struct sockaddr_storage *srcadr,
1391
1589
struct interface *inter,
1392
1590
struct req_pkt *inpkt
1393
1591
)
1401
1599
*/
1402
1600
static void
1403
1601
clr_sys_flag(
1404
struct sockaddr_in *srcadr,
1602
struct sockaddr_storage *srcadr,
1405
1603
struct interface *inter,
1406
1604
struct req_pkt *inpkt
1407
1605
)
1415
1613
*/
1416
1614
static void
1417
1615
setclr_flags(
1418
struct sockaddr_in *srcadr,
1616
struct sockaddr_storage *srcadr,
1419
1617
struct interface *inter,
1420
1618
struct req_pkt *inpkt,
1421
1619
u_long set
1433
1631
1434
1632
if (flags & ~(SYS_FLAG_BCLIENT | SYS_FLAG_PPS |
1435
1633
SYS_FLAG_NTP | SYS_FLAG_KERNEL | SYS_FLAG_MONITOR |
1436
SYS_FLAG_FILEGEN)) {
1634
SYS_FLAG_FILEGEN | SYS_FLAG_AUTH | SYS_FLAG_CAL)) {
1437
1635
msyslog(LOG_ERR, "setclr_flags: extra flags: %#x",
1438
flags & ~(SYS_FLAG_BCLIENT | SYS_FLAG_PPS |
1636
flags & ~(SYS_FLAG_BCLIENT | SYS_FLAG_PPS |
1439
1637
SYS_FLAG_NTP | SYS_FLAG_KERNEL |
1440
SYS_FLAG_MONITOR | SYS_FLAG_FILEGEN));
1638
SYS_FLAG_MONITOR | SYS_FLAG_FILEGEN |
1639
SYS_FLAG_AUTH | SYS_FLAG_CAL));
1441
1640
req_ack(srcadr, inter, inpkt, INFO_ERR_FMT);
1442
1641
return;
1443
1642
}
1444
1643
1445
1644
if (flags & SYS_FLAG_BCLIENT)
1446
proto_config(PROTO_BROADCLIENT, set, 0.);
1645
proto_config(PROTO_BROADCLIENT, set, 0., NULL);
1447
1646
if (flags & SYS_FLAG_PPS)
1448
proto_config(PROTO_PPS, set, 0.);
1647
proto_config(PROTO_PPS, set, 0., NULL);
1449
1648
if (flags & SYS_FLAG_NTP)
1450
proto_config(PROTO_NTP, set, 0.);
1649
proto_config(PROTO_NTP, set, 0., NULL);
1451
1650
if (flags & SYS_FLAG_KERNEL)
1452
proto_config(PROTO_KERNEL, set, 0.);
1651
proto_config(PROTO_KERNEL, set, 0., NULL);
1453
1652
if (flags & SYS_FLAG_MONITOR)
1454
proto_config(PROTO_MONITOR, set, 0.);
1653
proto_config(PROTO_MONITOR, set, 0., NULL);
1455
1654
if (flags & SYS_FLAG_FILEGEN)
1456
proto_config(PROTO_FILEGEN, set, 0.);
1655
proto_config(PROTO_FILEGEN, set, 0., NULL);
1656
if (flags & SYS_FLAG_AUTH)
1657
proto_config(PROTO_AUTHENTICATE, set, 0., NULL);
1658
if (flags & SYS_FLAG_CAL)
1659
proto_config(PROTO_CAL, set, 0., NULL);
1457
1660
req_ack(srcadr, inter, inpkt, INFO_OKAY);
1458
1661
}
1459
1662
1463
1666
*/
1464
1667
static void
1465
1668
list_restrict(
1466
struct sockaddr_in *srcadr,
1669
struct sockaddr_storage *srcadr,
1467
1670
struct interface *inter,
1468
1671
struct req_pkt *inpkt
1469
1672
)
1470
1673
{
1471
1674
register struct info_restrict *ir;
1472
1675
register struct restrictlist *rl;
1473
extern struct restrictlist *restrictlist;
1676
register struct restrictlist6 *rl6;
1474
1677
1475
1678
#ifdef DEBUG
1476
1679
if (debug > 2)
1477
printf("wants peer list summary\n");
1680
printf("wants restrict list summary\n");
1478
1681
#endif
1479
1682
1480
1683
ir = (struct info_restrict *)prepare_pkt(srcadr, inter, inpkt,
1481
sizeof(struct info_restrict));
1684
v6sizeof(struct info_restrict));
1685
1482
1686
for (rl = restrictlist; rl != 0 && ir != 0; rl = rl->next) {
1483
1687
ir->addr = htonl(rl->addr);
1688
if (client_v6_capable)
1689
ir->v6_flag = 0;
1484
1690
ir->mask = htonl(rl->mask);
1485
1691
ir->count = htonl((u_int32)rl->count);
1486
1692
ir->flags = htons(rl->flags);
1487
1693
ir->mflags = htons(rl->mflags);
1488
1694
ir = (struct info_restrict *)more_pkt();
1489
1695
}
1696
if (client_v6_capable)
1697
for (rl6 = restrictlist6; rl6 != 0 && ir != 0; rl6 = rl6->next) {
1698
ir->addr6 = rl6->addr6;
1699
ir->mask6 = rl6->mask6;
1700
ir->v6_flag = 1;
1701
ir->count = htonl((u_int32)rl6->count);
1702
ir->flags = htons(rl6->flags);
1703
ir->mflags = htons(rl6->mflags);
1704
ir = (struct info_restrict *)more_pkt();
1705
}
1490
1706
flush_pkt();
1491
1707
}
1492
1708
1497
1713
*/
1498
1714
static void
1499
1715
do_resaddflags(
1500
struct sockaddr_in *srcadr,
1716
struct sockaddr_storage *srcadr,
1501
1717
struct interface *inter,
1502
1718
struct req_pkt *inpkt
1503
1719
)
1512
1728
*/
1513
1729
static void
1514
1730
do_ressubflags(
1515
struct sockaddr_in *srcadr,
1731
struct sockaddr_storage *srcadr,
1516
1732
struct interface *inter,
1517
1733
struct req_pkt *inpkt
1518
1734
)
1526
1742
*/
1527
1743
static void
1528
1744
do_unrestrict(
1529
struct sockaddr_in *srcadr,
1745
struct sockaddr_storage *srcadr,
1530
1746
struct interface *inter,
1531
1747
struct req_pkt *inpkt
1532
1748
)
1543
1759
*/
1544
1760
static void
1545
1761
do_restrict(
1546
struct sockaddr_in *srcadr,
1762
struct sockaddr_storage *srcadr,
1547
1763
struct interface *inter,
1548
1764
struct req_pkt *inpkt,
1549
1765
int op
1551
1767
{
1552
1768
register struct conf_restrict *cr;
1553
1769
register int items;
1554
struct sockaddr_in matchaddr;
1555
struct sockaddr_in matchmask;
1770
struct sockaddr_storage matchaddr;
1771
struct sockaddr_storage matchmask;
1556
1772
int bad;
1557
1773
1558
1774
/*
1569
1785
bad |= 1;
1570
1786
if (cr->flags & ~(RES_ALLFLAGS))
1571
1787
bad |= 2;
1572
if (cr->addr == htonl(INADDR_ANY) && cr->mask != htonl(INADDR_ANY))
1573
bad |= 4;
1574
cr++;
1788
if (cr->mask != htonl(INADDR_ANY)) {
1789
if (client_v6_capable && cr->v6_flag != 0) {
1790
if (IN6_IS_ADDR_UNSPECIFIED(&cr->addr6))
1791
bad |= 4;
1792
} else
1793
if (cr->addr == htonl(INADDR_ANY))
1794
bad |= 8;
1795
}
1796
cr = (struct conf_restrict *)((char *)cr +
1797
INFO_ITEMSIZE(inpkt->mbz_itemsize));
1575
1798
}
1576
1799
1577
1800
if (bad) {
1585
1808
*/
1586
1809
items = INFO_NITEMS(inpkt->err_nitems);
1587
1810
cr = (struct conf_restrict *)inpkt->data;
1588
memset((char *)&matchaddr, 0, sizeof(struct sockaddr_in));
1589
memset((char *)&matchmask, 0, sizeof(struct sockaddr_in));
1590
matchaddr.sin_family = AF_INET;
1591
matchmask.sin_family = AF_INET;
1811
memset((char *)&matchaddr, 0, sizeof(struct sockaddr_storage));
1812
memset((char *)&matchmask, 0, sizeof(struct sockaddr_storage));
1592
1813
1593
1814
while (items-- > 0) {
1594
matchaddr.sin_addr.s_addr = cr->addr;
1595
matchmask.sin_addr.s_addr = cr->mask;
1815
if (client_v6_capable && cr->v6_flag != 0) {
1816
GET_INADDR6(matchaddr) = cr->addr6;
1817
GET_INADDR6(matchmask) = cr->mask6;
1818
matchaddr.ss_family = AF_INET6;
1819
matchmask.ss_family = AF_INET6;
1820
} else {
1821
GET_INADDR(matchaddr) = cr->addr;
1822
GET_INADDR(matchmask) = cr->mask;
1823
matchaddr.ss_family = AF_INET;
1824
matchmask.ss_family = AF_INET;
1825
}
1596
1826
hack_restrict(op, &matchaddr, &matchmask, cr->mflags,
1597
1827
cr->flags);
1598
1828
cr++;
1607
1837
*/
1608
1838
static void
1609
1839
mon_getlist_0(
1610
struct sockaddr_in *srcadr,
1840
struct sockaddr_storage *srcadr,
1611
1841
struct interface *inter,
1612
1842
struct req_pkt *inpkt
1613
1843
)
1625
1855
req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
1626
1856
return;
1627
1857
}
1628
1629
1858
im = (struct info_monitor *)prepare_pkt(srcadr, inter, inpkt,
1630
sizeof(struct info_monitor));
1859
v6sizeof(struct info_monitor));
1631
1860
for (md = mon_mru_list.mru_next; md != &mon_mru_list && im != 0;
1632
1861
md = md->mru_next) {
1633
im->lasttime = htonl((u_int32)(current_time - md->lasttime));
1634
im->firsttime = htonl((u_int32)(current_time - md->firsttime));
1635
if (md->lastdrop)
1636
im->lastdrop = htonl((u_int32)(current_time - md->lastdrop));
1637
else
1638
im->lastdrop = 0;
1862
im->lasttime = htonl((u_int32)md->avg_interval);
1863
im->firsttime = htonl((u_int32)(current_time - md->lasttime));
1864
im->lastdrop = htonl((u_int32)md->drop_count);
1639
1865
im->count = htonl((u_int32)(md->count));
1640
im->addr = md->rmtadr;
1866
if (md->rmtadr.ss_family == AF_INET6) {
1867
if (!client_v6_capable)
1868
continue;
1869
im->addr6 = GET_INADDR6(md->rmtadr);
1870
im->v6_flag = 1;
1871
} else {
1872
im->addr = GET_INADDR(md->rmtadr);
1873
if (client_v6_capable)
1874
im->v6_flag = 0;
1875
}
1641
1876
im->port = md->rmtport;
1642
1877
im->mode = md->mode;
1643
1878
im->version = md->version;
1651
1886
*/
1652
1887
static void
1653
1888
mon_getlist_1(
1654
struct sockaddr_in *srcadr,
1889
struct sockaddr_storage *srcadr,
1655
1890
struct interface *inter,
1656
1891
struct req_pkt *inpkt
1657
1892
)
1661
1896
extern struct mon_data mon_mru_list;
1662
1897
extern int mon_enabled;
1663
1898
1664
#ifdef DEBUG
1665
if (debug > 2)
1666
printf("wants monitor 1 list\n");
1667
#endif
1668
1899
if (!mon_enabled) {
1669
1900
req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
1670
1901
return;
1671
1902
}
1672
1673
1903
im = (struct info_monitor_1 *)prepare_pkt(srcadr, inter, inpkt,
1674
sizeof(struct info_monitor_1));
1904
v6sizeof(struct info_monitor_1));
1675
1905
for (md = mon_mru_list.mru_next; md != &mon_mru_list && im != 0;
1676
1906
md = md->mru_next) {
1677
im->lasttime = htonl((u_int32)(current_time - md->lasttime));
1678
im->firsttime = htonl((u_int32)(current_time - md->firsttime));
1679
if (md->lastdrop)
1680
im->lastdrop = htonl((u_int32)(current_time - md->lastdrop));
1681
else
1682
im->lastdrop = 0;
1907
im->lasttime = htonl((u_int32)md->avg_interval);
1908
im->firsttime = htonl((u_int32)(current_time - md->lasttime));
1909
im->lastdrop = htonl((u_int32)md->drop_count);
1683
1910
im->count = htonl((u_int32)md->count);
1684
im->addr = md->rmtadr;
1685
im->daddr =
1686
(md->cast_flags == MDF_BCAST)
1687
? md->interface->bcast.sin_addr.s_addr
1688
: (md->cast_flags
1689
? (md->interface->sin.sin_addr.s_addr
1690
? md->interface->sin.sin_addr.s_addr
1691
: md->interface->bcast.sin_addr.s_addr
1692
)
1693
: 4);
1911
if (md->rmtadr.ss_family == AF_INET6) {
1912
if (!client_v6_capable)
1913
continue;
1914
im->addr6 = GET_INADDR6(md->rmtadr);
1915
im->v6_flag = 1;
1916
im->daddr6 = GET_INADDR6(md->interface->sin);
1917
} else {
1918
im->addr = GET_INADDR(md->rmtadr);
1919
if (client_v6_capable)
1920
im->v6_flag = 0;
1921
im->daddr = (md->cast_flags == MDF_BCAST)
1922
? GET_INADDR(md->interface->bcast)
1923
: (md->cast_flags
1924
? (GET_INADDR(md->interface->sin)
1925
? GET_INADDR(md->interface->sin)
1926
: GET_INADDR(md->interface->bcast))
1927
: 4);
1928
}
1694
1929
im->flags = md->cast_flags;
1695
1930
im->port = md->rmtport;
1696
1931
im->mode = md->mode;
1724
1959
*/
1725
1960
static void
1726
1961
reset_stats(
1727
struct sockaddr_in *srcadr,
1962
struct sockaddr_storage *srcadr,
1728
1963
struct interface *inter,
1729
1964
struct req_pkt *inpkt
1730
1965
)
1760
1995
*/
1761
1996
static void
1762
1997
reset_peer(
1763
struct sockaddr_in *srcadr,
1998
struct sockaddr_storage *srcadr,
1764
1999
struct interface *inter,
1765
2000
struct req_pkt *inpkt
1766
2001
)
1768
2003
register struct conf_unpeer *cp;
1769
2004
register int items;
1770
2005
register struct peer *peer;
1771
struct sockaddr_in peeraddr;
2006
struct sockaddr_storage peeraddr;
1772
2007
int bad;
1773
2008
1774
2009
/*
1775
2010
* We check first to see that every peer exists. If not,
1776
2011
* we return an error.
1777
2012
*/
1778
peeraddr.sin_family = AF_INET;
1779
peeraddr.sin_port = htons(NTP_PORT);
1780
2013
1781
2014
items = INFO_NITEMS(inpkt->err_nitems);
1782
2015
cp = (struct conf_unpeer *)inpkt->data;
1783
2016
1784
2017
bad = 0;
1785
2018
while (items-- > 0 && !bad) {
1786
peeraddr.sin_addr.s_addr = cp->peeraddr;
2019
memset((char *)&peeraddr, 0, sizeof(peeraddr));
2020
if (client_v6_capable && cp->v6_flag != 0) {
2021
GET_INADDR6(peeraddr) = cp->peeraddr6;
2022
peeraddr.ss_family = AF_INET6;
2023
} else {
2024
GET_INADDR(peeraddr) = cp->peeraddr;
2025
peeraddr.ss_family = AF_INET;
2026
}
2027
NSRCPORT(&peeraddr) = htons(NTP_PORT);
2028
#ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR
2029
peeraddr.ss_len = SOCKLEN(&peeraddr);
2030
#endif
1787
2031
peer = findexistingpeer(&peeraddr, (struct peer *)0, -1);
1788
2032
if (peer == (struct peer *)0)
1789
2033
bad++;
1790
cp++;
2034
cp = (struct conf_unpeer *)((char *)cp +
2035
INFO_ITEMSIZE(inpkt->mbz_itemsize));
1791
2036
}
1792
2037
1793
2038
if (bad) {
1802
2047
items = INFO_NITEMS(inpkt->err_nitems);
1803
2048
cp = (struct conf_unpeer *)inpkt->data;
1804
2049
while (items-- > 0) {
1805
peeraddr.sin_addr.s_addr = cp->peeraddr;
2050
memset((char *)&peeraddr, 0, sizeof(peeraddr));
2051
if (client_v6_capable && cp->v6_flag != 0) {
2052
GET_INADDR6(peeraddr) = cp->peeraddr6;
2053
peeraddr.ss_family = AF_INET6;
2054
} else {
2055
GET_INADDR(peeraddr) = cp->peeraddr;
2056
peeraddr.ss_family = AF_INET;
2057
}
2058
#ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR
2059
peeraddr.ss_len = SOCKLEN(&peeraddr);
2060
#endif
1806
2061
peer = findexistingpeer(&peeraddr, (struct peer *)0, -1);
1807
2062
while (peer != 0) {
1808
2063
peer_reset(peer);
1809
2064
peer = findexistingpeer(&peeraddr, (struct peer *)peer, -1);
1810
2065
}
1811
cp++;
2066
cp = (struct conf_unpeer *)((char *)cp +
2067
INFO_ITEMSIZE(inpkt->mbz_itemsize));
1812
2068
}
1813
2069
1814
2070
req_ack(srcadr, inter, inpkt, INFO_OKAY);
1820
2076
*/
1821
2077
static void
1822
2078
do_key_reread(
1823
struct sockaddr_in *srcadr,
2079
struct sockaddr_storage *srcadr,
1824
2080
struct interface *inter,
1825
2081
struct req_pkt *inpkt
1826
2082
)
1835
2091
*/
1836
2092
static void
1837
2093
trust_key(
1838
struct sockaddr_in *srcadr,
2094
struct sockaddr_storage *srcadr,
1839
2095
struct interface *inter,
1840
2096
struct req_pkt *inpkt
1841
2097
)
1849
2105
*/
1850
2106
static void
1851
2107
untrust_key(
1852
struct sockaddr_in *srcadr,
2108
struct sockaddr_storage *srcadr,
1853
2109
struct interface *inter,
1854
2110
struct req_pkt *inpkt
1855
2111
)
1863
2119
*/
1864
2120
static void
1865
2121
do_trustkey(
1866
struct sockaddr_in *srcadr,
2122
struct sockaddr_storage *srcadr,
1867
2123
struct interface *inter,
1868
2124
struct req_pkt *inpkt,
1869
2125
u_long trust
1888
2144
*/
1889
2145
static void
1890
2146
get_auth_info(
1891
struct sockaddr_in *srcadr,
2147
struct sockaddr_storage *srcadr,
1892
2148
struct interface *inter,
1893
2149
struct req_pkt *inpkt
1894
2150
)
1956
2212
*/
1957
2213
static void
1958
2214
req_get_traps(
1959
struct sockaddr_in *srcadr,
2215
struct sockaddr_storage *srcadr,
1960
2216
struct interface *inter,
1961
2217
struct req_pkt *inpkt
1962
2218
)
1977
2233
}
1978
2234
1979
2235
it = (struct info_trap *)prepare_pkt(srcadr, inter, inpkt,
1980
sizeof(struct info_trap));
2236
v6sizeof(struct info_trap));
1981
2237
1982
2238
for (i = 0, tr = ctl_trap; i < CTL_MAXTRAPS; i++, tr++) {
1983
2239
if (tr->tr_flags & TRAP_INUSE) {
1984
if (tr->tr_localaddr == any_interface)
1985
it->local_address = 0;
1986
else
1987
it->local_address
1988
= NSRCADR(&tr->tr_localaddr->sin);
1989
it->trap_address = NSRCADR(&tr->tr_addr);
2240
if (tr->tr_addr.ss_family == AF_INET) {
2241
if (tr->tr_localaddr == any_interface)
2242
it->local_address = 0;
2243
else
2244
it->local_address
2245
= GET_INADDR(tr->tr_localaddr->sin);
2246
it->trap_address = GET_INADDR(tr->tr_addr);
2247
if (client_v6_capable)
2248
it->v6_flag = 0;
2249
} else {
2250
if (!client_v6_capable)
2251
continue;
2252
it->local_address6
2253
= GET_INADDR6(tr->tr_localaddr->sin);
2254
it->trap_address6 = GET_INADDR6(tr->tr_addr);
2255
it->v6_flag = 1;
2256
}
1990
2257
it->trap_port = NSRCPORT(&tr->tr_addr);
1991
2258
it->sequence = htons(tr->tr_sequence);
1992
2259
it->settime = htonl((u_int32)(current_time - tr->tr_settime));
2005
2272
*/
2006
2273
static void
2007
2274
req_set_trap(
2008
struct sockaddr_in *srcadr,
2275
struct sockaddr_storage *srcadr,
2009
2276
struct interface *inter,
2010
2277
struct req_pkt *inpkt
2011
2278
)
2020
2287
*/
2021
2288
static void
2022
2289
req_clr_trap(
2023
struct sockaddr_in *srcadr,
2290
struct sockaddr_storage *srcadr,
2024
2291
struct interface *inter,
2025
2292
struct req_pkt *inpkt
2026
2293
)
2035
2302
*/
2036
2303
static void
2037
2304
do_setclr_trap(
2038
struct sockaddr_in *srcadr,
2305
struct sockaddr_storage *srcadr,
2039
2306
struct interface *inter,
2040
2307
struct req_pkt *inpkt,
2041
2308
int set
2044
2311
register struct conf_trap *ct;
2045
2312
register struct interface *linter;
2046
2313
int res;
2047
struct sockaddr_in laddr;
2314
struct sockaddr_storage laddr;
2048
2315
2049
2316
/*
2050
* Prepare sockaddr_in structure
2317
* Prepare sockaddr_storage structure
2051
2318
*/
2052
2319
memset((char *)&laddr, 0, sizeof laddr);
2053
laddr.sin_family = AF_INET;
2054
laddr.sin_port = ntohs(NTP_PORT);
2320
laddr.ss_family = srcadr->ss_family;
2321
NSRCPORT(&laddr) = ntohs(NTP_PORT);
2055
2322
2056
2323
/*
2057
2324
* Restrict ourselves to one item only. This eliminates
2070
2337
if (ct->local_address == 0) {
2071
2338
linter = any_interface;
2072
2339
} else {
2073
laddr.sin_addr.s_addr = ct->local_address;
2340
if (laddr.ss_family == AF_INET)
2341
GET_INADDR(laddr) = ct->local_address;
2342
else
2343
GET_INADDR6(laddr) = ct->local_address6;
2074
2344
linter = findinterface(&laddr);
2075
2345
if (linter == NULL) {
2076
2346
req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
2078
2348
}
2079
2349
}
2080
2350
2081
laddr.sin_addr.s_addr = ct->trap_address;
2351
if (laddr.ss_family == AF_INET)
2352
GET_INADDR(laddr) = ct->trap_address;
2353
else
2354
GET_INADDR6(laddr) = ct->trap_address6;
2082
2355
if (ct->trap_port != 0)
2083
laddr.sin_port = ct->trap_port;
2356
NSRCPORT(&laddr) = ct->trap_port;
2084
2357
else
2085
laddr.sin_port = htons(TRAPPORT);
2358
NSRCPORT(&laddr) = htons(TRAPPORT);
2086
2359
2087
2360
if (set) {
2088
2361
res = ctlsettrap(&laddr, linter, 0,
2106
2379
*/
2107
2380
static void
2108
2381
set_request_keyid(
2109
struct sockaddr_in *srcadr,
2382
struct sockaddr_storage *srcadr,
2110
2383
struct interface *inter,
2111
2384
struct req_pkt *inpkt
2112
2385
)
2134
2407
*/
2135
2408
static void
2136
2409
set_control_keyid(
2137
struct sockaddr_in *srcadr,
2410
struct sockaddr_storage *srcadr,
2138
2411
struct interface *inter,
2139
2412
struct req_pkt *inpkt
2140
2413
)
2163
2436
*/
2164
2437
static void
2165
2438
get_ctl_stats(
2166
struct sockaddr_in *srcadr,
2439
struct sockaddr_storage *srcadr,
2167
2440
struct interface *inter,
2168
2441
struct req_pkt *inpkt
2169
2442
)
2219
2492
*/
2220
2493
static void
2221
2494
get_kernel_info(
2222
struct sockaddr_in *srcadr,
2495
struct sockaddr_storage *srcadr,
2223
2496
struct interface *inter,
2224
2497
struct req_pkt *inpkt
2225
2498
)
2274
2547
*/
2275
2548
static void
2276
2549
get_clock_info(
2277
struct sockaddr_in *srcadr,
2550
struct sockaddr_storage *srcadr,
2278
2551
struct interface *inter,
2279
2552
struct req_pkt *inpkt
2280
2553
)
2283
2556
register u_int32 *clkaddr;
2284
2557
register int items;
2285
2558
struct refclockstat clock_stat;
2286
struct sockaddr_in addr;
2559
struct sockaddr_storage addr;
2560
struct sockaddr_in tmp_clock;
2287
2561
l_fp ltmp;
2288
2562
2289
2563
memset((char *)&addr, 0, sizeof addr);
2290
addr.sin_family = AF_INET;
2291
addr.sin_port = htons(NTP_PORT);
2564
addr.ss_family = AF_INET;
2565
#ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR
2566
addr.ss_len = SOCKLEN(&addr);
2567
#endif
2568
NSRCPORT(&addr) = htons(NTP_PORT);
2292
2569
items = INFO_NITEMS(inpkt->err_nitems);
2293
2570
clkaddr = (u_int32 *) inpkt->data;
2294
2571
2296
2573
sizeof(struct info_clock));
2297
2574
2298
2575
while (items-- > 0) {
2299
addr.sin_addr.s_addr = *clkaddr++;
2300
if (!ISREFCLOCKADR(&addr) ||
2576
tmp_clock.sin_addr.s_addr = *clkaddr++;
2577
CAST_V4(addr)->sin_addr = tmp_clock.sin_addr;
2578
if (!ISREFCLOCKADR(&tmp_clock) ||
2301
2579
findexistingpeer(&addr, (struct peer *)0, -1) == 0) {
2302
2580
req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
2303
2581
return;
2307
2585
2308
2586
refclock_control(&addr, (struct refclockstat *)0, &clock_stat);
2309
2587
2310
ic->clockadr = addr.sin_addr.s_addr;
2588
ic->clockadr = tmp_clock.sin_addr.s_addr;
2311
2589
ic->type = clock_stat.type;
2312
2590
ic->flags = clock_stat.flags;
2313
2591
ic->lastevent = clock_stat.lastevent;
2319
2597
ic->timestarted = htonl((u_int32)clock_stat.timereset);
2320
2598
DTOLFP(clock_stat.fudgetime1, <mp);
2321
2599
HTONL_FP(<mp, &ic->fudgetime1);
2322
DTOLFP(clock_stat.fudgetime1, <mp);
2600
DTOLFP(clock_stat.fudgetime2, <mp);
2323
2601
HTONL_FP(<mp, &ic->fudgetime2);
2324
2602
ic->fudgeval1 = htonl((u_int32)clock_stat.fudgeval1);
2325
2603
ic->fudgeval2 = htonl((u_int32)clock_stat.fudgeval2);
2338
2616
*/
2339
2617
static void
2340
2618
set_clock_fudge(
2341
struct sockaddr_in *srcadr,
2619
struct sockaddr_storage *srcadr,
2342
2620
struct interface *inter,
2343
2621
struct req_pkt *inpkt
2344
2622
)
2346
2624
register struct conf_fudge *cf;
2347
2625
register int items;
2348
2626
struct refclockstat clock_stat;
2349
struct sockaddr_in addr;
2627
struct sockaddr_storage addr;
2628
struct sockaddr_in tmp_clock;
2350
2629
l_fp ltmp;
2351
2630
2352
2631
memset((char *)&addr, 0, sizeof addr);
2353
2632
memset((char *)&clock_stat, 0, sizeof clock_stat);
2354
addr.sin_family = AF_INET;
2355
addr.sin_port = htons(NTP_PORT);
2356
2633
items = INFO_NITEMS(inpkt->err_nitems);
2357
2634
cf = (struct conf_fudge *) inpkt->data;
2358
2635
2359
2636
while (items-- > 0) {
2360
addr.sin_addr.s_addr = cf->clockadr;
2361
if (!ISREFCLOCKADR(&addr) ||
2637
tmp_clock.sin_addr.s_addr = cf->clockadr;
2638
*CAST_V4(addr) = tmp_clock;
2639
addr.ss_family = AF_INET;
2640
#ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR
2641
addr.ss_len = SOCKLEN(&addr);
2642
#endif
2643
NSRCPORT(&addr) = htons(NTP_PORT);
2644
if (!ISREFCLOCKADR(&tmp_clock) ||
2362
2645
findexistingpeer(&addr, (struct peer *)0, -1) == 0) {
2363
2646
req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
2364
2647
return;
2384
2667
clock_stat.haveflags = CLK_HAVEVAL2;
2385
2668
break;
2386
2669
case FUDGE_FLAGS:
2387
clock_stat.flags = (u_char) ntohl(cf->fudgeval_flags) & 0xf;
2670
clock_stat.flags = (u_char) (ntohl(cf->fudgeval_flags) & 0xf);
2388
2671
clock_stat.haveflags =
2389
2672
(CLK_HAVEFLAG1|CLK_HAVEFLAG2|CLK_HAVEFLAG3|CLK_HAVEFLAG4);
2390
2673
break;
2407
2690
*/
2408
2691
static void
2409
2692
get_clkbug_info(
2410
struct sockaddr_in *srcadr,
2693
struct sockaddr_storage *srcadr,
2411
2694
struct interface *inter,
2412
2695
struct req_pkt *inpkt
2413
2696
)
2417
2700
register u_int32 *clkaddr;
2418
2701
register int items;
2419
2702
struct refclockbug bug;
2420
struct sockaddr_in addr;
2703
struct sockaddr_storage addr;
2704
struct sockaddr_in tmp_clock;
2421
2705
2422
2706
memset((char *)&addr, 0, sizeof addr);
2423
addr.sin_family = AF_INET;
2424
addr.sin_port = htons(NTP_PORT);
2707
addr.ss_family = AF_INET;
2708
#ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR
2709
addr.ss_len = SOCKLEN(&addr);
2710
#endif
2711
NSRCPORT(&addr) = htons(NTP_PORT);
2425
2712
items = INFO_NITEMS(inpkt->err_nitems);
2426
2713
clkaddr = (u_int32 *) inpkt->data;
2427
2714
2429
2716
sizeof(struct info_clkbug));
2430
2717
2431
2718
while (items-- > 0) {
2432
addr.sin_addr.s_addr = *clkaddr++;
2433
if (!ISREFCLOCKADR(&addr) ||
2719
tmp_clock.sin_addr.s_addr = *clkaddr++;
2720
GET_INADDR(addr) = tmp_clock.sin_addr.s_addr;
2721
if (!ISREFCLOCKADR(&tmp_clock) ||
2434
2722
findexistingpeer(&addr, (struct peer *)0, -1) == 0) {
2435
2723
req_ack(srcadr, inter, inpkt, INFO_ERR_NODATA);
2436
2724
return;
2443
2731
return;
2444
2732
}
2445
2733
2446
ic->clockadr = addr.sin_addr.s_addr;
2734
ic->clockadr = tmp_clock.sin_addr.s_addr;
2447
2735
i = bug.nvalues;
2448
2736
if (i > NUMCBUGVALUES)
2449
2737
i = NUMCBUGVALUES;
Loggerhead is a web-based interface for Breezy
Version: 2.0.1