Graybyt3 Was Here

Linux host1.absolutelystunningcenterpieces.com 3.10.0-957.21.3.el7.x86_64 #1 SMP Tue Jun 18 16:35:19 UTC 2019 x86_64
Apache
69.167.136.200

index.js

'use strict';

// Load modules

const Dgram = require('dgram');
const Dns = require('dns');

const Boom = require('boom');
const Bounce = require('bounce');
const Hoek = require('hoek');
const Teamwork = require('teamwork');

// Declare internals

const internals = {};

exports.time = async function (options = {}) {

const settings = Hoek.clone(options);
    settings.host = settings.host || 'time.google.com';
    settings.port = settings.port || 123;
    settings.resolveReference = settings.resolveReference || false;

const team = new Teamwork();

// Set timeout

const timeoutId = (settings.timeout ? setTimeout(() => team.attend(new Boom('Timeout')), settings.timeout) : null);

// Create UDP socket

const socket = Dgram.createSocket('udp4');

socket.once('error', (err) => team.attend(err));

// Listen to incoming messages

socket.on('message', (buffer, rinfo) => {

const received = Date.now();

const message = new internals.NtpMessage(buffer);
        if (!message.isValid) {
            const error = new Boom('Invalid server response');
            error.time = message;
            return team.attend(error);
        }

if (message.originateTimestamp !== sent) {
            const error = new Boom('Wrong originate timestamp');
            error.time = message;
            return team.attend(error);
        }

// Timestamp Name          ID   When Generated
        // ------------------------------------------------------------
        // Originate Timestamp     T1   time request sent by client
        // Receive Timestamp       T2   time request received by server
        // Transmit Timestamp      T3   time reply sent by server
        // Destination Timestamp   T4   time reply received by client
        //
        // The roundtrip delay d and system clock offset t are defined as:
        //
        // d = (T4 - T1) - (T3 - T2)     t = ((T2 - T1) + (T3 - T4)) / 2

const T1 = message.originateTimestamp;
        const T2 = message.receiveTimestamp;
        const T3 = message.transmitTimestamp;
        const T4 = received;

message.d = (T4 - T1) - (T3 - T2);
        message.t = ((T2 - T1) + (T3 - T4)) / 2;
        message.receivedLocally = received;

if (!settings.resolveReference ||
            message.stratum !== 'secondary') {

return team.attend(message);
        }

// Resolve reference IP address

Dns.reverse(message.referenceId, (err, domains) => {

if (/* $lab:coverage:off$ */ !err /* $lab:coverage:on$ */) {
                message.referenceHost = domains[0];
            }

return team.attend(message);
        });
    });

// Construct NTP message

const message = Buffer.alloc(48);                   // Zero-filled message
    message[0] = (0 << 6) + (4 << 3) + (3 << 0);        // Set version number to 4 and Mode to 3 (client)
    const sent = Date.now();
    internals.fromMsecs(sent, message, 40);             // Set transmit timestamp (returns as originate)

// Send NTP request

socket.send(message, 0, message.length, settings.port, settings.host, (err, bytes) => {

if (err ||
            bytes !== 48) {

return team.attend(err || new Boom('Could not send entire message'));
        }
    });

try {
        return await team.work;
    }
    finally {
        clearTimeout(timeoutId);

socket.removeAllListeners();
        socket.once('error', Hoek.ignore);

try {
            socket.close();
        }
        catch (ignoreErr) { }       // Ignore errors if the socket is already closed
    }
};

