diff options
-rw-r--r-- | plugins/check_ntp_time.c | 571 |
1 files changed, 298 insertions, 273 deletions
diff --git a/plugins/check_ntp_time.c b/plugins/check_ntp_time.c index b2e1655..34cc81d 100644 --- a/plugins/check_ntp_time.c +++ b/plugins/check_ntp_time.c | |||
@@ -1,38 +1,38 @@ | |||
1 | /***************************************************************************** | 1 | /***************************************************************************** |
2 | * | 2 | * |
3 | * Monitoring check_ntp_time plugin | 3 | * Monitoring check_ntp_time plugin |
4 | * | 4 | * |
5 | * License: GPL | 5 | * License: GPL |
6 | * Copyright (c) 2006 Sean Finney <seanius@seanius.net> | 6 | * Copyright (c) 2006 Sean Finney <seanius@seanius.net> |
7 | * Copyright (c) 2006-2008 Monitoring Plugins Development Team | 7 | * Copyright (c) 2006-2008 Monitoring Plugins Development Team |
8 | * | 8 | * |
9 | * Description: | 9 | * Description: |
10 | * | 10 | * |
11 | * This file contains the check_ntp_time plugin | 11 | * This file contains the check_ntp_time plugin |
12 | * | 12 | * |
13 | * This plugin checks the clock offset between the local host and a | 13 | * This plugin checks the clock offset between the local host and a |
14 | * remote NTP server. It is independent of any commandline programs or | 14 | * remote NTP server. It is independent of any commandline programs or |
15 | * external libraries. | 15 | * external libraries. |
16 | * | 16 | * |
17 | * If you'd rather want to monitor an NTP server, please use | 17 | * If you'd rather want to monitor an NTP server, please use |
18 | * check_ntp_peer. | 18 | * check_ntp_peer. |
19 | * | 19 | * |
20 | * | 20 | * |
21 | * This program is free software: you can redistribute it and/or modify | 21 | * This program is free software: you can redistribute it and/or modify |
22 | * it under the terms of the GNU General Public License as published by | 22 | * it under the terms of the GNU General Public License as published by |
23 | * the Free Software Foundation, either version 3 of the License, or | 23 | * the Free Software Foundation, either version 3 of the License, or |
24 | * (at your option) any later version. | 24 | * (at your option) any later version. |
25 | * | 25 | * |
26 | * This program is distributed in the hope that it will be useful, | 26 | * This program is distributed in the hope that it will be useful, |
27 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | 27 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
28 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | 28 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
29 | * GNU General Public License for more details. | 29 | * GNU General Public License for more details. |
30 | * | 30 | * |
31 | * You should have received a copy of the GNU General Public License | 31 | * You should have received a copy of the GNU General Public License |
32 | * along with this program. If not, see <http://www.gnu.org/licenses/>. | 32 | * along with this program. If not, see <http://www.gnu.org/licenses/>. |
33 | * | 33 | * |
34 | * | 34 | * |
35 | *****************************************************************************/ | 35 | *****************************************************************************/ |
36 | 36 | ||
37 | const char *progname = "check_ntp_time"; | 37 | const char *progname = "check_ntp_time"; |
38 | const char *copyright = "2006-2008"; | 38 | const char *copyright = "2006-2008"; |
@@ -42,22 +42,22 @@ const char *email = "devel@monitoring-plugins.org"; | |||
42 | #include "netutils.h" | 42 | #include "netutils.h" |
43 | #include "utils.h" | 43 | #include "utils.h" |
44 | 44 | ||
45 | static char *server_address=NULL; | 45 | static char *server_address = NULL; |
46 | static char *port="123"; | 46 | static char *port = "123"; |
47 | static int verbose=0; | 47 | static int verbose = 0; |
48 | static bool quiet = false; | 48 | static bool quiet = false; |
49 | static char *owarn="60"; | 49 | static char *owarn = "60"; |
50 | static char *ocrit="120"; | 50 | static char *ocrit = "120"; |
51 | static int time_offset=0; | 51 | static int time_offset = 0; |
52 | 52 | ||
53 | int process_arguments (int, char **); | 53 | int process_arguments(int, char **); |
54 | thresholds *offset_thresholds = NULL; | 54 | thresholds *offset_thresholds = NULL; |
55 | void print_help (void); | 55 | void print_help(void); |
56 | void print_usage (void); | 56 | void print_usage(void); |
57 | 57 | ||
58 | /* number of times to perform each request to get a good average. */ | 58 | /* number of times to perform each request to get a good average. */ |
59 | #ifndef AVG_NUM | 59 | #ifndef AVG_NUM |
60 | #define AVG_NUM 4 | 60 | # define AVG_NUM 4 |
61 | #endif | 61 | #endif |
62 | 62 | ||
63 | /* max size of control message data */ | 63 | /* max size of control message data */ |
@@ -65,17 +65,17 @@ void print_usage (void); | |||
65 | 65 | ||
66 | /* this structure holds everything in an ntp request/response as per rfc1305 */ | 66 | /* this structure holds everything in an ntp request/response as per rfc1305 */ |
67 | typedef struct { | 67 | typedef struct { |
68 | uint8_t flags; /* byte with leapindicator,vers,mode. see macros */ | 68 | uint8_t flags; /* byte with leapindicator,vers,mode. see macros */ |
69 | uint8_t stratum; /* clock stratum */ | 69 | uint8_t stratum; /* clock stratum */ |
70 | int8_t poll; /* polling interval */ | 70 | int8_t poll; /* polling interval */ |
71 | int8_t precision; /* precision of the local clock */ | 71 | int8_t precision; /* precision of the local clock */ |
72 | int32_t rtdelay; /* total rt delay, as a fixed point num. see macros */ | 72 | int32_t rtdelay; /* total rt delay, as a fixed point num. see macros */ |
73 | uint32_t rtdisp; /* like above, but for max err to primary src */ | 73 | uint32_t rtdisp; /* like above, but for max err to primary src */ |
74 | uint32_t refid; /* ref clock identifier */ | 74 | uint32_t refid; /* ref clock identifier */ |
75 | uint64_t refts; /* reference timestamp. local time local clock */ | 75 | uint64_t refts; /* reference timestamp. local time local clock */ |
76 | uint64_t origts; /* time at which request departed client */ | 76 | uint64_t origts; /* time at which request departed client */ |
77 | uint64_t rxts; /* time at which request arrived at server */ | 77 | uint64_t rxts; /* time at which request arrived at server */ |
78 | uint64_t txts; /* time at which request departed server */ | 78 | uint64_t txts; /* time at which request departed server */ |
79 | } ntp_message; | 79 | } ntp_message; |
80 | 80 | ||
81 | /* this structure holds data about results from querying offset from a peer */ | 81 | /* this structure holds data about results from querying offset from a peer */ |
@@ -86,43 +86,55 @@ typedef struct { | |||
86 | double rtdelay; /* converted from the ntp_message */ | 86 | double rtdelay; /* converted from the ntp_message */ |
87 | double rtdisp; /* converted from the ntp_message */ | 87 | double rtdisp; /* converted from the ntp_message */ |
88 | double offset[AVG_NUM]; /* offsets from each response */ | 88 | double offset[AVG_NUM]; /* offsets from each response */ |
89 | uint8_t flags; /* byte with leapindicator,vers,mode. see macros */ | 89 | uint8_t flags; /* byte with leapindicator,vers,mode. see macros */ |
90 | } ntp_server_results; | 90 | } ntp_server_results; |
91 | 91 | ||
92 | /* bits 1,2 are the leap indicator */ | 92 | /* bits 1,2 are the leap indicator */ |
93 | #define LI_MASK 0xc0 | 93 | #define LI_MASK 0xc0 |
94 | #define LI(x) ((x&LI_MASK)>>6) | 94 | #define LI(x) ((x & LI_MASK) >> 6) |
95 | #define LI_SET(x,y) do{ x |= ((y<<6)&LI_MASK); }while(0) | 95 | #define LI_SET(x, y) \ |
96 | do { \ | ||
97 | x |= ((y << 6) & LI_MASK); \ | ||
98 | } while (0) | ||
96 | /* and these are the values of the leap indicator */ | 99 | /* and these are the values of the leap indicator */ |
97 | #define LI_NOWARNING 0x00 | 100 | #define LI_NOWARNING 0x00 |
98 | #define LI_EXTRASEC 0x01 | 101 | #define LI_EXTRASEC 0x01 |
99 | #define LI_MISSINGSEC 0x02 | 102 | #define LI_MISSINGSEC 0x02 |
100 | #define LI_ALARM 0x03 | 103 | #define LI_ALARM 0x03 |
101 | /* bits 3,4,5 are the ntp version */ | 104 | /* bits 3,4,5 are the ntp version */ |
102 | #define VN_MASK 0x38 | 105 | #define VN_MASK 0x38 |
103 | #define VN(x) ((x&VN_MASK)>>3) | 106 | #define VN(x) ((x & VN_MASK) >> 3) |
104 | #define VN_SET(x,y) do{ x |= ((y<<3)&VN_MASK); }while(0) | 107 | #define VN_SET(x, y) \ |
108 | do { \ | ||
109 | x |= ((y << 3) & VN_MASK); \ | ||
110 | } while (0) | ||
105 | #define VN_RESERVED 0x02 | 111 | #define VN_RESERVED 0x02 |
106 | /* bits 6,7,8 are the ntp mode */ | 112 | /* bits 6,7,8 are the ntp mode */ |
107 | #define MODE_MASK 0x07 | 113 | #define MODE_MASK 0x07 |
108 | #define MODE(x) (x&MODE_MASK) | 114 | #define MODE(x) (x & MODE_MASK) |
109 | #define MODE_SET(x,y) do{ x |= (y&MODE_MASK); }while(0) | 115 | #define MODE_SET(x, y) \ |
116 | do { \ | ||
117 | x |= (y & MODE_MASK); \ | ||
118 | } while (0) | ||
110 | /* here are some values */ | 119 | /* here are some values */ |
111 | #define MODE_CLIENT 0x03 | 120 | #define MODE_CLIENT 0x03 |
112 | #define MODE_CONTROLMSG 0x06 | 121 | #define MODE_CONTROLMSG 0x06 |
113 | /* In control message, bits 8-10 are R,E,M bits */ | 122 | /* In control message, bits 8-10 are R,E,M bits */ |
114 | #define REM_MASK 0xe0 | 123 | #define REM_MASK 0xe0 |
115 | #define REM_RESP 0x80 | 124 | #define REM_RESP 0x80 |
116 | #define REM_ERROR 0x40 | 125 | #define REM_ERROR 0x40 |
117 | #define REM_MORE 0x20 | 126 | #define REM_MORE 0x20 |
118 | /* In control message, bits 11 - 15 are opcode */ | 127 | /* In control message, bits 11 - 15 are opcode */ |
119 | #define OP_MASK 0x1f | 128 | #define OP_MASK 0x1f |
120 | #define OP_SET(x,y) do{ x |= (y&OP_MASK); }while(0) | 129 | #define OP_SET(x, y) \ |
130 | do { \ | ||
131 | x |= (y & OP_MASK); \ | ||
132 | } while (0) | ||
121 | #define OP_READSTAT 0x01 | 133 | #define OP_READSTAT 0x01 |
122 | #define OP_READVAR 0x02 | 134 | #define OP_READVAR 0x02 |
123 | /* In peer status bytes, bits 6,7,8 determine clock selection status */ | 135 | /* In peer status bytes, bits 6,7,8 determine clock selection status */ |
124 | #define PEER_SEL(x) ((ntohs(x)>>8)&0x07) | 136 | #define PEER_SEL(x) ((ntohs(x) >> 8) & 0x07) |
125 | #define PEER_INCLUDED 0x04 | 137 | #define PEER_INCLUDED 0x04 |
126 | #define PEER_SYNCSOURCE 0x06 | 138 | #define PEER_SYNCSOURCE 0x06 |
127 | 139 | ||
128 | /** | 140 | /** |
@@ -136,82 +148,89 @@ typedef struct { | |||
136 | 148 | ||
137 | /* macros to access the left/right 16 bits of a 32-bit ntp "fixed point" | 149 | /* macros to access the left/right 16 bits of a 32-bit ntp "fixed point" |
138 | number. note that these can be used as lvalues too */ | 150 | number. note that these can be used as lvalues too */ |
139 | #define L16(x) (((uint16_t*)&x)[0]) | 151 | #define L16(x) (((uint16_t *)&x)[0]) |
140 | #define R16(x) (((uint16_t*)&x)[1]) | 152 | #define R16(x) (((uint16_t *)&x)[1]) |
141 | /* macros to access the left/right 32 bits of a 64-bit ntp "fixed point" | 153 | /* macros to access the left/right 32 bits of a 64-bit ntp "fixed point" |
142 | number. these too can be used as lvalues */ | 154 | number. these too can be used as lvalues */ |
143 | #define L32(x) (((uint32_t*)&x)[0]) | 155 | #define L32(x) (((uint32_t *)&x)[0]) |
144 | #define R32(x) (((uint32_t*)&x)[1]) | 156 | #define R32(x) (((uint32_t *)&x)[1]) |
145 | 157 | ||
146 | /* ntp wants seconds since 1/1/00, epoch is 1/1/70. this is the difference */ | 158 | /* ntp wants seconds since 1/1/00, epoch is 1/1/70. this is the difference */ |
147 | #define EPOCHDIFF 0x83aa7e80UL | 159 | #define EPOCHDIFF 0x83aa7e80UL |
148 | 160 | ||
149 | /* extract a 32-bit ntp fixed point number into a double */ | 161 | /* extract a 32-bit ntp fixed point number into a double */ |
150 | #define NTP32asDOUBLE(x) (ntohs(L16(x)) + (double)ntohs(R16(x))/65536.0) | 162 | #define NTP32asDOUBLE(x) (ntohs(L16(x)) + (double)ntohs(R16(x)) / 65536.0) |
151 | 163 | ||
152 | /* likewise for a 64-bit ntp fp number */ | 164 | /* likewise for a 64-bit ntp fp number */ |
153 | #define NTP64asDOUBLE(n) (double)(((uint64_t)n)?\ | 165 | #define NTP64asDOUBLE(n) \ |
154 | (ntohl(L32(n))-EPOCHDIFF) + \ | 166 | (double)(((uint64_t)n) ? (ntohl(L32(n)) - EPOCHDIFF) + (.00000001 * (0.5 + (double)(ntohl(R32(n)) / 42.94967296))) : 0) |
155 | (.00000001*(0.5+(double)(ntohl(R32(n))/42.94967296))):\ | ||
156 | 0) | ||
157 | 167 | ||
158 | /* convert a struct timeval to a double */ | 168 | /* convert a struct timeval to a double */ |
159 | #define TVasDOUBLE(x) (double)(x.tv_sec+(0.000001*x.tv_usec)) | 169 | #define TVasDOUBLE(x) (double)(x.tv_sec + (0.000001 * x.tv_usec)) |
160 | 170 | ||
161 | /* convert an ntp 64-bit fp number to a struct timeval */ | 171 | /* convert an ntp 64-bit fp number to a struct timeval */ |
162 | #define NTP64toTV(n,t) \ | 172 | #define NTP64toTV(n, t) \ |
163 | do{ if(!n) t.tv_sec = t.tv_usec = 0; \ | 173 | do { \ |
164 | else { \ | 174 | if (!n) \ |
165 | t.tv_sec=ntohl(L32(n))-EPOCHDIFF; \ | 175 | t.tv_sec = t.tv_usec = 0; \ |
166 | t.tv_usec=(int)(0.5+(double)(ntohl(R32(n))/4294.967296)); \ | 176 | else { \ |
167 | } \ | 177 | t.tv_sec = ntohl(L32(n)) - EPOCHDIFF; \ |
168 | }while(0) | 178 | t.tv_usec = (int)(0.5 + (double)(ntohl(R32(n)) / 4294.967296)); \ |
179 | } \ | ||
180 | } while (0) | ||
169 | 181 | ||
170 | /* convert a struct timeval to an ntp 64-bit fp number */ | 182 | /* convert a struct timeval to an ntp 64-bit fp number */ |
171 | #define TVtoNTP64(t,n) \ | 183 | #define TVtoNTP64(t, n) \ |
172 | do{ if(!t.tv_usec && !t.tv_sec) n=0x0UL; \ | 184 | do { \ |
173 | else { \ | 185 | if (!t.tv_usec && !t.tv_sec) \ |
174 | L32(n)=htonl(t.tv_sec + EPOCHDIFF); \ | 186 | n = 0x0UL; \ |
175 | R32(n)=htonl((uint64_t)((4294.967296*t.tv_usec)+.5)); \ | 187 | else { \ |
176 | } \ | 188 | L32(n) = htonl(t.tv_sec + EPOCHDIFF); \ |
177 | } while(0) | 189 | R32(n) = htonl((uint64_t)((4294.967296 * t.tv_usec) + .5)); \ |
190 | } \ | ||
191 | } while (0) | ||
178 | 192 | ||
179 | /* NTP control message header is 12 bytes, plus any data in the data | 193 | /* NTP control message header is 12 bytes, plus any data in the data |
180 | * field, plus null padding to the nearest 32-bit boundary per rfc. | 194 | * field, plus null padding to the nearest 32-bit boundary per rfc. |
181 | */ | 195 | */ |
182 | #define SIZEOF_NTPCM(m) (12+ntohs(m.count)+((m.count)?4-(ntohs(m.count)%4):0)) | 196 | #define SIZEOF_NTPCM(m) (12 + ntohs(m.count) + ((m.count) ? 4 - (ntohs(m.count) % 4) : 0)) |
183 | 197 | ||
184 | /* finally, a little helper or two for debugging: */ | 198 | /* finally, a little helper or two for debugging: */ |
185 | #define DBG(x) do{if(verbose>1){ x; }}while(0); | 199 | #define DBG(x) \ |
186 | #define PRINTSOCKADDR(x) \ | 200 | do { \ |
187 | do{ \ | 201 | if (verbose > 1) { \ |
188 | printf("%u.%u.%u.%u", (x>>24)&0xff, (x>>16)&0xff, (x>>8)&0xff, x&0xff);\ | 202 | x; \ |
189 | }while(0); | 203 | } \ |
204 | } while (0); | ||
205 | #define PRINTSOCKADDR(x) \ | ||
206 | do { \ | ||
207 | printf("%u.%u.%u.%u", (x >> 24) & 0xff, (x >> 16) & 0xff, (x >> 8) & 0xff, x & 0xff); \ | ||
208 | } while (0); | ||
190 | 209 | ||
191 | /* calculate the offset of the local clock */ | 210 | /* calculate the offset of the local clock */ |
192 | static inline double calc_offset(const ntp_message *m, const struct timeval *t){ | 211 | static inline double calc_offset(const ntp_message *m, const struct timeval *t) { |
193 | double client_tx, peer_rx, peer_tx, client_rx; | 212 | double client_tx, peer_rx, peer_tx, client_rx; |
194 | client_tx = NTP64asDOUBLE(m->origts); | 213 | client_tx = NTP64asDOUBLE(m->origts); |
195 | peer_rx = NTP64asDOUBLE(m->rxts); | 214 | peer_rx = NTP64asDOUBLE(m->rxts); |
196 | peer_tx = NTP64asDOUBLE(m->txts); | 215 | peer_tx = NTP64asDOUBLE(m->txts); |
197 | client_rx=TVasDOUBLE((*t)); | 216 | client_rx = TVasDOUBLE((*t)); |
198 | return (.5*((peer_tx-client_rx)+(peer_rx-client_tx))); | 217 | return (.5 * ((peer_tx - client_rx) + (peer_rx - client_tx))); |
199 | } | 218 | } |
200 | 219 | ||
201 | /* print out a ntp packet in human readable/debuggable format */ | 220 | /* print out a ntp packet in human readable/debuggable format */ |
202 | void print_ntp_message(const ntp_message *p){ | 221 | void print_ntp_message(const ntp_message *p) { |
203 | struct timeval ref, orig, rx, tx; | 222 | struct timeval ref, orig, rx, tx; |
204 | 223 | ||
205 | NTP64toTV(p->refts,ref); | 224 | NTP64toTV(p->refts, ref); |
206 | NTP64toTV(p->origts,orig); | 225 | NTP64toTV(p->origts, orig); |
207 | NTP64toTV(p->rxts,rx); | 226 | NTP64toTV(p->rxts, rx); |
208 | NTP64toTV(p->txts,tx); | 227 | NTP64toTV(p->txts, tx); |
209 | 228 | ||
210 | printf("packet contents:\n"); | 229 | printf("packet contents:\n"); |
211 | printf("\tflags: 0x%.2x\n", p->flags); | 230 | printf("\tflags: 0x%.2x\n", p->flags); |
212 | printf("\t li=%d (0x%.2x)\n", LI(p->flags), p->flags&LI_MASK); | 231 | printf("\t li=%d (0x%.2x)\n", LI(p->flags), p->flags & LI_MASK); |
213 | printf("\t vn=%d (0x%.2x)\n", VN(p->flags), p->flags&VN_MASK); | 232 | printf("\t vn=%d (0x%.2x)\n", VN(p->flags), p->flags & VN_MASK); |
214 | printf("\t mode=%d (0x%.2x)\n", MODE(p->flags), p->flags&MODE_MASK); | 233 | printf("\t mode=%d (0x%.2x)\n", MODE(p->flags), p->flags & MODE_MASK); |
215 | printf("\tstratum = %d\n", p->stratum); | 234 | printf("\tstratum = %d\n", p->stratum); |
216 | printf("\tpoll = %g\n", pow(2, p->poll)); | 235 | printf("\tpoll = %g\n", pow(2, p->poll)); |
217 | printf("\tprecision = %g\n", pow(2, p->precision)); | 236 | printf("\tprecision = %g\n", pow(2, p->precision)); |
@@ -224,41 +243,43 @@ void print_ntp_message(const ntp_message *p){ | |||
224 | printf("\ttxts = %-.16g\n", NTP64asDOUBLE(p->txts)); | 243 | printf("\ttxts = %-.16g\n", NTP64asDOUBLE(p->txts)); |
225 | } | 244 | } |
226 | 245 | ||
227 | void setup_request(ntp_message *p){ | 246 | void setup_request(ntp_message *p) { |
228 | struct timeval t; | 247 | struct timeval t; |
229 | 248 | ||
230 | memset(p, 0, sizeof(ntp_message)); | 249 | memset(p, 0, sizeof(ntp_message)); |
231 | LI_SET(p->flags, LI_ALARM); | 250 | LI_SET(p->flags, LI_ALARM); |
232 | VN_SET(p->flags, 4); | 251 | VN_SET(p->flags, 4); |
233 | MODE_SET(p->flags, MODE_CLIENT); | 252 | MODE_SET(p->flags, MODE_CLIENT); |
234 | p->poll=4; | 253 | p->poll = 4; |
235 | p->precision=(int8_t)0xfa; | 254 | p->precision = (int8_t)0xfa; |
236 | L16(p->rtdelay)=htons(1); | 255 | L16(p->rtdelay) = htons(1); |
237 | L16(p->rtdisp)=htons(1); | 256 | L16(p->rtdisp) = htons(1); |
238 | 257 | ||
239 | gettimeofday(&t, NULL); | 258 | gettimeofday(&t, NULL); |
240 | TVtoNTP64(t,p->txts); | 259 | TVtoNTP64(t, p->txts); |
241 | } | 260 | } |
242 | 261 | ||
243 | /* select the "best" server from a list of servers, and return its index. | 262 | /* select the "best" server from a list of servers, and return its index. |
244 | * this is done by filtering servers based on stratum, dispersion, and | 263 | * this is done by filtering servers based on stratum, dispersion, and |
245 | * finally round-trip delay. */ | 264 | * finally round-trip delay. */ |
246 | int best_offset_server(const ntp_server_results *slist, int nservers){ | 265 | int best_offset_server(const ntp_server_results *slist, int nservers) { |
247 | int cserver=0, best_server=-1; | 266 | int cserver = 0, best_server = -1; |
248 | 267 | ||
249 | /* for each server */ | 268 | /* for each server */ |
250 | for(cserver=0; cserver<nservers; cserver++){ | 269 | for (cserver = 0; cserver < nservers; cserver++) { |
251 | /* We don't want any servers that fails these tests */ | 270 | /* We don't want any servers that fails these tests */ |
252 | /* Sort out servers that didn't respond or responede with a 0 stratum; | 271 | /* Sort out servers that didn't respond or responede with a 0 stratum; |
253 | * stratum 0 is for reference clocks so no NTP server should ever report | 272 | * stratum 0 is for reference clocks so no NTP server should ever report |
254 | * a stratum 0 */ | 273 | * a stratum 0 */ |
255 | if ( slist[cserver].stratum == 0){ | 274 | if (slist[cserver].stratum == 0) { |
256 | if (verbose) printf("discarding peer %d: stratum=%d\n", cserver, slist[cserver].stratum); | 275 | if (verbose) |
276 | printf("discarding peer %d: stratum=%d\n", cserver, slist[cserver].stratum); | ||
257 | continue; | 277 | continue; |
258 | } | 278 | } |
259 | /* Sort out servers with error flags */ | 279 | /* Sort out servers with error flags */ |
260 | if ( LI(slist[cserver].flags) == LI_ALARM ){ | 280 | if (LI(slist[cserver].flags) == LI_ALARM) { |
261 | if (verbose) printf("discarding peer %d: flags=%d\n", cserver, LI(slist[cserver].flags)); | 281 | if (verbose) |
282 | printf("discarding peer %d: flags=%d\n", cserver, LI(slist[cserver].flags)); | ||
262 | continue; | 283 | continue; |
263 | } | 284 | } |
264 | 285 | ||
@@ -272,13 +293,13 @@ int best_offset_server(const ntp_server_results *slist, int nservers){ | |||
272 | /* compare the server to the best one we've seen so far */ | 293 | /* compare the server to the best one we've seen so far */ |
273 | /* does it have an equal or better stratum? */ | 294 | /* does it have an equal or better stratum? */ |
274 | DBG(printf("comparing peer %d with peer %d\n", cserver, best_server)); | 295 | DBG(printf("comparing peer %d with peer %d\n", cserver, best_server)); |
275 | if(slist[cserver].stratum <= slist[best_server].stratum){ | 296 | if (slist[cserver].stratum <= slist[best_server].stratum) { |
276 | DBG(printf("stratum for peer %d <= peer %d\n", cserver, best_server)); | 297 | DBG(printf("stratum for peer %d <= peer %d\n", cserver, best_server)); |
277 | /* does it have an equal or better dispersion? */ | 298 | /* does it have an equal or better dispersion? */ |
278 | if(slist[cserver].rtdisp <= slist[best_server].rtdisp){ | 299 | if (slist[cserver].rtdisp <= slist[best_server].rtdisp) { |
279 | DBG(printf("dispersion for peer %d <= peer %d\n", cserver, best_server)); | 300 | DBG(printf("dispersion for peer %d <= peer %d\n", cserver, best_server)); |
280 | /* does it have a better rtdelay? */ | 301 | /* does it have a better rtdelay? */ |
281 | if(slist[cserver].rtdelay < slist[best_server].rtdelay){ | 302 | if (slist[cserver].rtdelay < slist[best_server].rtdelay) { |
282 | DBG(printf("rtdelay for peer %d < peer %d\n", cserver, best_server)); | 303 | DBG(printf("rtdelay for peer %d < peer %d\n", cserver, best_server)); |
283 | best_server = cserver; | 304 | best_server = cserver; |
284 | DBG(printf("peer %d is now our best candidate\n", best_server)); | 305 | DBG(printf("peer %d is now our best candidate\n", best_server)); |
@@ -287,7 +308,7 @@ int best_offset_server(const ntp_server_results *slist, int nservers){ | |||
287 | } | 308 | } |
288 | } | 309 | } |
289 | 310 | ||
290 | if(best_server >= 0) { | 311 | if (best_server >= 0) { |
291 | DBG(printf("best server selected: peer %d\n", best_server)); | 312 | DBG(printf("best server selected: peer %d\n", best_server)); |
292 | return best_server; | 313 | return best_server; |
293 | } else { | 314 | } else { |
@@ -301,16 +322,16 @@ int best_offset_server(const ntp_server_results *slist, int nservers){ | |||
301 | * we don't waste time sitting around waiting for single packets. | 322 | * we don't waste time sitting around waiting for single packets. |
302 | * - we also "manually" handle resolving host names and connecting, because | 323 | * - we also "manually" handle resolving host names and connecting, because |
303 | * we have to do it in a way that our lazy macros don't handle currently :( */ | 324 | * we have to do it in a way that our lazy macros don't handle currently :( */ |
304 | double offset_request(const char *host, int *status){ | 325 | double offset_request(const char *host, int *status) { |
305 | int i=0, j=0, ga_result=0, num_hosts=0, *socklist=NULL, respnum=0; | 326 | int i = 0, j = 0, ga_result = 0, num_hosts = 0, *socklist = NULL, respnum = 0; |
306 | int servers_completed=0, one_read=0, servers_readable=0, best_index=-1; | 327 | int servers_completed = 0, one_read = 0, servers_readable = 0, best_index = -1; |
307 | time_t now_time=0, start_ts=0; | 328 | time_t now_time = 0, start_ts = 0; |
308 | ntp_message *req=NULL; | 329 | ntp_message *req = NULL; |
309 | double avg_offset=0.; | 330 | double avg_offset = 0.; |
310 | struct timeval recv_time; | 331 | struct timeval recv_time; |
311 | struct addrinfo *ai=NULL, *ai_tmp=NULL, hints; | 332 | struct addrinfo *ai = NULL, *ai_tmp = NULL, hints; |
312 | struct pollfd *ufds=NULL; | 333 | struct pollfd *ufds = NULL; |
313 | ntp_server_results *servers=NULL; | 334 | ntp_server_results *servers = NULL; |
314 | 335 | ||
315 | /* setup hints to only return results from getaddrinfo that we'd like */ | 336 | /* setup hints to only return results from getaddrinfo that we'd like */ |
316 | memset(&hints, 0, sizeof(struct addrinfo)); | 337 | memset(&hints, 0, sizeof(struct addrinfo)); |
@@ -320,97 +341,105 @@ double offset_request(const char *host, int *status){ | |||
320 | 341 | ||
321 | /* fill in ai with the list of hosts resolved by the host name */ | 342 | /* fill in ai with the list of hosts resolved by the host name */ |
322 | ga_result = getaddrinfo(host, port, &hints, &ai); | 343 | ga_result = getaddrinfo(host, port, &hints, &ai); |
323 | if(ga_result!=0){ | 344 | if (ga_result != 0) { |
324 | die(STATE_UNKNOWN, "error getting address for %s: %s\n", | 345 | die(STATE_UNKNOWN, "error getting address for %s: %s\n", host, gai_strerror(ga_result)); |
325 | host, gai_strerror(ga_result)); | ||
326 | } | 346 | } |
327 | 347 | ||
328 | /* count the number of returned hosts, and allocate stuff accordingly */ | 348 | /* count the number of returned hosts, and allocate stuff accordingly */ |
329 | for(ai_tmp=ai; ai_tmp!=NULL; ai_tmp=ai_tmp->ai_next){ num_hosts++; } | 349 | for (ai_tmp = ai; ai_tmp != NULL; ai_tmp = ai_tmp->ai_next) { |
330 | req=(ntp_message*)malloc(sizeof(ntp_message)*num_hosts); | 350 | num_hosts++; |
331 | if(req==NULL) die(STATE_UNKNOWN, "can not allocate ntp message array"); | 351 | } |
332 | socklist=(int*)malloc(sizeof(int)*num_hosts); | 352 | req = (ntp_message *)malloc(sizeof(ntp_message) * num_hosts); |
333 | if(socklist==NULL) die(STATE_UNKNOWN, "can not allocate socket array"); | 353 | if (req == NULL) |
334 | ufds=(struct pollfd*)malloc(sizeof(struct pollfd)*num_hosts); | 354 | die(STATE_UNKNOWN, "can not allocate ntp message array"); |
335 | if(ufds==NULL) die(STATE_UNKNOWN, "can not allocate socket array"); | 355 | socklist = (int *)malloc(sizeof(int) * num_hosts); |
336 | servers=(ntp_server_results*)malloc(sizeof(ntp_server_results)*num_hosts); | 356 | if (socklist == NULL) |
337 | if(servers==NULL) die(STATE_UNKNOWN, "can not allocate server array"); | 357 | die(STATE_UNKNOWN, "can not allocate socket array"); |
338 | memset(servers, 0, sizeof(ntp_server_results)*num_hosts); | 358 | ufds = (struct pollfd *)malloc(sizeof(struct pollfd) * num_hosts); |
359 | if (ufds == NULL) | ||
360 | die(STATE_UNKNOWN, "can not allocate socket array"); | ||
361 | servers = (ntp_server_results *)malloc(sizeof(ntp_server_results) * num_hosts); | ||
362 | if (servers == NULL) | ||
363 | die(STATE_UNKNOWN, "can not allocate server array"); | ||
364 | memset(servers, 0, sizeof(ntp_server_results) * num_hosts); | ||
339 | DBG(printf("Found %d peers to check\n", num_hosts)); | 365 | DBG(printf("Found %d peers to check\n", num_hosts)); |
340 | 366 | ||
341 | /* setup each socket for writing, and the corresponding struct pollfd */ | 367 | /* setup each socket for writing, and the corresponding struct pollfd */ |
342 | ai_tmp=ai; | 368 | ai_tmp = ai; |
343 | for(i=0;ai_tmp;i++){ | 369 | for (i = 0; ai_tmp; i++) { |
344 | socklist[i]=socket(ai_tmp->ai_family, SOCK_DGRAM, IPPROTO_UDP); | 370 | socklist[i] = socket(ai_tmp->ai_family, SOCK_DGRAM, IPPROTO_UDP); |
345 | if(socklist[i] == -1) { | 371 | if (socklist[i] == -1) { |
346 | perror(NULL); | 372 | perror(NULL); |
347 | die(STATE_UNKNOWN, "can not create new socket"); | 373 | die(STATE_UNKNOWN, "can not create new socket"); |
348 | } | 374 | } |
349 | if(connect(socklist[i], ai_tmp->ai_addr, ai_tmp->ai_addrlen)){ | 375 | if (connect(socklist[i], ai_tmp->ai_addr, ai_tmp->ai_addrlen)) { |
350 | /* don't die here, because it is enough if there is one server | 376 | /* don't die here, because it is enough if there is one server |
351 | answering in time. This also would break for dual ipv4/6 stacked | 377 | answering in time. This also would break for dual ipv4/6 stacked |
352 | ntp servers when the client only supports on of them. | 378 | ntp servers when the client only supports on of them. |
353 | */ | 379 | */ |
354 | DBG(printf("can't create socket connection on peer %i: %s\n", i, strerror(errno))); | 380 | DBG(printf("can't create socket connection on peer %i: %s\n", i, strerror(errno))); |
355 | } else { | 381 | } else { |
356 | ufds[i].fd=socklist[i]; | 382 | ufds[i].fd = socklist[i]; |
357 | ufds[i].events=POLLIN; | 383 | ufds[i].events = POLLIN; |
358 | ufds[i].revents=0; | 384 | ufds[i].revents = 0; |
359 | } | 385 | } |
360 | ai_tmp = ai_tmp->ai_next; | 386 | ai_tmp = ai_tmp->ai_next; |
361 | } | 387 | } |
362 | 388 | ||
363 | /* now do AVG_NUM checks to each host. We stop before timeout/2 seconds | 389 | /* now do AVG_NUM checks to each host. We stop before timeout/2 seconds |
364 | * have passed in order to ensure post-processing and jitter time. */ | 390 | * have passed in order to ensure post-processing and jitter time. */ |
365 | now_time=start_ts=time(NULL); | 391 | now_time = start_ts = time(NULL); |
366 | while(servers_completed<num_hosts && now_time-start_ts <= socket_timeout/2){ | 392 | while (servers_completed < num_hosts && now_time - start_ts <= socket_timeout / 2) { |
367 | /* loop through each server and find each one which hasn't | 393 | /* loop through each server and find each one which hasn't |
368 | * been touched in the past second or so and is still lacking | 394 | * been touched in the past second or so and is still lacking |
369 | * some responses. For each of these servers, send a new request, | 395 | * some responses. For each of these servers, send a new request, |
370 | * and update the "waiting" timestamp with the current time. */ | 396 | * and update the "waiting" timestamp with the current time. */ |
371 | now_time=time(NULL); | 397 | now_time = time(NULL); |
372 | 398 | ||
373 | for(i=0; i<num_hosts; i++){ | 399 | for (i = 0; i < num_hosts; i++) { |
374 | if(servers[i].waiting<now_time && servers[i].num_responses<AVG_NUM){ | 400 | if (servers[i].waiting < now_time && servers[i].num_responses < AVG_NUM) { |
375 | if(verbose && servers[i].waiting != 0) printf("re-"); | 401 | if (verbose && servers[i].waiting != 0) |
376 | if(verbose) printf("sending request to peer %d\n", i); | 402 | printf("re-"); |
403 | if (verbose) | ||
404 | printf("sending request to peer %d\n", i); | ||
377 | setup_request(&req[i]); | 405 | setup_request(&req[i]); |
378 | write(socklist[i], &req[i], sizeof(ntp_message)); | 406 | write(socklist[i], &req[i], sizeof(ntp_message)); |
379 | servers[i].waiting=now_time; | 407 | servers[i].waiting = now_time; |
380 | break; | 408 | break; |
381 | } | 409 | } |
382 | } | 410 | } |
383 | 411 | ||
384 | /* quickly poll for any sockets with pending data */ | 412 | /* quickly poll for any sockets with pending data */ |
385 | servers_readable=poll(ufds, num_hosts, 100); | 413 | servers_readable = poll(ufds, num_hosts, 100); |
386 | if(servers_readable==-1){ | 414 | if (servers_readable == -1) { |
387 | perror("polling ntp sockets"); | 415 | perror("polling ntp sockets"); |
388 | die(STATE_UNKNOWN, "communication errors"); | 416 | die(STATE_UNKNOWN, "communication errors"); |
389 | } | 417 | } |
390 | 418 | ||
391 | /* read from any sockets with pending data */ | 419 | /* read from any sockets with pending data */ |
392 | for(i=0; servers_readable && i<num_hosts; i++){ | 420 | for (i = 0; servers_readable && i < num_hosts; i++) { |
393 | if(ufds[i].revents&POLLIN && servers[i].num_responses < AVG_NUM){ | 421 | if (ufds[i].revents & POLLIN && servers[i].num_responses < AVG_NUM) { |
394 | if(verbose) { | 422 | if (verbose) { |
395 | printf("response from peer %d: ", i); | 423 | printf("response from peer %d: ", i); |
396 | } | 424 | } |
397 | 425 | ||
398 | read(ufds[i].fd, &req[i], sizeof(ntp_message)); | 426 | read(ufds[i].fd, &req[i], sizeof(ntp_message)); |
399 | gettimeofday(&recv_time, NULL); | 427 | gettimeofday(&recv_time, NULL); |
400 | DBG(print_ntp_message(&req[i])); | 428 | DBG(print_ntp_message(&req[i])); |
401 | respnum=servers[i].num_responses++; | 429 | respnum = servers[i].num_responses++; |
402 | servers[i].offset[respnum]=calc_offset(&req[i], &recv_time)+time_offset; | 430 | servers[i].offset[respnum] = calc_offset(&req[i], &recv_time) + time_offset; |
403 | if(verbose) { | 431 | if (verbose) { |
404 | printf("offset %.10g\n", servers[i].offset[respnum]); | 432 | printf("offset %.10g\n", servers[i].offset[respnum]); |
405 | } | 433 | } |
406 | servers[i].stratum=req[i].stratum; | 434 | servers[i].stratum = req[i].stratum; |
407 | servers[i].rtdisp=NTP32asDOUBLE(req[i].rtdisp); | 435 | servers[i].rtdisp = NTP32asDOUBLE(req[i].rtdisp); |
408 | servers[i].rtdelay=NTP32asDOUBLE(req[i].rtdelay); | 436 | servers[i].rtdelay = NTP32asDOUBLE(req[i].rtdelay); |
409 | servers[i].waiting=0; | 437 | servers[i].waiting = 0; |
410 | servers[i].flags=req[i].flags; | 438 | servers[i].flags = req[i].flags; |
411 | servers_readable--; | 439 | servers_readable--; |
412 | one_read = 1; | 440 | one_read = 1; |
413 | if(servers[i].num_responses==AVG_NUM) servers_completed++; | 441 | if (servers[i].num_responses == AVG_NUM) |
442 | servers_completed++; | ||
414 | } | 443 | } |
415 | } | 444 | } |
416 | /* lather, rinse, repeat. */ | 445 | /* lather, rinse, repeat. */ |
@@ -421,54 +450,54 @@ double offset_request(const char *host, int *status){ | |||
421 | } | 450 | } |
422 | 451 | ||
423 | /* now, pick the best server from the list */ | 452 | /* now, pick the best server from the list */ |
424 | best_index=best_offset_server(servers, num_hosts); | 453 | best_index = best_offset_server(servers, num_hosts); |
425 | if(best_index < 0){ | 454 | if (best_index < 0) { |
426 | *status=STATE_UNKNOWN; | 455 | *status = STATE_UNKNOWN; |
427 | } else { | 456 | } else { |
428 | /* finally, calculate the average offset */ | 457 | /* finally, calculate the average offset */ |
429 | for(i=0; i<servers[best_index].num_responses;i++){ | 458 | for (i = 0; i < servers[best_index].num_responses; i++) { |
430 | avg_offset+=servers[best_index].offset[i]; | 459 | avg_offset += servers[best_index].offset[i]; |
431 | } | 460 | } |
432 | avg_offset/=servers[best_index].num_responses; | 461 | avg_offset /= servers[best_index].num_responses; |
433 | } | 462 | } |
434 | 463 | ||
435 | /* cleanup */ | 464 | /* cleanup */ |
436 | for(j=0; j<num_hosts; j++){ close(socklist[j]); } | 465 | for (j = 0; j < num_hosts; j++) { |
466 | close(socklist[j]); | ||
467 | } | ||
437 | free(socklist); | 468 | free(socklist); |
438 | free(ufds); | 469 | free(ufds); |
439 | free(servers); | 470 | free(servers); |
440 | free(req); | 471 | free(req); |
441 | freeaddrinfo(ai); | 472 | freeaddrinfo(ai); |
442 | 473 | ||
443 | if(verbose) printf("overall average offset: %.10g\n", avg_offset); | 474 | if (verbose) |
475 | printf("overall average offset: %.10g\n", avg_offset); | ||
444 | return avg_offset; | 476 | return avg_offset; |
445 | } | 477 | } |
446 | 478 | ||
447 | int process_arguments(int argc, char **argv){ | 479 | int process_arguments(int argc, char **argv) { |
448 | int c; | 480 | int c; |
449 | int option=0; | 481 | int option = 0; |
450 | static struct option longopts[] = { | 482 | static struct option longopts[] = {{"version", no_argument, 0, 'V'}, |
451 | {"version", no_argument, 0, 'V'}, | 483 | {"help", no_argument, 0, 'h'}, |
452 | {"help", no_argument, 0, 'h'}, | 484 | {"verbose", no_argument, 0, 'v'}, |
453 | {"verbose", no_argument, 0, 'v'}, | 485 | {"use-ipv4", no_argument, 0, '4'}, |
454 | {"use-ipv4", no_argument, 0, '4'}, | 486 | {"use-ipv6", no_argument, 0, '6'}, |
455 | {"use-ipv6", no_argument, 0, '6'}, | 487 | {"quiet", no_argument, 0, 'q'}, |
456 | {"quiet", no_argument, 0, 'q'}, | 488 | {"time-offset", optional_argument, 0, 'o'}, |
457 | {"time-offset", optional_argument, 0, 'o'}, | 489 | {"warning", required_argument, 0, 'w'}, |
458 | {"warning", required_argument, 0, 'w'}, | 490 | {"critical", required_argument, 0, 'c'}, |
459 | {"critical", required_argument, 0, 'c'}, | 491 | {"timeout", required_argument, 0, 't'}, |
460 | {"timeout", required_argument, 0, 't'}, | 492 | {"hostname", required_argument, 0, 'H'}, |
461 | {"hostname", required_argument, 0, 'H'}, | 493 | {"port", required_argument, 0, 'p'}, |
462 | {"port", required_argument, 0, 'p'}, | 494 | {0, 0, 0, 0}}; |
463 | {0, 0, 0, 0} | ||
464 | }; | ||
465 | |||
466 | 495 | ||
467 | if (argc < 2) | 496 | if (argc < 2) |
468 | usage ("\n"); | 497 | usage("\n"); |
469 | 498 | ||
470 | while (1) { | 499 | while (1) { |
471 | c = getopt_long (argc, argv, "Vhv46qw:c:t:H:p:o:", longopts, &option); | 500 | c = getopt_long(argc, argv, "Vhv46qw:c:t:H:p:o:", longopts, &option); |
472 | if (c == -1 || c == EOF || c == 1) | 501 | if (c == -1 || c == EOF || c == 1) |
473 | break; | 502 | break; |
474 | 503 | ||
@@ -494,7 +523,7 @@ int process_arguments(int argc, char **argv){ | |||
494 | ocrit = optarg; | 523 | ocrit = optarg; |
495 | break; | 524 | break; |
496 | case 'H': | 525 | case 'H': |
497 | if(!is_host(optarg)) | 526 | if (!is_host(optarg)) |
498 | usage2(_("Invalid hostname/address"), optarg); | 527 | usage2(_("Invalid hostname/address"), optarg); |
499 | server_address = strdup(optarg); | 528 | server_address = strdup(optarg); |
500 | break; | 529 | break; |
@@ -502,11 +531,11 @@ int process_arguments(int argc, char **argv){ | |||
502 | port = strdup(optarg); | 531 | port = strdup(optarg); |
503 | break; | 532 | break; |
504 | case 't': | 533 | case 't': |
505 | socket_timeout=atoi(optarg); | 534 | socket_timeout = atoi(optarg); |
506 | break; | 535 | break; |
507 | case 'o': | 536 | case 'o': |
508 | time_offset=atoi(optarg); | 537 | time_offset = atoi(optarg); |
509 | break; | 538 | break; |
510 | case '4': | 539 | case '4': |
511 | address_family = AF_INET; | 540 | address_family = AF_INET; |
512 | break; | 541 | break; |
@@ -514,77 +543,75 @@ int process_arguments(int argc, char **argv){ | |||
514 | #ifdef USE_IPV6 | 543 | #ifdef USE_IPV6 |
515 | address_family = AF_INET6; | 544 | address_family = AF_INET6; |
516 | #else | 545 | #else |
517 | usage4 (_("IPv6 support not available")); | 546 | usage4(_("IPv6 support not available")); |
518 | #endif | 547 | #endif |
519 | break; | 548 | break; |
520 | case '?': | 549 | case '?': |
521 | /* print short usage statement if args not parsable */ | 550 | /* print short usage statement if args not parsable */ |
522 | usage5 (); | 551 | usage5(); |
523 | break; | 552 | break; |
524 | } | 553 | } |
525 | } | 554 | } |
526 | 555 | ||
527 | if(server_address == NULL){ | 556 | if (server_address == NULL) { |
528 | usage4(_("Hostname was not supplied")); | 557 | usage4(_("Hostname was not supplied")); |
529 | } | 558 | } |
530 | 559 | ||
531 | return 0; | 560 | return 0; |
532 | } | 561 | } |
533 | 562 | ||
534 | char *perfd_offset (double offset) { | 563 | char *perfd_offset(double offset) { |
535 | return fperfdata ("offset", offset, "s", | 564 | return fperfdata("offset", offset, "s", true, offset_thresholds->warning->end, true, offset_thresholds->critical->end, false, 0, false, |
536 | true, offset_thresholds->warning->end, | 565 | 0); |
537 | true, offset_thresholds->critical->end, | ||
538 | false, 0, false, 0); | ||
539 | } | 566 | } |
540 | 567 | ||
541 | int main(int argc, char *argv[]){ | 568 | int main(int argc, char *argv[]) { |
542 | int result, offset_result; | 569 | int result, offset_result; |
543 | double offset=0; | 570 | double offset = 0; |
544 | char *result_line, *perfdata_line; | 571 | char *result_line, *perfdata_line; |
545 | 572 | ||
546 | setlocale (LC_ALL, ""); | 573 | setlocale(LC_ALL, ""); |
547 | bindtextdomain (PACKAGE, LOCALEDIR); | 574 | bindtextdomain(PACKAGE, LOCALEDIR); |
548 | textdomain (PACKAGE); | 575 | textdomain(PACKAGE); |
549 | 576 | ||
550 | result = offset_result = STATE_OK; | 577 | result = offset_result = STATE_OK; |
551 | 578 | ||
552 | /* Parse extra opts if any */ | 579 | /* Parse extra opts if any */ |
553 | argv=np_extra_opts (&argc, argv, progname); | 580 | argv = np_extra_opts(&argc, argv, progname); |
554 | 581 | ||
555 | if (process_arguments (argc, argv) == ERROR) | 582 | if (process_arguments(argc, argv) == ERROR) |
556 | usage4 (_("Could not parse arguments")); | 583 | usage4(_("Could not parse arguments")); |
557 | 584 | ||
558 | set_thresholds(&offset_thresholds, owarn, ocrit); | 585 | set_thresholds(&offset_thresholds, owarn, ocrit); |
559 | 586 | ||
560 | /* initialize alarm signal handling */ | 587 | /* initialize alarm signal handling */ |
561 | signal (SIGALRM, socket_timeout_alarm_handler); | 588 | signal(SIGALRM, socket_timeout_alarm_handler); |
562 | 589 | ||
563 | /* set socket timeout */ | 590 | /* set socket timeout */ |
564 | alarm (socket_timeout); | 591 | alarm(socket_timeout); |
565 | 592 | ||
566 | offset = offset_request(server_address, &offset_result); | 593 | offset = offset_request(server_address, &offset_result); |
567 | if (offset_result == STATE_UNKNOWN) { | 594 | if (offset_result == STATE_UNKNOWN) { |
568 | result = ( (!quiet) ? STATE_UNKNOWN : STATE_CRITICAL); | 595 | result = ((!quiet) ? STATE_UNKNOWN : STATE_CRITICAL); |
569 | } else { | 596 | } else { |
570 | result = get_status(fabs(offset), offset_thresholds); | 597 | result = get_status(fabs(offset), offset_thresholds); |
571 | } | 598 | } |
572 | 599 | ||
573 | switch (result) { | 600 | switch (result) { |
574 | case STATE_CRITICAL : | 601 | case STATE_CRITICAL: |
575 | xasprintf(&result_line, _("NTP CRITICAL:")); | 602 | xasprintf(&result_line, _("NTP CRITICAL:")); |
576 | break; | 603 | break; |
577 | case STATE_WARNING : | 604 | case STATE_WARNING: |
578 | xasprintf(&result_line, _("NTP WARNING:")); | 605 | xasprintf(&result_line, _("NTP WARNING:")); |
579 | break; | 606 | break; |
580 | case STATE_OK : | 607 | case STATE_OK: |
581 | xasprintf(&result_line, _("NTP OK:")); | 608 | xasprintf(&result_line, _("NTP OK:")); |
582 | break; | 609 | break; |
583 | default : | 610 | default: |
584 | xasprintf(&result_line, _("NTP UNKNOWN:")); | 611 | xasprintf(&result_line, _("NTP UNKNOWN:")); |
585 | break; | 612 | break; |
586 | } | 613 | } |
587 | if(offset_result == STATE_UNKNOWN){ | 614 | if (offset_result == STATE_UNKNOWN) { |
588 | xasprintf(&result_line, "%s %s", result_line, _("Offset unknown")); | 615 | xasprintf(&result_line, "%s %s", result_line, _("Offset unknown")); |
589 | xasprintf(&perfdata_line, ""); | 616 | xasprintf(&perfdata_line, ""); |
590 | } else { | 617 | } else { |
@@ -593,35 +620,36 @@ int main(int argc, char *argv[]){ | |||
593 | } | 620 | } |
594 | printf("%s|%s\n", result_line, perfdata_line); | 621 | printf("%s|%s\n", result_line, perfdata_line); |
595 | 622 | ||
596 | if(server_address!=NULL) free(server_address); | 623 | if (server_address != NULL) |
624 | free(server_address); | ||
597 | return result; | 625 | return result; |
598 | } | 626 | } |
599 | 627 | ||
600 | void print_help(void){ | 628 | void print_help(void) { |
601 | print_revision(progname, NP_VERSION); | 629 | print_revision(progname, NP_VERSION); |
602 | 630 | ||
603 | printf ("Copyright (c) 2006 Sean Finney\n"); | 631 | printf("Copyright (c) 2006 Sean Finney\n"); |
604 | printf (COPYRIGHT, copyright, email); | 632 | printf(COPYRIGHT, copyright, email); |
605 | 633 | ||
606 | printf ("%s\n", _("This plugin checks the clock offset with the ntp server")); | 634 | printf("%s\n", _("This plugin checks the clock offset with the ntp server")); |
607 | 635 | ||
608 | printf ("\n\n"); | 636 | printf("\n\n"); |
609 | 637 | ||
610 | print_usage(); | 638 | print_usage(); |
611 | printf (UT_HELP_VRSN); | 639 | printf(UT_HELP_VRSN); |
612 | printf (UT_EXTRA_OPTS); | 640 | printf(UT_EXTRA_OPTS); |
613 | printf (UT_IPv46); | 641 | printf(UT_IPv46); |
614 | printf (UT_HOST_PORT, 'p', "123"); | 642 | printf(UT_HOST_PORT, 'p', "123"); |
615 | printf (" %s\n", "-q, --quiet"); | 643 | printf(" %s\n", "-q, --quiet"); |
616 | printf (" %s\n", _("Returns UNKNOWN instead of CRITICAL if offset cannot be found")); | 644 | printf(" %s\n", _("Returns UNKNOWN instead of CRITICAL if offset cannot be found")); |
617 | printf (" %s\n", "-w, --warning=THRESHOLD"); | 645 | printf(" %s\n", "-w, --warning=THRESHOLD"); |
618 | printf (" %s\n", _("Offset to result in warning status (seconds)")); | 646 | printf(" %s\n", _("Offset to result in warning status (seconds)")); |
619 | printf (" %s\n", "-c, --critical=THRESHOLD"); | 647 | printf(" %s\n", "-c, --critical=THRESHOLD"); |
620 | printf (" %s\n", _("Offset to result in critical status (seconds)")); | 648 | printf(" %s\n", _("Offset to result in critical status (seconds)")); |
621 | printf (" %s\n", "-o, --time_offset=INTEGER"); | 649 | printf(" %s\n", "-o, --time_offset=INTEGER"); |
622 | printf (" %s\n", _("Expected offset of the ntp server relative to local server (seconds)")); | 650 | printf(" %s\n", _("Expected offset of the ntp server relative to local server (seconds)")); |
623 | printf (UT_CONN_TIMEOUT, DEFAULT_SOCKET_TIMEOUT); | 651 | printf(UT_CONN_TIMEOUT, DEFAULT_SOCKET_TIMEOUT); |
624 | printf (UT_VERBOSE); | 652 | printf(UT_VERBOSE); |
625 | 653 | ||
626 | printf("\n"); | 654 | printf("\n"); |
627 | printf("%s\n", _("This plugin checks the clock offset between the local host and a")); | 655 | printf("%s\n", _("This plugin checks the clock offset between the local host and a")); |
@@ -641,13 +669,10 @@ void print_help(void){ | |||
641 | printf("%s\n", _("Examples:")); | 669 | printf("%s\n", _("Examples:")); |
642 | printf(" %s\n", ("./check_ntp_time -H ntpserv -w 0.5 -c 1")); | 670 | printf(" %s\n", ("./check_ntp_time -H ntpserv -w 0.5 -c 1")); |
643 | 671 | ||
644 | printf (UT_SUPPORT); | 672 | printf(UT_SUPPORT); |
645 | } | 673 | } |
646 | 674 | ||
647 | void | 675 | void print_usage(void) { |
648 | print_usage(void) | 676 | printf("%s\n", _("Usage:")); |
649 | { | ||
650 | printf ("%s\n", _("Usage:")); | ||
651 | printf(" %s -H <host> [-4|-6] [-w <warn>] [-c <crit>] [-v verbose] [-o <time offset>]\n", progname); | 677 | printf(" %s -H <host> [-4|-6] [-w <warn>] [-c <crit>] [-v verbose] [-o <time offset>]\n", progname); |
652 | } | 678 | } |
653 | |||