React Native Requires Chilkat v11.0.0+

Transfer a File using Sockets (TLS or non-TLS)

See more Socket/SSL/TLS Examples

Demonstrates how to two programs, one a socket writer and the other a socket reader, can transfer a file. The connection can be TLS or a regular non-encrypted TCP connection. React Native

import { BinData, Socket } from '@chilkat/react-native'

async function chilkatExample() {
  // This example requires the Chilkat API to have been previously unlocked.
  // See Global Unlock Sample for sample code.

  // On the sending side, we'll load the file into a BinData object and send.
  // On the receiving side, we'll read from the socket connection into a BinData, and save to a file.
  // This example assumes the file is not crazy-large, and that the entire contents
  // can fit into memory.  
  // (If the file is too large for memory, there are other ways to send. It just involves streaming or 
  // sending the file chunk-by-chunk..)

  // This section of code is for the sender.
  const bdToSend = new BinData();
  bdToSend.loadFile('somePath/someFile.dat');
  // Assume success for the example...

  const sndSock = new Socket();
  const bUseTls = true;
  const port = 5555;
  let maxWaitMs = 5000;
  await sndSock.connectAsync('some_domain_or_ip.com', port, bUseTls, maxWaitMs);
  // Assume success for the example...

  // Tell the receiver how many bytes are coming.
  const numBytes = bdToSend.numBytes;
  const bBigEndian = true;
  await sndSock.sendInt32Async(numBytes, bBigEndian);

  // Send the file data (sends the entire contents of bdToSend).
  await sndSock.sendBdAsync(bdToSend, 0, 0);

  // Get an acknowledgement.
  try {
    await sndSock.receiveInt32Async(bBigEndian);
  } catch {
    console.log(sndSock.lastErrorText);
    return;
  }

  // Did the receiver get the correct number of bytes?
  if (sndSock.receivedInt !== numBytes) {
    console.log('The receiver did not acknowledge with the correct number of bytes.');
    return;
  }

  console.log('File sent!');

  // ------------------------------------------------------------------------------------
  // The code below is for the receiving side (running on some other computer..)

  const listenSock = new Socket();

  try {
    await listenSock.bindAndListenAsync(5555, 25);
  } catch {
    console.log(listenSock.lastErrorText);
    return;
  }

  // Get the next incoming connection
  // Wait a maximum of 20 seconds (20000 millisec)
  const rcvSock = new Socket();
  try {
    await listenSock.acceptNextAsync(20000, rcvSock);
  } catch {
    console.log(listenSock.lastErrorText);
    return;
  }

  // The sender will first send the big-endian integer for the number of bytes
  // that are forthcoming..
  try {
    await rcvSock.receiveInt32Async(bBigEndian);
  } catch {
    console.log(rcvSock.lastErrorText);
    return;
  }

  const numBytesComing = rcvSock.receivedInt;

  // Receive that many bytes..
  const bdReceived = new BinData();
  try {
    await rcvSock.receiveBdNAsync(numBytesComing, bdReceived);
  } catch {
    console.log(rcvSock.lastErrorText);
    return;
  }

  // Acknowledge the sender by sending back the number of bytes we received.
  await rcvSock.sendInt32Async(bdReceived.numBytes, bBigEndian);

  // Close the connection.
  maxWaitMs = 20;
  await rcvSock.closeAsync(maxWaitMs);

  // Save the received data to a file.
  bdReceived.writeFile('somePath/someFile.dat');
  // Assume success for the example...

  console.log('File received!');
}