since being async instead of throwing Nan::Error we setErrorMessage and return; nodejs would be called back the error as the first argument

Author: harrydevnull

.gitignore

@@ -31,4 +31,5 @@ build
 
 #OSX garbage
 .DS_Store
-examples/*.pcap
+examples/*.pcap
+.vscode/

examples/pcap_dump_test.js

@@ -3,11 +3,15 @@
 
 var pcap = require("../pcap"),
 
-pcap_dump = new pcap.PcapDumpSession('en0', "ip proto \\tcp",10*1024*1024,"tmp91.pcap",false,5);
+pcap_dump = new pcap.PcapDumpSession('en0', "ip proto \\tcp",10*1024*1024,"tmp95.pcap",false,5);
 
 pcap_dump.on('pcap_write_complete_async',function(message){
         console.log("done.....",message);
 });
 
+pcap_dump.on('pcap_write_error',function(message){
+        console.log("pcap_write_error.....",message);
+});
+
 //pcap_dump.start();
 pcap_dump.startAsyncCapture();

pcap_binding.cc

@@ -50,59 +50,61 @@ class PcapWorker : public AsyncWorker {
         net = 0;
         mask = 0;
         fprintf(stderr, "warning: %s - this may not actually work\n", errbuf);
+        SetErrorMessage(errbuf);
+        return;
     }
     pcap_handle = pcap_create(device.c_str(), errbuf);
     if (pcap_handle == NULL) {
-        Nan::ThrowError(errbuf);
+        SetErrorMessage(errbuf);
         return;
     }
 
     // 64KB is the max IPv4 packet size
     if (pcap_set_snaplen(pcap_handle, 65535) != 0) {
-        Nan::ThrowError("error setting snaplen");
+       SetErrorMessage("error setting snaplen");
         return;
     }
 
     // always use promiscuous mode
     if (pcap_set_promisc(pcap_handle, 1) != 0) {
-        Nan::ThrowError("error setting promiscuous mode");
+        SetErrorMessage("error setting promiscuous mode");
         return;
     }
 
     // Try to set buffer size.  Sometimes the OS has a lower limit that it will silently enforce.
     if (pcap_set_buffer_size(pcap_handle, buffer_size) != 0) {
-        Nan::ThrowError("error setting buffer size");
+        SetErrorMessage("error setting buffer size");
         return;
     }
 
 
     // set "timeout" on read, even though we are also setting nonblock below.  On Linux this is required.
     if (pcap_set_timeout(pcap_handle, 1000) != 0) {
-        Nan::ThrowError("error setting read timeout");
+        SetErrorMessage("error setting read timeout");
         return;
     }
 
     if (pcap_activate(pcap_handle) != 0) {
-        Nan::ThrowError(pcap_geterr(pcap_handle));
+        SetErrorMessage(pcap_geterr(pcap_handle));
         return;
     }
     if ((pcap_output_filename.size()) > 0) {
         pcap_dump_handle = pcap_dump_open(pcap_handle,pcap_output_filename.c_str());
         if (pcap_dump_handle == NULL) {
-            Nan::ThrowError("error opening dump");
+            SetErrorMessage("error opening dump");
             return;
         }
     }
 
 
     if (filter.size() != 0) {
         if (pcap_compile(pcap_handle, &fp, filter.c_str(), 1, net) == -1) {
-            Nan::ThrowError(pcap_geterr(pcap_handle));
+            SetErrorMessage(pcap_geterr(pcap_handle));
             return;
         }
 
         if (pcap_setfilter(pcap_handle, &fp) == -1) {
-            Nan::ThrowError(pcap_geterr(pcap_handle));
+            SetErrorMessage(pcap_geterr(pcap_handle));
             return;
         }
 
@@ -120,16 +122,6 @@ class PcapWorker : public AsyncWorker {
     }
   }
 
-  void HandleErrorCallback(){
-    std::string error = std::string(errbuf);
-    Local<Value> argv[] = {
-       Nan::EmptyString()//TODO convert errbuf to error Message 
-      ,Nan::Null()
-    };
-
-    callback->Call(2, argv);
-  }
-
   // Executed when the async work is complete
   // this function will be run inside the main event loop
   // so it is safe to use V8 again

pcap_dump.js

@@ -4,7 +4,7 @@ var binding = require("./build/Release/pcap_binding");
 
 
 function PcapDumpSession(device_name, filter, buffer_size, outfile, is_monitor, number_of_packets_to_be_read) {
-    
+
     this.device_name = device_name;
     this.filter = filter || "";
     this.buffer_size = buffer_size;
@@ -29,47 +29,53 @@ util.inherits(PcapDumpSession, events.EventEmitter);
 
 exports.lib_version = binding.lib_version();
 
-exports.findalldevs = function() {
+exports.findalldevs = function () {
     return binding.findalldevs();
 };
 
 
-PcapDumpSession.prototype.startAsyncCapture = function() {
-    
+PcapDumpSession.prototype.startAsyncCapture = function () {
+
     this.opened = true;
     binding.create_pcap_dump_async(
-    this.device_name,
-    this.filter, 
-    this.buffer_size, 
-    this.outfile, 
-    PcapDumpSession.prototype.on_packet.bind(this),
-    this.is_monitor,
-    this.number_of_packets_to_be_read,
-    PcapDumpSession.prototype.on_pcap_write_complete_async.bind(this)
+        this.device_name,
+        this.filter,
+        this.buffer_size,
+        this.outfile,
+        PcapDumpSession.prototype.on_packet.bind(this),
+        this.is_monitor,
+        this.number_of_packets_to_be_read,
+        PcapDumpSession.prototype.on_pcap_write_complete_async.bind(this)
     );
 };
 
 
-PcapDumpSession.prototype.close = function() {
+PcapDumpSession.prototype.close = function () {
     this.opened = false;
     this.session.close();
 };
 
-PcapDumpSession.prototype.stats = function() {
+PcapDumpSession.prototype.stats = function () {
     return this.session.stats();
 };
 
-PcapDumpSession.prototype.on_pcap_write_complete_async = function(err,packet_count) {
-    this.emit("pcap_write_complete_async",{
-            "packets_read":packet_count ,
-            "fileName":this.outfile
+PcapDumpSession.prototype.on_pcap_write_complete_async = function (err, packet_count) {
+
+    if (err) {
+        this.emit("pcap_write_error", err);
+
+    } else {
+        this.emit("pcap_write_complete_async", {
+            "packets_read": packet_count,
+            "fileName": this.outfile
         });
+    }
 
 };
 
 
-PcapDumpSession.prototype.on_packet = function(packet) {
-    this.emit("packet",packet);
+PcapDumpSession.prototype.on_packet = function (packet) {
+    this.emit("packet", packet);
 
 };
 
@@ -79,6 +85,6 @@ PcapDumpSession.prototype.on_packet = function(packet) {
 exports.PcapDumpSession = PcapDumpSession;
 
 
-exports.createPcapDumpSession = function(device, filter, buffer_size, path, monitor, number_of_packets) {
+exports.createPcapDumpSession = function (device, filter, buffer_size, path, monitor, number_of_packets) {
     return new PcapDumpSession(device, filter, buffer_size, path, monitor, number_of_packets);
 };