srf.invite((req, res) => {
    let mySdp; // populated somehow with SDP we want to answer in 200 OK
    srf.createUas(req, res, {localSdp: mySdp})
      .then((uas) => {
        console.log(`dialog established, remote uri is ${uas.remote.uri}`);
        uas.on('destroy', () => {
          console.log('caller hung up');
        });
        return;
      })
      .catch((err) => {
        console.log(`Error establishing dialog: ${err}`);
      });
  });

  srf.invite((req, res) => {
    let mySdp; // populated somehow with SDP we want to answer in 200 OK
    srf.createUas(req, res, {
      localSdp: mySdp,
      headers: {
        'User-Agent': 'drachtio/iechyd-da',
        'X-Linked-UUID': '1e2587c'
      }
    }, (err, uas) => {
      if (err) return console.log(`Error creating dialog: ${err}`);
      console.log(`dialog established, local tag is ${uas.sip.localTag}`);

      uas.on('destroy', () => console.log('caller hung up'));
    });
  });

  let mySdp; // populated somehow with SDP we want to offer
  srf.createUAC('sip:1234@10.10.100.1', {localSdp: mySdp})
    .then((uac) => {
      console.log(`dialog established, call-id is ${uac.sip.callId}`);
      uac.on('destroy', () => console.log('called party hung up'));
      return;
    })
    .catch((err) => {
      console.error(`INVITE rejected with status: ${err}`);
      console.log(err.stack);
    });

  let mySdp; // populated somehow with SDP we want to offer
  srf.createUac('sip:1234@10.10.100.1', {localSdp: mySdp},
     (err, uac) => {
       if (err) return console.log(`INVITE rejected with status: ${err.status}`);
      
      uac.on('destroy', () => console.log('called party hung up'));
    });

  const Srf = require('drachtio-srf');
  const srf = new Srf();
  const assert = require('assert');

  let mySdp; // populated somehow with SDP we want to offer
  let inviteSent;
  srf.createUAC('sip:1234@10.10.100.1', {localSdp: mySdp},
    {
      cbRequest: (err, reqSent) => { inviteSent = reqSent; }
    })
    .then((uac) => {
      // unexpected, in this case
      return console.log('dialog established before we could cancel');
    })
    .catch((err) => {
      assert(err.status === 487); // expected sip response to a CANCEL
    });

  // cancel the request after 0.5s
  setTimeout(() => {
    if (inviteSent) inviteSent.cancel();
  }, 500);

  const Srf = require('drachtio-srf');
  const srf = new Srf();

  srf.connect({..});

  srf.invite((req, res) => {
    srf.createB2BUA(req, res, 'sip:1234@10.10.100.1', {localSdpB: req.body})
      .then(({uas, uac}) => {
        console.log('call connected');

        // when one side terminates, hang up the other
        uas.on('destroy', () => { uac.destroy(); });
        uac.on('destroy', () => { uas.destroy(); });
        return;
      })
      .catch((err) => {
        console.log(`call failed to connect: ${err}`);
      });
  });

  const Srf = require('drachtio-srf');
  const srf = new Srf();

  srf.connect({..});

  function endCall(dlg1, dlg2) {
    dlg1.on('destroy', () => dlg2.destroy());
    dlg2.on('destroy', () => dlg1.destroy());
  }
  srf.invite((req, res) => {
    srf.createB2BUA(req, res, 'sip:1234@10.10.100.1', {localSdpB: req.body, passFailure: false})
      .catch((err) => {
        // try backup if we got a sip non-success response and the caller did not hang up
        if (err instanceof Srf.SipError && err.status !== 487) {
          console.log(`failed connecting to primary, will try backup: ${err}`);
          return {};
        }
        throw err;
      })
      .then(({uas, uac}) => {
        if (!uas) return srf.createB2BUA(req, res, 'sip:1234@10.10.100.2', {localSdpB: req.body});
        return {uas, uac};
      })
      .then(({uas, uac}) => {
        return endCall({uas, uac});
      })
      .catch((err) => {
        console.log(`failed connecting to backup uri: ${err}`);
      });
  });

  const Srf = require('drachtio-srf');
  const srf = new Srf();
  const config = require('config');
  const Client = require('rtpengine-client').Client;
  const rtpengine = new Client();

  srf.connect(config.get('drachtio'));

  // clean up and free rtpengine resources when either side hangs up
  function endCall(dlg1, dlg2, details) {
    [dlg1, dlg2].each((dlg) => dlg.on('destroy', () => (dlg === dlg1 ? dlg2 : dlg1).destroy()));
    rtpengine.delete(config.get('rtpengine'), details);
  }

  // function returning a Promise that resolves with the SDP to offer A leg in 18x/200 answer
  function getSdpA(details, remoteSdp, res) {
    return rtpengine.answer(config.get('rtpengine'), Object.assign(details, {
      'sdp': remoteSdp,
      'to-tag': res.getParsedHeader('To').params.tag
    }))
      .then((response) => {
        if (response.result !== 'ok') throw new Error(`Error calling answer: ${response['error-reason']}`);
        return response.sdp;
      });
  }

  // handle incoming invite
  srf.invite((req, res) => {
    const from = req.getParsedHeader('From');
    const details = {'call-id': req.get('Call-Id'), 'from-tag': from.params.tag};

    rtpengine.offer(config.get('rtpengine'), Object.assign(details, {'sdp': req.body}))
      .then((rtpResponse) => {
        if (rtpResponse && rtpResponse.result === 'ok') return rtpResponse.sdp;
        throw new Error('rtpengine failure');
      })
      .then((sdpB) => {
        return srf.createB2BUA(req, res, config.get('uri'), {
          localSdpB: sdpB,
          localSdpA: getSdpA.bind(null, details)
        });
      })
      .then(({uas, uac}) => {
        console.log('call connected with media proxy');
        return endCall(uas, uac, details);
      })
      .catch((err) => {
        console.log(`Error proxying call with media: ${err}`);
      });
  });

  const Srf = require('drachtio-srf');
  const srf = new Srf();
  
  srf.invite((req, res) => {
    srf.proxyRequest(req, ['sip.example1.com', 'sip.example2.com'], {
      recordRoute: true,
      followRedirects: true,
      provisionalTimeout: '2s'
    }).then((results) => {
      console.log(JSON.stringify(result)); 
      // {finalStatus: 200, finalResponse:{..}, responses: [..]}
    });
  });

  const Srf = require('drachtio-srf');
  const srf = new Srf();

  srf.connect({host: '127.0.0.1', port: 9022, secret: 'cymru'});

  srf.on('connect', (err, hp) => {
    if (err) return console.log(`Error connecting: ${err}`);
    console.log(`connected to server listening on ${hp}`);

    setInterval(optionsPing, 10000);
  });

  function optionsPing() {
    srf.request('sip:tighthead.drachtio.org', {
      method: 'OPTIONS',
      headers: {
        'Subject': 'OPTIONS Ping'
      }
    }, (err, req) => {
      if (err) return console.log(`Error sending OPTIONS: ${err}`);
      req.on('response', (res) => {
        console.log(`Response to OPTIONS ping: ${res.status}`);
      });
    });
  }

  const Srf = require('drachtio-srf');
  const srf = new Srf() ;
  const digestAuth = require('drachtio-mw-digest-auth');
  const regParser = require('drachtio-mw-registration-parser');

  srf.connect({...}) ;
  
  const challenge = digestAuth({
    realm: 'sip.drachtio.org',
    passwordLookup: function(username, realm, callback) {
      // ..lookup password for username in realm
      return callback(null, password) ;
    }
  }) ;

  srf.use('register', challenge) ;
  srf.use('register', regParser) ;
  srf.register((req, res) => {
    // if we reach here we have an authenticated request
    // and 'registration' property added to 'req'

    res.send(200, {
      headers: {
        'Expires': req.registration.expires
      }
    });
  });

  srf.invite((req, res) => {
    console.log(req.get('Via'));
    // SIP/2.0/UDP 172.16.0.129:5061;branch=z9hG4bK-1859-1-0;received=127.0.0.1;rport=5061

  srf.invite((req, res) => {
    console.log(JSON.stringify(req.getParsedHeader('Via')));
    /*
    [{
      "version": "2.0",
      "protocol": "UDP",
      "host": "172.16.0.129",
      "port": 5061,
      "params": {
        "branch": "z9hG4bK-2070-1-0",
        "received": "127.0.0.1",
        "rport": "5061"
      }
    }]
    */