![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to networking.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / sntp|
Return to networking.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / sntp |
1.1 misho 1: #include <config.h>
2: #include "networking.h"
3:
4: char adr_buf[INET6_ADDRSTRLEN];
5:
6:
7: /* resolve_hosts consumes an array of hostnames/addresses and its length, stores a pointer
8: * to the array with the resolved hosts in res and returns the size of the array res.
9: * pref_family enforces IPv4 or IPv6 depending on commandline options and system
10: * capability. If pref_family is NULL or PF_UNSPEC any compatible family will be accepted.
11: * Check here: Probably getaddrinfo() can do without ISC's IPv6 availability check?
12: */
13: int
14: resolve_hosts (
15: const char **hosts,
16: int hostc,
17: struct addrinfo ***res,
18: int pref_family
19: )
20: {
21: register unsigned int a;
22: unsigned int resc;
23: struct addrinfo **tres;
24:
25: if (hostc < 1 || NULL == res)
26: return 0;
27:
28: tres = emalloc(sizeof(struct addrinfo *) * hostc);
29: for (a = 0, resc = 0; a < hostc; a++) {
30: struct addrinfo hints;
31: int error;
32:
33: tres[resc] = NULL;
34: #ifdef DEBUG
35: printf("sntp resolve_hosts: Starting host resolution for %s...\n", hosts[a]);
36: #endif
37: memset(&hints, 0, sizeof(hints));
38: if (AF_UNSPEC == pref_family)
39: hints.ai_family = PF_UNSPEC;
40: else
41: hints.ai_family = pref_family;
42: hints.ai_socktype = SOCK_DGRAM;
43: error = getaddrinfo(hosts[a], "123", &hints, &tres[resc]);
44: if (error) {
45: msyslog(LOG_DEBUG, "Error looking up %s%s: %s",
46: (AF_UNSPEC == hints.ai_family)
47: ? ""
48: : (AF_INET == hints.ai_family)
49: ? "(A) "
50: : "(AAAA) ",
51: hosts[a], gai_strerror(error));
52: } else {
53: #ifdef DEBUG
54: for (dres = tres[resc]; dres; dres = dres->ai_next) {
55: getnameinfo(dres->ai_addr, dres->ai_addrlen, adr_buf, sizeof(adr_buf), NULL, 0, NI_NUMERICHOST);
56: STDLINE
57: printf("Resolv No.: %i Result of getaddrinfo for %s:\n", resc, hosts[a]);
58: printf("socktype: %i ", dres->ai_socktype);
59: printf("protocol: %i ", dres->ai_protocol);
60: printf("Prefered socktype: %i IP: %s\n", dres->ai_socktype, adr_buf);
61: STDLINE
62: }
63: #endif
64: resc++;
65: }
66: }
67:
68: if (resc)
69: *res = realloc(tres, sizeof(struct addrinfo *) * resc);
70: else {
71: free(tres);
72: *res = NULL;
73: }
74: return resc;
75: }
76:
77: /* Creates a socket and returns. */
78: void
79: create_socket (
80: SOCKET *rsock,
81: sockaddr_u *dest
82: )
83: {
84: *rsock = socket(AF(dest), SOCK_DGRAM, 0);
85:
86: if (-1 == *rsock && ENABLED_OPT(NORMALVERBOSE))
87: printf("Failed to create UDP socket with family %d\n", AF(dest));
88: }
89:
90: /* Send a packet */
91: void
92: sendpkt (
93: SOCKET rsock,
94: sockaddr_u *dest,
95: struct pkt *pkt,
96: int len
97: )
98: {
99: int cc;
100:
101: #ifdef DEBUG
102: printf("sntp sendpkt: Packet data:\n");
103: pkt_output(pkt, len, stdout);
104: #endif
105:
106: if (ENABLED_OPT(NORMALVERBOSE)) {
107: getnameinfo(&dest->sa, SOCKLEN(dest), adr_buf, sizeof(adr_buf), NULL, 0, NI_NUMERICHOST);
108: printf("sntp sendpkt: Sending packet to %s... ", adr_buf);
109: }
110:
111: cc = sendto(rsock, (void *)pkt, len, 0, &dest->sa, SOCKLEN(dest));
112: if (cc == SOCKET_ERROR) {
113: #ifdef DEBUG
114: printf("\n sntp sendpkt: Socket error: %i. Couldn't send packet!\n", cc);
115: #endif
116: if (errno != EWOULDBLOCK && errno != ENOBUFS) {
117: /* oh well */
118: }
119: } else if (ENABLED_OPT(NORMALVERBOSE)) {
120: printf("Packet sent.\n");
121: }
122: }
123:
124: /* Receive raw data */
125: int
126: recvdata(
127: SOCKET rsock,
128: sockaddr_u *sender,
129: char *rdata,
130: int rdata_length
131: )
132: {
133: GETSOCKNAME_SOCKLEN_TYPE slen;
134: int recvc;
135:
136: #ifdef DEBUG
137: printf("sntp recvdata: Trying to receive data from...\n");
138: #endif
139: slen = sizeof(*sender);
140: recvc = recvfrom(rsock, rdata, rdata_length, 0,
141: &sender->sa, &slen);
142: #ifdef DEBUG
143: if (recvc > 0) {
144: printf("Received %d bytes from %s:\n", recvc, stoa(sender));
145: pkt_output((struct pkt *) rdata, recvc, stdout);
146: } else {
147: saved_errno = errno;
148: printf("recvfrom error %d (%s)\n", errno, strerror(errno));
149: errno = saved_errno;
150: }
151: #endif
152: return recvc;
153: }
154:
155: /* Receive data from broadcast. Couldn't finish that. Need to do some digging
156: * here, especially for protocol independence and IPv6 multicast */
157: int
158: recv_bcst_data (
159: SOCKET rsock,
160: char *rdata,
161: int rdata_len,
162: sockaddr_u *sas,
163: sockaddr_u *ras
164: )
165: {
166: char *buf;
167: int btrue = 1;
168: int recv_bytes = 0;
169: int rdy_socks;
170: GETSOCKNAME_SOCKLEN_TYPE ss_len;
171: struct timeval timeout_tv;
172: fd_set bcst_fd;
173: #ifdef MCAST
174: struct ip_mreq mdevadr;
175: TYPEOF_IP_MULTICAST_LOOP mtrue = 1;
176: #endif
177: #ifdef INCLUDE_IPV6_MULTICAST_SUPPORT
178: struct ipv6_mreq mdevadr6;
179: #endif
180:
181: setsockopt(rsock, SOL_SOCKET, SO_REUSEADDR, &btrue, sizeof(btrue));
182: if (IS_IPV4(sas)) {
183: if (bind(rsock, &sas->sa, SOCKLEN(sas)) < 0) {
184: if (ENABLED_OPT(NORMALVERBOSE))
185: printf("sntp recv_bcst_data: Couldn't bind() address %s:%d.\n",
186: stoa(sas), SRCPORT(sas));
187: }
188:
189: #ifdef MCAST
190: if (setsockopt(rsock, IPPROTO_IP, IP_MULTICAST_LOOP, &mtrue, sizeof(mtrue)) < 0) {
191: /* some error message regarding setting up multicast loop */
192: return BROADCAST_FAILED;
193: }
194: mdevadr.imr_multiaddr.s_addr = NSRCADR(sas);
195: mdevadr.imr_interface.s_addr = htonl(INADDR_ANY);
196: if (mdevadr.imr_multiaddr.s_addr == -1) {
197: if (ENABLED_OPT(NORMALVERBOSE)) {
198: printf("sntp recv_bcst_data: %s:%d is not a broad-/multicast address, aborting...\n",
199: stoa(sas), SRCPORT(sas));
200: }
201: return BROADCAST_FAILED;
202: }
203: if (setsockopt(rsock, IPPROTO_IP, IP_ADD_MEMBERSHIP, &mdevadr, sizeof(mdevadr)) < 0) {
204: if (ENABLED_OPT(NORMALVERBOSE)) {
205: buf = ss_to_str(sas);
206: printf("sntp recv_bcst_data: Couldn't add IP membership for %s\n", buf);
207: free(buf);
208: }
209: }
210: #endif /* MCAST */
211: }
212: #ifdef ISC_PLATFORM_HAVEIPV6
213: else if (IS_IPV6(sas)) {
214: if (bind(rsock, &sas->sa, SOCKLEN(sas)) < 0) {
215: if (ENABLED_OPT(NORMALVERBOSE))
216: printf("sntp recv_bcst_data: Couldn't bind() address.\n");
217: }
218: #ifdef INCLUDE_IPV6_MULTICAST_SUPPORT
219: if (setsockopt(rsock, IPPROTO_IPV6, IPV6_MULTICAST_LOOP, &btrue, sizeof (btrue)) < 0) {
220: /* some error message regarding setting up multicast loop */
221: return BROADCAST_FAILED;
222: }
223: memset(&mdevadr6, 0, sizeof(mdevadr6));
224: mdevadr6.ipv6mr_multiaddr = SOCK_ADDR6(sas);
225: if (!IN6_IS_ADDR_MULTICAST(&mdevadr6.ipv6mr_multiaddr)) {
226: if (ENABLED_OPT(NORMALVERBOSE)) {
227: buf = ss_to_str(sas);
228: printf("sntp recv_bcst_data: %s is not a broad-/multicast address, aborting...\n", buf);
229: free(buf);
230: }
231: return BROADCAST_FAILED;
232: }
233: if (setsockopt(rsock, IPPROTO_IPV6, IPV6_JOIN_GROUP,
234: &mdevadr6, sizeof(mdevadr6)) < 0) {
235: if (ENABLED_OPT(NORMALVERBOSE)) {
236: buf = ss_to_str(sas);
237: printf("sntp recv_bcst_data: Couldn't join group for %s\n", buf);
238: free(buf);
239: }
240: }
241: #endif /* INCLUDE_IPV6_MULTICAST_SUPPORT */
242: }
243: #endif /* ISC_PLATFORM_HAVEIPV6 */
244: FD_ZERO(&bcst_fd);
245: FD_SET(rsock, &bcst_fd);
246: if (ENABLED_OPT(TIMEOUT))
247: timeout_tv.tv_sec = (int) OPT_ARG(TIMEOUT);
248: else
249: timeout_tv.tv_sec = 68; /* ntpd broadcasts every 64s */
250: timeout_tv.tv_usec = 0;
251: rdy_socks = select(rsock + 1, &bcst_fd, 0, 0, &timeout_tv);
252: switch (rdy_socks) {
253: case -1:
254: if (ENABLED_OPT(NORMALVERBOSE))
255: perror("sntp recv_bcst_data: select()");
256: return BROADCAST_FAILED;
257: break;
258: case 0:
259: if (ENABLED_OPT(NORMALVERBOSE))
260: printf("sntp recv_bcst_data: select() reached timeout (%u sec), aborting.\n",
261: (unsigned)timeout_tv.tv_sec);
262: return BROADCAST_FAILED;
263: break;
264: default:
265: ss_len = sizeof(*ras);
266: recv_bytes = recvfrom(rsock, rdata, rdata_len, 0, &ras->sa, &ss_len);
267: break;
268: }
269: if (recv_bytes == -1) {
270: if (ENABLED_OPT(NORMALVERBOSE))
271: perror("sntp recv_bcst_data: recvfrom:");
272: recv_bytes = BROADCAST_FAILED;
273: }
274: #ifdef MCAST
275: if (IS_IPV4(sas))
276: setsockopt(rsock, IPPROTO_IP, IP_DROP_MEMBERSHIP, &btrue, sizeof(btrue));
277: #endif
278: #ifdef INCLUDE_IPV6_MULTICAST_SUPPORT
279: if (IS_IPV6(sas))
280: setsockopt(rsock, IPPROTO_IPV6, IPV6_LEAVE_GROUP, &btrue, sizeof(btrue));
281: #endif
282: return recv_bytes;
283: }
284:
285: int
286: process_pkt (
287: struct pkt *rpkt,
288: sockaddr_u *sas,
289: int pkt_len,
290: int mode,
291: struct pkt *spkt,
292: char * func_name
293: )
294: {
295: unsigned int key_id = 0;
296: struct key *pkt_key = NULL;
297: int is_authentic = 0;
298: unsigned int exten_words, exten_words_used = 0;
299: int mac_size;
300: /*
301: * Parse the extension field if present. We figure out whether
302: * an extension field is present by measuring the MAC size. If
303: * the number of words following the packet header is 0, no MAC
304: * is present and the packet is not authenticated. If 1, the
305: * packet is a crypto-NAK; if 3, the packet is authenticated
306: * with DES; if 5, the packet is authenticated with MD5; if 6,
307: * the packet is authenticated with SHA. If 2 or 4, the packet
308: * is a runt and discarded forthwith. If greater than 6, an
309: * extension field is present, so we subtract the length of the
310: * field and go around again.
311: */
312: if (pkt_len < LEN_PKT_NOMAC || (pkt_len & 3) != 0) {
313: unusable:
314: if (ENABLED_OPT(NORMALVERBOSE))
315: printf("sntp %s: Funny packet length: %i. Discarding package.\n", func_name, pkt_len);
316: return PACKET_UNUSEABLE;
317: }
318: /* skip past the extensions, if any */
319: exten_words = ((unsigned)pkt_len - LEN_PKT_NOMAC) >> 2;
320: while (exten_words > 6) {
321: unsigned int exten_len;
322: exten_len = ntohl(rpkt->exten[exten_words_used]) & 0xffff;
323: exten_len = (exten_len + 7) >> 2; /* convert to words, add 1 */
324: if (exten_len > exten_words || exten_len < 5)
325: goto unusable;
326: exten_words -= exten_len;
327: exten_words_used += exten_len;
328: }
329:
330: switch (exten_words) {
331: case 1:
332: key_id = ntohl(rpkt->exten[exten_words_used]);
333: printf("Crypto NAK = 0x%08x\n", key_id);
334: break;
335: case 5:
336: case 6:
337: /* Look for the key used by the server in the specified keyfile
338: * and if existent, fetch it or else leave the pointer untouched */
339: key_id = ntohl(rpkt->exten[exten_words_used]);
340: get_key(key_id, &pkt_key);
341: if (!pkt_key) {
342: printf("unrecognized key ID = 0x%08x\n", key_id);
343: break;
344: }
345: /* Seems like we've got a key with matching keyid */
346: /* Generate a md5sum of the packet with the key from our keyfile
347: * and compare those md5sums */
348: mac_size = exten_words << 2;
349: if (!auth_md5((char *)rpkt, pkt_len - mac_size, mac_size - 4, pkt_key)) {
350: break;
351: }
352: /* Yay! Things worked out! */
353: if (ENABLED_OPT(NORMALVERBOSE)) {
354: char *hostname = ss_to_str(sas);
355: printf("sntp %s: packet received from %s successfully authenticated using key id %i.\n",
356: func_name, hostname, key_id);
357: free(hostname);
358: }
359: is_authentic = 1;
360: break;
361: case 0:
362: break;
363: default:
364: goto unusable;
365: break;
366: }
367: if (!is_authentic) {
368: if (ENABLED_OPT(AUTHENTICATION)) {
369: /* We want a authenticated packet */
370: if (ENABLED_OPT(NORMALVERBOSE)) {
371: char *hostname = ss_to_str(sas);
372: printf("sntp %s: packet received from %s is not authentic. Will discard it.\n",
373: func_name, hostname);
374: free(hostname);
375: }
376: return SERVER_AUTH_FAIL;
377: }
378: /* We don't know if the user wanted authentication so let's
379: * use it anyways */
380: if (ENABLED_OPT(NORMALVERBOSE)) {
381: char *hostname = ss_to_str(sas);
382: printf("sntp %s: packet received from %s is not authentic. Authentication not enforced.\n",
383: func_name, hostname);
384: free(hostname);
385: }
386: }
387: /* Check for server's ntp version */
388: if (PKT_VERSION(rpkt->li_vn_mode) < NTP_OLDVERSION ||
389: PKT_VERSION(rpkt->li_vn_mode) > NTP_VERSION) {
390: if (ENABLED_OPT(NORMALVERBOSE))
391: printf("sntp %s: Packet shows wrong version (%i)\n",
392: func_name, PKT_VERSION(rpkt->li_vn_mode));
393: return SERVER_UNUSEABLE;
394: }
395: /* We want a server to sync with */
396: if (PKT_MODE(rpkt->li_vn_mode) != mode &&
397: PKT_MODE(rpkt->li_vn_mode) != MODE_PASSIVE) {
398: if (ENABLED_OPT(NORMALVERBOSE))
399: printf("sntp %s: mode %d stratum %i\n", func_name,
400: PKT_MODE(rpkt->li_vn_mode), rpkt->stratum);
401: return SERVER_UNUSEABLE;
402: }
403: /* Stratum is unspecified (0) check what's going on */
404: if (STRATUM_PKT_UNSPEC == rpkt->stratum) {
405: char *ref_char;
406: if (ENABLED_OPT(NORMALVERBOSE))
407: printf("sntp %s: Stratum unspecified, going to check for KOD (stratum: %i)\n",
408: func_name, rpkt->stratum);
409: ref_char = (char *) &rpkt->refid;
410: if (ENABLED_OPT(NORMALVERBOSE))
411: printf("sntp %s: Packet refid: %c%c%c%c\n", func_name,
412: ref_char[0], ref_char[1], ref_char[2], ref_char[3]);
413: /* If it's a KOD packet we'll just use the KOD information */
414: if (ref_char[0] != 'X') {
415: if (strncmp(ref_char, "DENY", 4) == 0)
416: return KOD_DEMOBILIZE;
417: if (strncmp(ref_char, "RSTR", 4) == 0)
418: return KOD_DEMOBILIZE;
419: if (strncmp(ref_char, "RATE", 4) == 0)
420: return KOD_RATE;
421: /* There are other interesting kiss codes which might be interesting for authentication */
422: }
423: }
424: /* If the server is not synced it's not really useable for us */
425: if (LEAP_NOTINSYNC == PKT_LEAP(rpkt->li_vn_mode)) {
426: if (ENABLED_OPT(NORMALVERBOSE))
427: printf("sntp %s: Server not in sync, skipping this server\n", func_name);
428: return SERVER_UNUSEABLE;
429: }
430:
431: /*
432: * Decode the org timestamp and make sure we're getting a response
433: * to our last request, but only if we're not in broadcast mode.
434: */
435: #ifdef DEBUG
436: printf("rpkt->org:\n");
437: l_fp_output(&rpkt->org, stdout);
438: printf("spkt->xmt:\n");
439: l_fp_output(&spkt->xmt, stdout);
440: #endif
441: if (mode != MODE_BROADCAST && !L_ISEQU(&rpkt->org, &spkt->xmt)) {
442: if (ENABLED_OPT(NORMALVERBOSE))
443: printf("sntp process_pkt: pkt.org and peer.xmt differ\n");
444: return PACKET_UNUSEABLE;
445: }
446:
447: return pkt_len;
448: }
449:
450: int
451: recv_bcst_pkt (
452: SOCKET rsock,
453: struct pkt *rpkt,
454: unsigned int rsize,
455: sockaddr_u *sas
456: )
457: {
458: sockaddr_u sender;
459: int pkt_len = recv_bcst_data(rsock, (char *)rpkt, rsize, sas, &sender);
460: if (pkt_len < 0) {
461: return BROADCAST_FAILED;
462: }
463: pkt_len = process_pkt(rpkt, sas, pkt_len, MODE_BROADCAST, NULL, "recv_bcst_pkt");
464: return pkt_len;
465: }
466:
467: /* Fetch data, check if it's data for us and whether it's useable or not. If not, return
468: * a failure code so we can delete this server from our list and continue with another one.
469: */
470: int
471: recvpkt (
472: SOCKET rsock,
473: struct pkt *rpkt, /* received packet (response) */
474: unsigned int rsize, /* size of rpkt buffer */
475: struct pkt *spkt /* sent packet (request) */
476: )
477: {
478: int rdy_socks;
479: int pkt_len;
480: sockaddr_u sender;
481: struct timeval timeout_tv;
482: fd_set recv_fd;
483:
484: FD_ZERO(&recv_fd);
485: FD_SET(rsock, &recv_fd);
486: if (ENABLED_OPT(TIMEOUT))
487: timeout_tv.tv_sec = (int) OPT_ARG(TIMEOUT);
488: else
489: timeout_tv.tv_sec = 68; /* ntpd broadcasts every 64s */
490: timeout_tv.tv_usec = 0;
491: rdy_socks = select(rsock + 1, &recv_fd, 0, 0, &timeout_tv);
492: switch (rdy_socks) {
493: case -1:
494: if (ENABLED_OPT(NORMALVERBOSE))
495: perror("sntp recvpkt: select()");
496: return PACKET_UNUSEABLE;
497: break;
498: case 0:
499: if (ENABLED_OPT(NORMALVERBOSE))
500: printf("sntp recvpkt: select() reached timeout (%u sec), aborting.\n",
501: (unsigned)timeout_tv.tv_sec);
502: return PACKET_UNUSEABLE;
503: break;
504: default:
505: break;
506: }
507: pkt_len = recvdata(rsock, &sender, (char *)rpkt, rsize);
508: if (pkt_len > 0)
509: pkt_len = process_pkt(rpkt, &sender, pkt_len, MODE_SERVER, spkt, "recvpkt");
510:
511: return pkt_len;
512: }
513:
514: /*
515: * is_reachable - check to see if we have a route to given destination
516: */
517: int
518: is_reachable (
519: struct addrinfo *dst
520: )
521: {
522: SOCKET sockfd = socket(dst->ai_family, SOCK_DGRAM, 0);
523:
524: if (-1 == sockfd) {
525: #ifdef DEBUG
526: printf("is_reachable: Couldn't create socket\n");
527: #endif
528: return 0;
529: }
530: if (connect(sockfd, dst->ai_addr, SOCKLEN((sockaddr_u *)dst->ai_addr))) {
531: closesocket(sockfd);
532: return 0;
533: }
534: closesocket(sockfd);
535: return 1;
536: }