@bengreenier/krtp/dist/Session.js

Node implementation of rdp protocol. RFC 3550

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    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) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
/*
 * +===============================================
 * | Author:        Parham Alvani (parham.alvani@gmail.com)
 * | Modified by:   Ben Greenier (ben@bengreenier.com)
 * |
 * | Creation Date: 01-06-2017
 * |
 * | File Name:     session.ts
 * +===============================================
 */
const crypto_1 = require("crypto");
const events_1 = require("events");
const Packet_1 = require("./Packet");
const Control_1 = require("./Control");
/**
 * RTP session: An association among a set of participants
 * communicating with RTP.
 */
class Session extends events_1.EventEmitter {
    /**
     * Creates a RTP session
     * @param port - RTP port
     * @param packetType - RTP packet type: This field identifies the format of the RTP
     * payload and determines its interpretation by the application.
     */
    constructor(port, socketFactory, packetType = 95) {
        super();
        this.port = port;
        this.packetType = packetType;
        this.timestamp = (Date.now() / 1000) | 0;
        this._sequenceNumber = crypto_1.randomBytes(2).readUInt16BE(0);
        this.ssrc = crypto_1.randomBytes(4).readUInt32BE(0);
        this._packetCount = 0;
        this._octetCount = 0;
        this.socket = socketFactory.createSocket();
        this.socket.on("message", (msg, rinfo) => {
            this.emit("message", Packet_1.Packet.deserialize(msg), rinfo);
        });
        this.socket.bind(this.port);
        this.controlSocket = socketFactory.createSocket();
        this.controlSocket.bind(this.port + 1);
    }
    get sequenceNumber() {
        return this._sequenceNumber;
    }
    get packetCount() {
        return this._packetCount;
    }
    get octetCount() {
        return this._octetCount;
    }
    sendSR(address = "127.0.0.1", timestamp = ((Date.now() / 1000) | 0) - this.timestamp) {
        return __awaiter(this, void 0, void 0, function* () {
            const packet = new Control_1.ControlSR(this._packetCount, this._octetCount, this.ssrc, timestamp);
            return new Promise((resolve, reject) => {
                this.controlSocket.send(packet.serialize(), this.port + 1, address, err => {
                    if (err) {
                        return reject(err);
                    }
                    return resolve();
                });
            });
        });
    }
    send(payload, address = "127.0.0.1", timestamp = ((Date.now() / 1000) | 0) - this.timestamp) {
        return __awaiter(this, void 0, void 0, function* () {
            const packet = new Packet_1.Packet(payload, this._sequenceNumber, this.ssrc, timestamp, this.packetType);
            this._sequenceNumber = (this._sequenceNumber + 1) % (1 << 16);
            this._packetCount += 1;
            this._octetCount += payload.length;
            return new Promise((resolve, reject) => {
                this.socket.send(packet.serialize(), this.port, address, err => {
                    if (err) {
                        return reject(err);
                    }
                    return resolve();
                });
            });
        });
    }
    close() {
        this.socket.close();
        this.controlSocket.close();
    }
}
exports.Session = Session;