Jassif Team Institution

// Net தொகுதியை இறக்குமதி செய்க
const net = require('net');

// ஒரு Socket உருவாக்க
const socket = new net.Socket();

const net = require('net');

// புதிய socket உருவாக்க
const client = new net.Socket();

// ஒரு சேவையகத்துடன் இணை
client.connect(8080, '127.0.0.1', () => {
  console.log('Connected to server');
  
  // சேவையகத்திற்கு தரவை அனுப்ப
  client.write('Hello, server! From client.');
});

// சேவையகத்திலிருந்து பெறப்பட்ட தரவைக் கையாள
client.on('data', (data) => {
  console.log(`Received from server: ${data.toString()}`);
  
  // பதில் பெற்ற பிறகு இணைப்பை மூடு
  client.end();
});

// இணைப்பு மூடலைக் கையாள
client.on('close', () => {
  console.log('Connection closed');
});

// பிழைகளைக் கையாள
client.on('error', (err) => {
  console.error(`Error: ${err.message}`);
});

const net = require('net');

// TCP server உருவாக்க
const server = net.createServer((socket) => {
  // 'socket' என்பது client இணைப்பு - net.Socket இன் ஒரு instance
  
  console.log(`Client connected: ${socket.remoteAddress}:${socket.remotePort}`);
  
  // Encoding அமை
  socket.setEncoding('utf8');
  
  // Client இலிருந்து தரவைக் கையாள
  socket.on('data', (data) => {
    console.log(`Received from client: ${data}`);
    
    // தரவை client க்கு echo செய்
    socket.write(`You said: ${data}`);
  });
  
  // Client துண்டிப்பைக் கையாள
  socket.on('end', () => {
    console.log('Client disconnected');
  });
  
  // Socket பிழைகளைக் கையாள
  socket.on('error', (err) => {
    console.error(`Socket error: ${err.message}`);
  });
  
  // Client க்கு வரவேற்பு செய்தியை அனுப்ப
  socket.write('Welcome to the TCP server!\n');
});

// Port 8080 இல் server ஐத் தொடங்கு
server.listen(8080, '127.0.0.1', () => {
  console.log('Server listening on port 8080');
});

// Server பிழைகளைக் கையாள
server.on('error', (err) => {
  console.error(`Server error: ${err.message}`);
});

const net = require('net');

// Timeouts உடன் server உருவாக்க
const server = net.createServer((socket) => {
  console.log('Client connected');
  
  // Socket timeout ஐ 10 விநாடிகளாக அமை
  socket.setTimeout(10000);
  
  // Socket timeout ஐக் கையாள
  socket.on('timeout', () => {
    console.log('Socket timeout - no activity for 10 seconds');
    socket.write('You have been inactive for too long. The connection will be closed.');
    socket.end();
  });
  
  // தரவைக் கையாள
  socket.on('data', (data) => {
    console.log(`Received: ${data.toString()}`);
    socket.write('Data received');
    
    // ஒவ்வொரு முறையும் தரவைப் பெறும்போது, timeout மீட்டமைக்கப்படும்
    console.log('Timeout timer reset');
  });
  
  // Socket மூடலைக் கையாள
  socket.on('close', () => {
    console.log('Socket closed');
  });
  
  // வரவேற்பு செய்தியை அனுப்ப
  socket.write('Welcome! This connection will timeout after 10 seconds of inactivity.\n');
});

// Server ஐத் தொடங்கு
const PORT = 8081;
server.listen(PORT, () => {
  console.log(`Timeout example server running on port ${PORT}`);
  
  // சோதனைக்கு: இணையும் ஆனால் தரவை அனுப்பாத client உருவாக்க
  const client = new net.Socket();
  client.connect(PORT, '127.0.0.1', () => {
    console.log('Test client connected');
    
    // 5 விநாடிகளுக்குப் பிறகு ஒரு செய்தியை அனுப்புவோம் (timeout க்கு முன்)
    setTimeout(() => {
      client.write('Hello after 5 seconds');
    }, 5000);
    
    // வேறு எதையும் அனுப்ப மாட்டோம், எனவே இணைப்பு timeout ஆக வேண்டும்
    // மற்றொரு 10 விநாடிகளுக்குப் பிறகு
  });
  
  client.on('data', (data) => {
    console.log(`Client received: ${data.toString()}`);
  });
  
  client.on('close', () => {
    console.log('Client disconnected');
  });
});

const net = require('net');

// விருப்பங்களுடன் Socket உருவாக்க
const socket = new net.Socket();

// Socket விருப்பங்களை உள்ளமை
socket.setKeepAlive(true, 1000); // 1 விநாடி ஆரம்ப தாமதத்துடன் keep-alive ஐ இயக்கு
socket.setNoDelay(true); // Nagle's algorithm ஐ முடக்கு (buffer செய்யாதது)

