index.js

const crypto = require("crypto");
const dotenv = require("dotenv");
const express = require("express");
const app = express();
const http = require("http");
const fs = require("fs");
const server = http.createServer(app);
const port = process.env.PORT || 3000;
const config = dotenv.config().parsed;

const { Server } = require("socket.io");
const io = new Server(server);

let peerConfig = {};
try {
  const data = fs.readFileSync("config.json");
  peerConfig = JSON.parse(data);
} catch (err) {
  console.error("Error reading config file: ", err);
}

const generateTurnCredentials = (secret, ttl) => {
  const timestamp = Math.floor(Date.now() / 1000) + ttl;
  const userId = "turnuser";
  const userCombo = `${timestamp}:${userId}`;
  console.debug(`Generating password for ${userCombo}`);

  const hmac = crypto.createHmac("sha1", secret);
  hmac.setEncoding("base64");
  hmac.write(userCombo);
  hmac.end();

  const password = hmac.read();
  return [userCombo, password];
};

io.on("connection", (socket) => {
  socket.emit("welcome");
  console.debug("New connection: ", socket.id);

  socket.on("join", (code) => {
    if (!io.sockets.adapter.rooms.get(code)) {
      //First client - create
      socket.join(code);
      socket.emit("created", code);
      console.debug("First client: ", code);
    } else if (io.sockets.adapter.rooms.get(code).size === 1) {
      //Second client - join
      socket.join(code);
      socket.emit("joined", code);
      socket.to(code).emit("begin");
      console.debug("Second client: ", code);
    } else {
      //Room full - full
      socket.emit("full", code);
      socket.emit("welcome");
      console.debug("Room full: ", code);
    }
  });

  socket.on("leave", (code) => {
    console.debug(`${socket.id} left room: `, code);
    const rooms = Array.from(socket.rooms);
    rooms.forEach((room) => {
      socket.to(room).emit("bye");
    });
    socket.leave(code);
  });

  socket.on("describe", (sessionDesc) => {
    console.debug("SDP received of type: ", sessionDesc.type);
    socket.rooms.forEach((room) => {
      socket.to(room).emit("describe", sessionDesc);
    });
  });

  socket.on("candidate", (candidate) => {
    console.debug("Candidate received: ", candidate.candidate);
    socket.rooms.forEach((room) => {
      socket.to(room).emit("candidate", candidate);
    });
  });

  socket.on("test", () => {
    console.debug(`Received Test from ${socket.id}`);
    let rooms = socket.rooms;
    console.log(`${socket.id} is in rooms ${rooms.size}`);
    rooms.forEach((room) => {
      console.log(`Sending test to room ${room}`);
      socket.to(room).emit("test", "socket.to");
    });
    socket.broadcast.emit("test", "socket.broadcast");
  });

  socket.on("disconnecting", () => {
    console.log(`User ${socket.id} disconnected from rooms: `, socket.rooms);
    const rooms = Array.from(socket.rooms);

    rooms.forEach((room) => {
      socket.to(room).emit("bye");
    });
  });
});

app.use(express.static("public"));

app.use(
  "/material-icons",
  express.static("node_modules/material-icons/iconfont")
);
app.get("/config", (_, res) => {
  const secret = config.TURN_SECRET;
  const ttl = parseInt(config.TURN_TTL);
  const [username, password] = generateTurnCredentials(secret, ttl);
  console.log(`TURN username: ${username}, password: ${password}`);

  const updatedIceServers = peerConfig.iceServers.map((server) => {
    if (server.urls[0].startsWith("turn:")) {
      return {
        urls: server.urls,
        username: username,
        credential: password,
      };
    } else {
      return server;
    }
  });

  const updatedPeerConfig = {
    iceServers: updatedIceServers,
    iceTransportPolicy: peerConfig.iceTransportPolicy,
  };

  res.json(updatedPeerConfig);
});

server.listen(port, () => {
  console.log("Server Started.");
  console.log(`Listening on http://localhost:${port}`);
});