try {
if (self.secure) {
if (!securePool) allocNewSecurePool();
- secureBytesRead = read(self.fd, securePool, 0, securePool.length);
- self.secureStream.readInject(securePool, 0, secureBytesRead);
- bytesRead = self.secureStream.readExtract(pool,
- pool.used,
- pool.length - pool.used);
+ var calledByNextTick = (arguments.length == 0); // IOWatcher always passes arguments
+ if (!calledByNextTick) {
+ secureBytesRead = read(self.fd, securePool, 0, securePool.length);
+ self.secureStream.readInject(securePool, 0, secureBytesRead);
+ }
+ var chunkBytes;
+ bytesRead = 0;
+ do {
+ chunkBytes = self.secureStream.readExtract(pool,
+ pool.used + bytesRead,
+ pool.length - pool.used - bytesRead);
+ bytesRead += chunkBytes;
+ } while ((chunkBytes > 0) && (pool.used + bytesRead < pool.length));
+ if (bytesRead == 0 && calledByNextTick)
+ return;
+ if (self.secureStream.readPending()) {
+ process.nextTick(function () {
+ if(self._readWatcher)
+ self._readWatcher.callback();
+ });
+ }
if (!self.secureEstablished) {
if (self.secureStream.isInitFinished()) {
self.secureEstablished = true;
SecureStream::WriteInject);
NODE_SET_PROTOTYPE_METHOD(t, "writeExtract",
SecureStream::WriteExtract);
+ NODE_SET_PROTOTYPE_METHOD(t, "readPending",
+ SecureStream::ReadPending);
NODE_SET_PROTOTYPE_METHOD(t, "writeCanExtract",
SecureStream::WriteCanExtract);
NODE_SET_PROTOTYPE_METHOD(t, "getPeerCertificate",
return scope.Close(Integer::New(bytes_read));
}
+Handle<Value> SecureStream::ReadPending(const Arguments& args) {
+ HandleScope scope;
+
+ SecureStream *ss = ObjectWrap::Unwrap<SecureStream>(args.Holder());
+ int bytes_pending = BIO_pending(ss->pbioRead);
+ return scope.Close(Integer::New(bytes_pending));
+}
+
Handle<Value> SecureStream::WriteCanExtract(const Arguments& args) {
HandleScope scope;
static v8::Handle<v8::Value> New(const v8::Arguments& args);
static v8::Handle<v8::Value> ReadInject(const v8::Arguments& args);
static v8::Handle<v8::Value> ReadExtract(const v8::Arguments& args);
+ static v8::Handle<v8::Value> ReadPending(const v8::Arguments& args);
static v8::Handle<v8::Value> WriteCanExtract(const v8::Arguments& args);
static v8::Handle<v8::Value> WriteExtract(const v8::Arguments& args);
static v8::Handle<v8::Value> WriteInject(const v8::Arguments& args);