// ஒரு சேவையகத்துடன் இணை
socket.connect({
  port: 80,
  host: 'example.com',
  family: 4, // IPv4
  localAddress: '0.0.0.0', // bind செய்ய உள்ளூர் இடைமுகம்
  localPort: 8000 // bind செய்ய உள்ளூர் port
}, () => {
  console.log('Connected with options');
  
  // Socket தகவலைக் காட்டு
  console.log(`Local address: ${socket.localAddress}:${socket.localPort}`);
  console.log(`Remote address: ${socket.remoteAddress}:${socket.remotePort}`);
  console.log(`Remote family: ${socket.remoteFamily}`);
  
  // எளிய HTTP கோரிக்கையை அனுப்ப
  socket.write('GET / HTTP/1.1\r\n');
  socket.write('Host: example.com\r\n');
  socket.write('Connection: close\r\n');
  socket.write('\r\n');
});

// தரவைக் கையாள
let responseData = '';
socket.on('data', (data) => {
  const chunk = data.toString();
  responseData += chunk;
  
  // பதிலின் முதல் வரியைக் காட்டு
  if (responseData.includes('\r\n') && !socket.firstLineShown) {
    const firstLine = responseData.split('\r\n')[0];
    console.log(`First line of response: ${firstLine}`);
    socket.firstLineShown = true;
  }
});

// தரவு முடிவைக் கையாள
socket.on('end', () => {
  console.log('Response complete');
  console.log(`Total bytes received: ${socket.bytesRead}`);
  console.log(`Total bytes sent: ${socket.bytesWritten}`);
});

// பிழைகளைக் கையாள
socket.on('error', (err) => {
  console.error(`Socket error: ${err.message}`);
});

const net = require('net');

// Buffer கையாளுதலை நிரூபிக்க server உருவாக்க
const server = net.createServer((socket) => {
  console.log('Client connected');
  
  // Buffer ஐ வேகமாக நிரப்புவதை நிரூபிக்க சிறியதாக்கு
  socket.bufferSize = 1024; // குறிப்பு: இது உண்மையில் buffer அளவைக் கட்டுப்படுத்தாது
  
  // Client க்கு மெதுவான பதிலை அனுப்புவதன் மூலம் buffering ஐ நிரூபிக்க
  socket.on('data', (data) => {
    console.log(`Received data: ${data.toString().trim()}`);
    console.log('Sending large response...');
    
    // Buffer நிரம்பும் வரை தரவை எழுதும் செயல்பாடு
    const writeUntilBufferFull = () => {
      // அனுப்ப சில தரவை உருவாக்கு
      const chunk = 'x'.repeat(1024);
      
      // Buffer நிரம்பும் வரை எழுதுவதைத் தொடர் (write false திரும்பும்)
      let i = 0;
      while (i < 100) {
        const canContinue = socket.write(`Chunk ${i}: ${chunk}\n`);
        console.log(`Wrote chunk ${i}, buffer full? ${!canContinue}`);
        
        // Buffer நிரம்பியிருந்தால், அது drain ஆகக் காத்திரு
        if (!canContinue) {
          console.log(`Buffer is full after ${i} writes. Current buffer size: ${socket.bufferSize} bytes`);
          // எழுதுவதை நிறுத்தி 'drain' நிகழ்வுக்குக் காத்திரு
          socket.once('drain', () => {
            console.log('Buffer drained, resuming writes');
            writeUntilBufferFull();
          });
          return;
        }
        i++;
      }
      
      // அனைத்து chunks எழுதப்பட்டது
      console.log('All data sent');
      socket.end('\nTransmission complete');
    };
    
    // எழுதும் செயல்முறையைத் தொடங்கு
    writeUntilBufferFull();
  });
  
  socket.on('end', () => {
    console.log('Client disconnected');
  });
  
  socket.on('error', (err) => {
    console.error(`Socket error: ${err.message}`);
  });
  
  socket.write('Send any message to receive a large response\n');
});

// Server ஐத் தொடங்கு
const PORT = 8082;
server.listen(PORT, () => {
  console.log(`Buffer demonstration server running on port ${PORT}`);
  
  // நிரூபணத்திற்கு, இணைந்து செய்தியை அனுப்பும் client உருவாக்க
  const client = new net.Socket();
  
  client.connect(PORT, '127.0.0.1', () => {
    console.log('Test client connected');
    
    // 1 விநாடிக்குப் பிறகு செய்தியை அனுப்பு
    setTimeout(() => {
      client.write('Please send me a large response');
    }, 1000);
  });
  
  let receivedData = 0;
  client.on('data', (data) => {
    receivedData += data.length;
    console.log(`Client received ${data.length} bytes, total: ${receivedData}`);
  });
  
  client.on('end', () => {
    console.log(`Client disconnected after receiving ${receivedData} bytes`);
    process.exit(0);
  });
  
  client.on('error', (err) => {
    console.error(`Client error: ${err.message}`);
  });
});

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

// IPC path - OS ஐப் பொறுத்து
const socketPath = process.platform === 'win32'
  ? path.join('\\\\?\\pipe', process.cwd(), 'ipc-demo.sock')
  : path.join(process.cwd(), 'ipc-demo.sock');