internals.NtpMessage = function (buffer) {

this.isValid = false;

// Validate

if (buffer.length !== 48) {
        return;
    }

// Leap indicator

const li = (buffer[0] >> 6);
    switch (li) {
        case 0: this.leapIndicator = 'no-warning'; break;
        case 1: this.leapIndicator = 'last-minute-61'; break;
        case 2: this.leapIndicator = 'last-minute-59'; break;
        case 3: this.leapIndicator = 'alarm'; break;
    }

// Version

const vn = ((buffer[0] & 0x38) >> 3);
    this.version = vn;

// Mode

const mode = (buffer[0] & 0x7);
    switch (mode) {
        case 1: this.mode = 'symmetric-active'; break;
        case 2: this.mode = 'symmetric-passive'; break;
        case 3: this.mode = 'client'; break;
        case 4: this.mode = 'server'; break;
        case 5: this.mode = 'broadcast'; break;
        case 0:
        case 6:
        case 7: this.mode = 'reserved'; break;
    }

// Stratum

// Poll interval (msec)

this.pollInterval = Math.round(Math.pow(2, buffer[2])) * 1000;

// Precision (msecs)

this.precision = Math.pow(2, buffer[3]) * 1000;

// Root delay (msecs)

const rootDelay = 256 * (256 * (256 * buffer[4] + buffer[5]) + buffer[6]) + buffer[7];
    this.rootDelay = 1000 * (rootDelay / 0x10000);

// Root dispersion (msecs)

this.rootDispersion = ((buffer[8] << 8) + buffer[9] + ((buffer[10] << 8) + buffer[11]) / Math.pow(2, 16)) * 1000;

// Reference identifier

this.referenceId = '';
    switch (this.stratum) {
        case 'death':
        case 'primary':
            this.referenceId = String.fromCharCode(buffer[12]) + String.fromCharCode(buffer[13]) + String.fromCharCode(buffer[14]) + String.fromCharCode(buffer[15]);
            break;
        case 'secondary':
            this.referenceId = '' + buffer[12] + '.' + buffer[13] + '.' + buffer[14] + '.' + buffer[15];
            break;
    }

// Reference timestamp

this.referenceTimestamp = internals.toMsecs(buffer, 16);

// Originate timestamp

this.originateTimestamp = internals.toMsecs(buffer, 24);

// Receive timestamp

this.receiveTimestamp = internals.toMsecs(buffer, 32);

// Transmit timestamp

this.transmitTimestamp = internals.toMsecs(buffer, 40);

// Validate

if (this.version === 4 &&
        this.stratum !== 'reserved' &&
        this.mode === 'server' &&
        this.originateTimestamp &&
        this.receiveTimestamp &&
        this.transmitTimestamp) {

this.isValid = true;
    }

return this;
};

internals.toMsecs = function (buffer, offset) {

let seconds = 0;
    let fraction = 0;

for (let i = 0; i < 4; ++i) {
        seconds = (seconds * 256) + buffer[offset + i];
    }

for (let i = 4; i < 8; ++i) {
        fraction = (fraction * 256) + buffer[offset + i];
    }

return ((seconds - 2208988800 + (fraction / Math.pow(2, 32))) * 1000);
};

internals.fromMsecs = function (ts, buffer, offset) {

const seconds = Math.floor(ts / 1000) + 2208988800;
    const fraction = Math.round((ts % 1000) / 1000 * Math.pow(2, 32));

buffer[offset + 0] = (seconds & 0xFF000000) >> 24;
    buffer[offset + 1] = (seconds & 0x00FF0000) >> 16;
    buffer[offset + 2] = (seconds & 0x0000FF00) >> 8;
    buffer[offset + 3] = (seconds & 0x000000FF);

buffer[offset + 4] = (fraction & 0xFF000000) >> 24;
    buffer[offset + 5] = (fraction & 0x00FF0000) >> 16;
    buffer[offset + 6] = (fraction & 0x0000FF00) >> 8;
    buffer[offset + 7] = (fraction & 0x000000FF);
};

// Offset singleton

internals.last = {
    offset: 0,
    expires: 0,
    host: '',
    port: 0
};

exports.offset = async function (options = {}) {

const now = Date.now();
    const clockSyncRefresh = options.clockSyncRefresh || 24 * 60 * 60 * 1000;                    // Daily

if (internals.last.offset &&
        internals.last.host === options.host &&
        internals.last.port === options.port &&
        now < internals.last.expires) {

return internals.last.offset;
    }

const time = await exports.time(options);

internals.last = {
        offset: Math.round(time.t),
        expires: now + clockSyncRefresh,
        host: options.host,
        port: options.port
    };

return internals.last.offset;
};

// Now singleton

internals.now = {
    started: false,
    intervalId: null
};

exports.start = async function (options = {}) {

if (internals.now.started) {
        return;
    }

const tick = async () => {

try {
            await exports.offset(options);
        }
        catch (err) {
            if (options.onError) {
                options.onError(err);
            }

Bounce.rethrow(err, 'system');
        }
    };

internals.now.started = true;
    internals.now.intervalId = setInterval(tick, options.clockSyncRefresh || 24 * 60 * 60 * 1000);      // Daily
    await exports.offset(options);
};

exports.stop = function () {

if (!internals.now.started) {
        return;
    }

clearInterval(internals.now.intervalId);
    internals.now.started = false;
    internals.now.intervalId = null;
};

exports.isLive = function () {

return internals.now.started;
};

exports.now = function () {

const now = Date.now();
    if (!exports.isLive() ||
        now >= internals.last.expires) {

return now;
    }

return now + internals.last.offset;
};

System Information
*ReClick For Close
File : BlackDragon /wanderfuls/about.php

Name	Type	Size	Owner/Group	Permission	Last Modified	Actions
.	dir	-	nobody/root	0755	1985-10-26 08:15:00
..	dir	-	nobody/root	0755	2019-07-04 06:46:56
index.js	file	9.15 KB	nobody/root	0755	1985-10-26 08:15:00