Jassif Team Institution

const net = require('net');

const net = require('net');

// Create a TCP server
const server = net.createServer((socket) => {
  console.log('Client connected');
  
  // Set encoding to utf8 so we receive strings instead of Buffer objects
  socket.setEncoding('utf8');
  
  // Handle data from client
  socket.on('data', (data) => {
    console.log(`Received from client: ${data}`);
    
    // Echo the data back to the client
    socket.write(`Echo: ${data}`);
  });
  
  // Handle client disconnection
  socket.on('end', () => {
    console.log('Client disconnected');
  });
  
  // Handle errors
  socket.on('error', (err) => {
    console.error('Socket error:', err);
  });
  
  // Send a welcome message to the client
  socket.write('Welcome to the TCP server!\r\n');
});

// Start the server and listen on port 8080
server.listen(8080, () => {
  console.log('TCP Server running on port 8080');
});

const net = require('net');

// Create a TCP client
const client = net.createConnection({ port: 8080 }, () => {
  console.log('Connected to server');
  
  // Send a message to the server
  client.write('Hello from client!');
});

// Set encoding
client.setEncoding('utf8');

// Handle data from server
client.on('data', (data) => {
  console.log(`Received from server: ${data}`);
  
  // Send another message
  client.write('More data from client');
});

// Handle connection end
client.on('end', () => {
  console.log('Disconnected from server');
});

// Handle errors
client.on('error', (err) => {
  console.error('Connection error:', err);
});

const net = require('net');

// Store all client connections
const clients = [];

// Create a chat server
const server = net.createServer((socket) => {
  // Generate a client ID
  const clientId = `${socket.remoteAddress}:${socket.remotePort}`;
  console.log(`Client connected: ${clientId}`);
  
  // Set encoding
  socket.setEncoding('utf8');
  
  // Add client to the list
  clients.push(socket);
  
  // Send welcome message
  socket.write(`Welcome to the chat server! There are ${clients.length} users online.\r\n`);
  
  // Broadcast message to all clients except the sender
  function broadcast(message, sender) {
    clients.forEach(client => {
      if (client !== sender) {
        client.write(message);
      }
    });
  }
  
  // Notify all clients about the new connection
  broadcast(`User ${clientId} joined the chat.\r\n`, socket);
  
  // Handle client messages
  socket.on('data', (data) => {
    console.log(`${clientId}: ${data.trim()}`);
    
    // Broadcast the message to all other clients
    broadcast(`${clientId}: ${data}`, socket);
  });
  
  // Handle client disconnection
  socket.on('end', () => {
    console.log(`Client disconnected: ${clientId}`);
    
    // Remove client from the list
    const index = clients.indexOf(socket);
    if (index !== -1) {
      clients.splice(index, 1);
    }
    
    // Notify all clients about the disconnection
    broadcast(`User ${clientId} left the chat.\r\n`, null);
  });
  
  // Handle errors
  socket.on('error', (err) => {
    console.error(`Socket error from ${clientId}:`, err);
  });
});

// Start the server
const PORT = 8080;
server.listen(PORT, () => {
  console.log(`Chat server running on port ${PORT}`);
});

// Handle server errors
server.on('error', (err) => {
  console.error('Server error:', err);
});

telnet localhost 8080

const net = require('net');
const readline = require('readline');

// Create interface for reading from the terminal
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
});

// Create a client connection
const client = net.createConnection({ port: 8080 }, () => {
  console.log('Connected to chat server');
  console.log('Type a message and press Enter to send');
  
  // Start reading user input
  rl.prompt();
});

// Set encoding
client.setEncoding('utf8');

// Handle data from server
client.on('data', (data) => {
  // Move cursor to beginning of line and clear it
  process.stdout.write('\r\x1b[K');
  
  // Print the server message
  console.log(data.trim());
  
  // Re-display the prompt
  rl.prompt();
});

// Handle connection end
client.on('end', () => {
  console.log('Disconnected from server');
  rl.close();
  process.exit(0);
});

// Handle errors
client.on('error', (err) => {
  console.error('Connection error:', err);
  rl.close();
  process.exit(1);
});

// Handle user input
rl.on('line', (input) => {
  // Send the user input to the server
  client.write(input);
  rl.prompt();
});

// Close the connection when the user exits
rl.on('close', () => {
  console.log('Exiting chat...');
  client.end();
});

const net = require('net');