// ஏற்கனவே உள்ள socket கோப்பை அகற்று (Unix மட்டும்)
if (process.platform !== 'win32' && fs.existsSync(socketPath)) {
  fs.unlinkSync(socketPath);
}

// IPC server உருவாக்க
const server = net.createServer((socket) => {
  console.log('Client connected to IPC socket');
  
  socket.on('data', (data) => {
    const message = data.toString().trim();
    console.log(`Server received: ${message}`);
    
    // Echo back
    socket.write(`Echo: ${message}`);
  });
  
  socket.on('end', () => {
    console.log('Client disconnected from IPC socket');
  });
  
  socket.write('Connected to IPC server\n');
});

// Server பிழைகளைக் கையாள
server.on('error', (err) => {
  console.error(`IPC server error: ${err.message}`);
});

// IPC server ஐத் தொடங்கு
server.listen(socketPath, () => {
  console.log(`IPC server listening on ${socketPath}`);
  
  // IPC socket உடன் இணையும் client உருவாக்க
  const client = new net.Socket();
  
  client.on('data', (data) => {
    console.log(`Client received: ${data.toString().trim()}`);
  });
  
  client.on('end', () => {
    console.log('Disconnected from IPC server');
  });
  
  client.on('error', (err) => {
    console.error(`IPC client error: ${err.message}`);
  });
  
  // IPC server உடன் இணை
  client.connect(socketPath, () => {
    console.log('Connected to IPC server');
    client.write('Hello via IPC socket');
    
    // பல செய்திகளை அனுப்பு
    setTimeout(() => {
      client.write('Message 1');
    }, 1000);
    
    setTimeout(() => {
      client.write('Message 2');
      client.end(); // கடைசி செய்தியை அனுப்பிய பிறகு மூடு
    }, 2000);
  });
});

// exit இல் cleanup
process.on('exit', () => {
  if (process.platform !== 'win32' && fs.existsSync(socketPath)) {
    fs.unlinkSync(socketPath);
  }
});

// Ctrl+C ஐக் கையாள
process.on('SIGINT', () => {
  console.log('Shutting down...');
  process.exit(0);
});

const net = require('net');

// Server உருவாக்க
const server = net.createServer((socket) => {
  console.log('Client connected');
  
  // ஆரம்ப செய்தியை அனுப்பு
  socket.write('Welcome to the half-close demonstration server\n');
  
  // Client இலிருந்து தரவைக் கையாள
  socket.on('data', (data) => {
    console.log(`Server received: ${data.toString().trim()}`);
  });
  
  // Socket end (client தங்கள் write stream ஐ முடித்தது)
  socket.on('end', () => {
    console.log('Client ended their write stream (half-closed)');
    
    // அவர்கள் தங்கள் write stream ஐ முடித்த பிறகும் client க்கு இன்னும் எழுதலாம்
    socket.write('You have ended your side of the connection, but I can still talk to you.');
    
    // தாமதத்திற்குப் பிறகு எங்கள் பக்கத்தை மூடு
    setTimeout(() => {
      console.log('Server now closing its write stream');
      socket.end('Goodbye! Closing my side of the connection now.');
    }, 8080);
  });
  
  // முழுமையான Socket மூடலைக் கையாள
  socket.on('close', (hadError) => {
    console.log(`Socket fully closed. Had error: ${hadError}`);
  });
  
  socket.on('error', (err) => {
    console.error(`Socket error: ${err.message}`);
  });
});

// Server ஐத் தொடங்கு
const PORT = 8083;
server.listen(PORT, () => {
  console.log(`Half-close demonstration server running on port ${PORT}`);
  
  // நிரூபணத்திற்கு client உருவாக்க
  const client = new net.Socket();
  
  client.connect(PORT, '127.0.0.1', () => {
    console.log('Client connected');
    
    // சில தரவை அனுப்பு
    client.write('Hello from client');
    
    // தாமதத்திற்குப் பிறகு client write stream ஐ முடி (half-close)
    setTimeout(() => {
      console.log('Client ending its write stream (half-closing)');
      client.end();
      
      // இனி எழுத முடியாது, ஆனால் இன்னும் தரவைப் பெற முடியும்
      console.log('Client waiting to receive more data...');
    }, 2000);
  });
  
  // Server இலிருந்து தரவைக் கையாள
  client.on('data', (data) => {
    console.log(`Client received: ${data.toString().trim()}`);
  });
  
  // Server தங்கள் write stream ஐ மூடுவதைக் கையாள
  client.on('end', () => {
    console.log('Server ended its write stream, connection fully closed');
  });
  
  // முழுமையான இணைப்பு மூடலைக் கையாள
  client.on('close', (hadError) => {
    console.log(`Client connection fully closed. Had error: ${hadError}`);
  });
  
  client.on('error', (err) => {
    console.error(`Client error: ${err.message}`);
  });
});