← Back to branch summary

~ubuntu-dev/ubuntu/lucid/zabbix/lucid-201002110857

« back to all changes in this revision

Viewing changes to src/libs/zbxsysinfo/simple/ntp.c

  • Committer: Bazaar Package Importer
  • Author(s): Michael Ablassmeier
  • Date: 2007-07-02 09:06:51 UTC
  • mfrom: (1.1.4 upstream)
  • Revision ID: james.westby@ubuntu.com-20070702090651-8l6fl3fjw9rh6l2u
Tags: 1:1.4.1-2
Add patch from SVN in order to fix Incorrect processing of character '%'
in user parameters and remote commands.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/libs/zbxsysinfo/simple/ntp.c
 
1
/*
 
2
** ZABBIX
 
3
** Copyright (C) 2000-2005 SIA Zabbix
 
4
**
 
5
** This program is free software; you can redistribute it and/or modify
 
6
** it under the terms of the GNU General Public License as published by
 
7
** the Free Software Foundation; either version 2 of the License, or
 
8
** (at your option) any later version.
 
9
**
 
10
** This program is distributed in the hope that it will be useful,
 
11
** but WITHOUT ANY WARRANTY; without even the implied warranty of
 
12
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
13
** GNU General Public License for more details.
 
14
**
 
15
** You should have received a copy of the GNU General Public License
 
16
** along with this program; if not, write to the Free Software
 
17
** Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
18
**/
 
19
 
 
20
#include "common.h"
 
21
#include "sysinfo.h"
 
22
#include "comms.h"
 
23
#include "log.h"
 
24
#include "cfg.h"
 
25
 
 
26
#define NTP_SCALE  4294967296.0        /* 2^32, of course! */
 
27
 
 
28
#define NTP_PACKET_MIN       48        /* Without authentication */
 
29
#define NTP_PACKET_MAX       68        /* With authentication (ignored) */
 
30
#define NTP_DISP_FIELD        8        /* Offset of dispersion field */
 
31
#define NTP_REFERENCE        16        /* Offset of reference timestamp */
 
32
#define NTP_ORIGINATE        24        /* Offset of originate timestamp */
 
33
#define NTP_RECEIVE          32        /* Offset of receive timestamp */
 
34
#define NTP_TRANSMIT         40        /* Offset of transmit timestamp */
 
35
 
 
36
#define NTP_LI_FUDGE          0        /* The current 'status' */
 
37
#define NTP_VERSION           3        /* The current version */
 
38
#define NTP_VERSION_MAX       4        /* The maximum valid version */
 
39
#define NTP_STRATUM          15        /* The current stratum as a server */
 
40
#define NTP_STRATUM_MAX      15        /* The maximum valid stratum */
 
41
#define NTP_POLLING           8        /* The current 'polling interval' */
 
42
#define NTP_PRECISION         0        /* The current 'precision' - 1 sec. */
 
43
 
 
44
#define NTP_ACTIVE            1        /* NTP symmetric active request */
 
45
#define NTP_PASSIVE           2        /* NTP symmetric passive response */
 
46
#define NTP_CLIENT            3        /* NTP client request */
 
47
#define NTP_SERVER            4        /* NTP server response */
 
48
#define NTP_BROADCAST         5        /* NTP server broadcast */
 
49
 
 
50
#define NTP_INSANITY     3600.0        /* Errors beyond this are hopeless */
 
51
#define RESET_MIN            15        /* Minimum period between resets */
 
52
#define ABSCISSA            3.0        /* Scale factor for standard errors */
 
53
 
 
54
typedef struct ntp_data_s {
 
55
 
 
56
    unsigned char 
 
57
            status, 
 
58
            version, 
 
59
            mode, 
 
60
            stratum, 
 
61
            polling, 
 
62
            precision;
 
63
    double 
 
64
            dispersion, 
 
65
            reference, 
 
66
            originate, 
 
67
            receive, 
 
68
            transmit, 
 
69
            current;
 
70
 
 
71
} ntp_data;
 
72
 
 
73
static void make_packet (ntp_data *data)
 
74
{
 
75
        data->status    = NTP_LI_FUDGE<<6;
 
76
        data->stratum   = NTP_STRATUM;
 
77
        data->reference = data->dispersion = 0.0;
 
78
    
 
79
        data->version   = NTP_VERSION;
 
80
        data->mode      = 1;
 
81
        data->polling   = NTP_POLLING;
 
82
        data->precision = NTP_PRECISION;
 
83
        data->receive   = data->originate = 0.0;
 
84
        data->current   = data->transmit = zbx_current_time();
 
85
}
 
86
 
 
87
static void pack_ntp (unsigned char *packet, int length, ntp_data *data)
 