// Create a server that supports a JSON-based protocol
const server = net.createServer((socket) => {
  console.log('Client connected');
  
  // Buffer for incoming data
  let buffer = '';
  
  // Handle data
  socket.on('data', (data) => {
    // Add the new data to our buffer
    buffer += data.toString();
    
    // Process complete messages
    let boundary = buffer.indexOf('\n');
    while (boundary !== -1) {
      // Extract the complete message
      const message = buffer.substring(0, boundary);
      buffer = buffer.substring(boundary + 1);
      
      // Process the message
      try {
        const parsedMessage = JSON.parse(message);
        console.log('Received message:', parsedMessage);
        
        // Handle different message types
        switch (parsedMessage.type) {
          case 'greeting':
            socket.write(JSON.stringify({
              type: 'welcome',
              message: `Hello, ${parsedMessage.name}!`,
              timestamp: Date.now()
            }) + '\n');
            break;
            
          case 'query':
            socket.write(JSON.stringify({
              type: 'response',
              queryId: parsedMessage.queryId,
              result: handleQuery(parsedMessage.query),
              timestamp: Date.now()
            }) + '\n');
            break;
            
          default:
            socket.write(JSON.stringify({
              type: 'error',
              message: 'Unknown message type',
              timestamp: Date.now()
            }) + '\n');
        }
      } catch (err) {
        console.error('Error processing message:', err);
        socket.write(JSON.stringify({
          type: 'error',
          message: 'Invalid JSON format',
          timestamp: Date.now()
        }) + '\n');
      }
      
      // Look for the next message
      boundary = buffer.indexOf('\n');
    }
  });
  
  // Handle disconnection
  socket.on('end', () => {
    console.log('Client disconnected');
  });
  
  // Handle errors
  socket.on('error', (err) => {
    console.error('Socket error:', err);
  });
});

// Simple function to handle queries
function handleQuery(query) {
  if (query === 'time') {
    return { time: new Date().toISOString() };
  } else if (query === 'stats') {
    return {
      uptime: process.uptime(),
      memory: process.memoryUsage(),
      platform: process.platform
    };
  } else {
    return { error: 'Unknown query' };
  }
}

// Start the server
const PORT = 8080;
server.listen(PORT, () => {
  console.log(`JSON protocol server running on port ${PORT}`);
});

const net = require('net');

// Connect to the server
const client = net.createConnection({ port: 8080 }, () => {
  console.log('Connected to server');
  
  // Send a greeting
  send({
    type: 'greeting',
    name: 'Client'
  });
  
  // Send a query
  send({
    type: 'query',
    queryId: 1,
    query: 'time'
  });
  
  // Send another query
  setTimeout(() => {
    send({
      type: 'query',
      queryId: 2,
      query: 'stats'
    });
  }, 1000);
});

// Buffer for incoming data
let buffer = '';

// Handle data from server
client.on('data', (data) => {
  // Add the new data to our buffer
  buffer += data.toString();
  
  // Process complete messages
  let boundary = buffer.indexOf('\n');
  while (boundary !== -1) {
    // Extract the complete message
    const message = buffer.substring(0, boundary);
    buffer = buffer.substring(boundary + 1);
    
    // Process the message
    try {
      const parsedMessage = JSON.parse(message);
      console.log('Received from server:', parsedMessage);
    } catch (err) {
      console.error('Error parsing message:', err);
    }
    
    // Look for the next message
    boundary = buffer.indexOf('\n');
  }
});

// Helper function to send messages
function send(message) {
  const jsonString = JSON.stringify(message) + '\n';
  console.log('Sending:', message);
  client.write(jsonString);
}

// Handle connection end
client.on('end', () => {
  console.log('Disconnected from server');
});

// Handle errors
client.on('error', (err) => {
  console.error('Connection error:', err);
});

// Close the connection after some time
setTimeout(() => {
  console.log('Closing connection');
  client.end();
}, 5000);

const net = require('net');

const server = net.createServer((socket) => {
  console.log('Client connected');
  
  // Set a timeout of 10 seconds
  socket.setTimeout(10000);
  
  // Handle timeout
  socket.on('timeout', () => {
    console.log('Socket timeout');
    socket.write('You have been inactive for too long. Disconnecting...\r\n');
    socket.end();
  });
  
  // Handle data
  socket.on('data', (data) => {
    console.log(`Received: ${data.toString().trim()}`);
    socket.write(`Echo: ${data}`);
  });
  
  // Handle disconnection
  socket.on('end', () => {
    console.log('Client disconnected');
  });
});

server.listen(8080, () => {
  console.log('Server with timeout running on port 8080');
});

const net = require('net');
const path = require('path');

// Define the path for the IPC socket
const socketPath = path.join(__dirname, 'ipc-socket');

// Create an IPC server
const server = net.createServer((socket) => {
  console.log('Client connected to IPC server');
  
  socket.on('data', (data) => {
    console.log(`Received via IPC: ${data.toString().trim()}`);
    socket.write(`Echo: ${data}`);
  });
  
  socket.on('end', () => {
    console.log('Client disconnected from IPC server');
  });
});

// Start the IPC server
server.listen(socketPath, () => {
  console.log(`IPC server running at ${socketPath}`);
});

// Clean up the socket file when the server closes
server.on('close', () => {
  console.log('Cleaning up socket file');
  require('fs').unlinkSync(socketPath);
});

// Handle process termination
process.on('SIGINT', () => {
  server.close(() => {
    console.log('IPC server closed');
    process.exit(0);
  });
});

const net = require('net');
const path = require('path');

// Define the path for the IPC socket
const socketPath = path.join(__dirname, 'ipc-socket');

// Create an IPC client
const client = net.createConnection({ path: socketPath }, () => {
  console.log('Connected to IPC server');
  client.write('Hello from IPC client!');
});

client.on('data', (data) => {
  console.log(`Received from IPC server: ${data.toString().trim()}`);
  client.end();
});

client.on('end', () => {
  console.log('Disconnected from IPC server');
});

client.on('error', (err) => {
  console.error('Connection error:', err);
});