@ruanitto/react-native-ntp-sync/dist/internals/client.js

Sync time using NTP servers

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.getNetworkTime = void 0;
const buffer_1 = require("buffer");
const react_native_udp_1 = __importDefault(require("react-native-udp"));
const getError = (obj) => {
    if (!obj) {
        return new Error("unknown error");
    }
    if (!(obj instanceof Error)) {
        if (typeof obj === "string") {
            return new Error(obj);
        }
        return new Error(obj.toString());
    }
    return obj;
};
/**
 * Gets the current time from the parsed NTP Server.
 * @param {String} server IP/Hostname of the NTP server
 * @param {Number} port Port of the NTP server
 */
const getNetworkTime = (server, port, serverTimeout) => __awaiter(void 0, void 0, void 0, function* () {
    return new Promise((resolve, reject) => {
        const client = react_native_udp_1.default.createSocket({
            type: "udp4",
            debug: false,
        });
        const ntpData = buffer_1.Buffer.alloc(48);
        ntpData[0] = 0x1b;
        for (let i = 1; i < 48; i++) {
            ntpData[i] = 0;
        }
        let errorFired = false;
        const timeout = setTimeout(() => {
            errorFired = true;
            client.close();
            reject(new Error("timed out waiting for response"));
        }, serverTimeout);
        client.on("error", err => {
            if (errorFired) {
                return;
            }
            errorFired = true;
            clearTimeout(timeout);
            client.close();
            reject(getError(err));
        });
        client.once("message", msg => {
            clearTimeout(timeout);
            client.close();
            try {
                let offsetTransmitTime = 40, intpart = 0, fractpart = 0;
                for (let i = 0; i <= 3; i++) {
                    intpart = 256 * intpart + msg[offsetTransmitTime + i];
                }
                for (let i = 4; i <= 7; i++) {
                    fractpart = 256 * fractpart + msg[offsetTransmitTime + i];
                }
                let milliseconds = intpart * 1000 + (fractpart * 1000) / 0x100000000;
                let date = new Date(Date.UTC(1900, 0, 1));
                date.setUTCMilliseconds(date.getUTCMilliseconds() + milliseconds);
                resolve(date);
            }
            catch (err) {
                reject(getError(err));
            }
        });
        client.once("listening", () => {
            client.send(ntpData, 0, ntpData.length, port, server, err => {
                if (err) {
                    if (errorFired) {
                        return;
                    }
                    errorFired = true;
                    clearTimeout(timeout);
                    client.close();
                    reject(getError(err));
                }
            });
        });
        client.bind(0);
    });
});
exports.getNetworkTime = getNetworkTime;