88
{
 
89
 
 
90
/* Pack the essential data into an NTP packet, bypassing struct layout and
 
91
endian problems.  Note that it ignores fields irrelevant to SNTP. */
 
92
 
 
93
    int i, k;
 
94
    double d;
 
95
 
 
96
    assert(length >= (NTP_TRANSMIT + 8));
 
97
 
 
98
    memset(packet,0,(size_t)length);
 
99
 
 
100
    packet[0] = (data->status << 6) | (data->version << 3) | data->mode;
 
101
    packet[1] = data->stratum;
 
102
    packet[2] = data->polling;
 
103
    packet[3] = data->precision;
 
104
 
 
105
    d = data->originate / NTP_SCALE;
 
106
    for (i = 0; i < 8; ++i) {
 
107
        if ((k = (int)(d *= 256.0)) >= 256) k = 255;
 
108
        packet[NTP_ORIGINATE + i] = k;
 
109
        d -= k;
 
110
    }
 
111
 
 
112
    d = data->receive / NTP_SCALE;
 
113
    for (i = 0; i < 8; ++i) {
 
114
        if ((k = (int)(d *= 256.0)) >= 256) k = 255;
 
115
        packet[NTP_RECEIVE + i] = k;
 
116
        d -= k;
 
117
    }
 
118
 
 
119
    d = data->transmit / NTP_SCALE;
 
120
    for (i = 0; i < 8; ++i) {
 
121
        if ((k = (int)(d *= 256.0)) >= 256) k = 255;
 
122
        packet[NTP_TRANSMIT + i] = k;
 
123
        d -= k;
 
124
    }
 
125
}
 
126
 
 
127
static void unpack_ntp (ntp_data *data, unsigned char *packet, int length) {
 
128
 
 
129
/* Unpack the essential data from an NTP packet, bypassing struct layout and
 
130
endian problems.  Note that it ignores fields irrelevant to SNTP. */
 
131
 
 
132
    int i;
 
133
    double d;
 
134
 
 
135
    memset(data, 0, sizeof(ntp_data));
 
136
 
 
137
    if(length == 0)
 
138
            return;
 
139
 
 
140
    assert(length >= (NTP_TRANSMIT + 8));
 
141
 
 
142
    data->current       = zbx_current_time();    /* Best to come first */
 
143
    data->status        = (packet[0] >> 6);
 
144
    data->version       = (packet[0] >> 3) & 0x07;
 
145
    data->mode          = packet[0] & 0x07;
 
146
    data->stratum       = packet[1];
 
147
    data->polling       = packet[2];
 
148
    data->precision     = packet[3];
 
149
 
 
150
    d = 0.0;
 
151
    for (i = 0; i < 4; ++i) d = 256.0 * d + packet[NTP_DISP_FIELD + i];
 
152
    data->dispersion = d / 65536.0;
 
153
    d = 0.0;
 
154
    for (i = 0; i < 8; ++i) d = 256.0 * d + packet[NTP_REFERENCE + i];
 
155
    data->reference = d / NTP_SCALE;
 
156
    d = 0.0;
 
157
    for (i = 0; i < 8; ++i) d = 256.0 * d + packet[NTP_ORIGINATE + i];
 
158
    data->originate = d / NTP_SCALE;
 
159
    d = 0.0;
 
160
    for (i = 0; i < 8; ++i) d = 256.0 * d + packet[NTP_RECEIVE + i];
 
161
    data->receive = d / NTP_SCALE;
 
162
    d = 0.0;
 
163
    for (i = 0; i < 8; ++i) d = 256.0 * d + packet[NTP_TRANSMIT + i];
 
164
    data->transmit = d / NTP_SCALE;
 
165
}
 
166
 
 
167
/*
 
168
static void display_data (ntp_data *data) {
 
169
 
 
170
    printf("sta = %d ver = %d mod = %d str = %d pol = %d dis = " ZBX_FS_DBL_EXT(6) " ref = " ZBX_FS_DBL_EXT(6) "\n",
 
171
        data->status,data->version,data->mode,data->stratum,data->polling,
 
172
        data->dispersion,data->reference);
 
173
    printf("ori = " ZBX_FS_DBL_EXT(6) " rec = " ZBX_FS_DBL_EXT(6) "\n",data->originate, data->receive);
 
174
    printf("tra = " ZBX_FS_DBL_EXT(6) " cur = " ZBX_FS_DBL_EXT(6) "\n",data->transmit, data->current);
 
175
}
 
176
*/
 
177
 
 
178
int     check_ntp(char *host, unsigned short port, int *value_int)
 
179
{
 
180
 
 
181
        zbx_sock_t      s;
 
182
 
 
183
        int             ret;
 
184
        char    *buf = NULL;
 
185
 
 
186
        ntp_data        data;
 
187
        char            packet[NTP_PACKET_MIN];
 
188
 
 
189
        assert(value_int);
 
190
 
 
191
        *value_int = 0;
 
192
 
 
193
        if( SUCCEED == (ret = zbx_tcp_connect(&s, host, port)) )
 
194
        {
 
195
                make_packet(&data);
 
196
 
 
197
                pack_ntp((unsigned char*)packet, sizeof(packet), &data);
 
198
 
 
199
                if( SUCCEED == (ret = zbx_tcp_send_raw(&s, packet)) )
 
200
                {
 
201
                        if( SUCCEED == (ret = zbx_tcp_recv(&s, &buf)) )
 
202
                        {
 
203
                        
 
204
                                unpack_ntp(&data, (unsigned char *)buf, strlen(buf));
 
205
 
 
206
#if OFF 
 
207
                        /* local time */        *value_int = time(NULL);
 
208
#else
 
209
                        /* server time */       *value_int = (data.receive > 0) ? (int)(data.receive - ZBX_JAN_1970_IN_SEC) : 0;
 
210
#endif
 
211
                        }
 
212
                }
 
213
        }
 
214
        zbx_tcp_close(&s);
 
215
 
 
216
        if( FAIL == ret )
 
217
        {
 
218
                zabbix_log(LOG_LEVEL_DEBUG, "NTP check error: %s", zbx_tcp_strerror());
 
219
        }
 
220
 
 
221
        return SYSINFO_RET_OK;
 
222
}
 
223