Index: trunk/lib/Danga/Socket/SSL.pm
===================================================================
--- trunk/lib/Danga/Socket/SSL.pm (revision 1)
+++ trunk/lib/Danga/Socket/SSL.pm (revision 2)
@@ -16,6 +16,6 @@
 
 use fields (
-            '_ssl',  # our SSL state
-            '_write_when_readable',
+            'ssl_state',  # our SSL state
+            'ssl_write_when_readable',
             );
 
@@ -66,5 +66,5 @@
 
     my $ssl = Net::SSLeay::new($ctx) or die_now("Failed to create SSL $!");
-    $self->{_ssl} = $ssl;
+    $self->{ssl_state} = $ssl;
 
 #    Net::SSLeay::set_verify($ssl, Net::SSLeay::VERIFY_PEER(), 0);
@@ -91,5 +91,5 @@
 sub _danga_socket_writerfunc {
     my Danga::Socket::SSL $conn = shift;
-    my $ssl = $conn->{_ssl};
+    my $ssl = $conn->{ssl_state};
     return sub {
         my ($bref, $to_write, $offset) = @_;
@@ -97,5 +97,5 @@
         # unless our event_read has been called, we don't want to try
         # to do any work now.  and probably we should complain.
-        if ($conn->{_write_when_readable}) {
+        if ($conn->{ssl_write_when_readable}) {
             warn "writer func called when we're waiting for readability first.\n";
             return 0;
@@ -133,8 +133,13 @@
 }
 
+sub is_ssl {
+    my Danga::Socket::SSL $self = shift;
+    return $self->{ssl_state} ? 1 : 0;
+}
+
 # return SSL state object.  more useful as a boolean if conn is in SSL mode.
 sub ssl_state {
     my Danga::Socket::SSL $self = shift;
-    return $self->{_ssl};
+    return $self->{ssl_state};
 }
 
@@ -144,8 +149,10 @@
     my $self = shift;
 
+    print "self = $self\n";
+
     # enable readability, but remember old value so we can pop it back
     my $prev_readable = ($self->{event_watch} & POLLIN)  ? 1 : 0;
     $self->watch_read(1);
-    $self->{_write_when_readable} = [ $prev_readable ];
+    $self->{ssl_write_when_readable} = [ $prev_readable ];
 
     # don't need to push/pop its state because Danga::Socket->write, called later,
@@ -158,5 +165,5 @@
 sub on_incomplete_write {
     my $self = shift;
-    return if $self->{_write_when_readable};
+    return if $self->{ssl_write_when_readable};
     $self->SUPER::on_incomplete_write;
 }
@@ -167,5 +174,5 @@
     my $amount = $_[1];
 
-    my $ssl = $self->{_ssl};
+    my $ssl = $self->{ssl_state};
     return $self->SUPER::read($amount) unless $ssl;
 
@@ -197,6 +204,6 @@
     # we then go back into the write path (by flushing the write
     # buffer) and it then does a read on this socket.
-    if (my $ar = $self->{_write_when_readable}) {
-        $self->{_write_when_readable} = 0;
+    if (my $ar = $self->{ssl_write_when_readable}) {
+        $self->{ssl_write_when_readable} = 0;
         $self->watch_read($ar->[0]);  # restore previous readability state
         $self->watch_write(1);