diff --git a/serial/rfc2217.py b/serial/rfc2217.py
index 173b914..754242e 100644
--- a/serial/rfc2217.py
+++ b/serial/rfc2217.py
@@ -462,11 +462,12 @@
         self._reconfigurePort()
         # all things set up get, now a clean start
         self._isOpen = True
+        if not self.dsrdtr:
+            self._update_dtr_state()
         if not self._rtscts:
-            self.setRTS(True)
-            self.setDTR(True)
-        self.flushInput()
-        self.flushOutput()
+            self._update_rts_state()
+        self.reset_input_buffer()
+        self.reset_output_buffer()
 
     def _reconfigurePort(self):
         """Set communication parameters on opened port."""
@@ -562,7 +563,8 @@
 
     #  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -
 
-    def inWaiting(self):
+    @property
+    def in_waiting(self):
         """Return the number of characters currently in the input buffer."""
         if not self._isOpen: raise portNotOpenError
         return self._read_buffer.qsize()
@@ -598,7 +600,7 @@
                 raise SerialException("connection failed (socket error): %s" % (e,))
         return len(data)
 
-    def flushInput(self):
+    def reset_input_buffer(self):
         """Clear input buffer, discarding all that is in the buffer."""
         if not self._isOpen: raise portNotOpenError
         self.rfc2217SendPurge(PURGE_RECEIVE_BUFFER)
@@ -606,7 +608,7 @@
         while self._read_buffer.qsize():
             self._read_buffer.get(False)
 
-    def flushOutput(self):
+    def reset_output_buffer(self):
         """\
         Clear output buffer, aborting the current output and
         discarding all that is in the buffer.
@@ -614,65 +616,59 @@
         if not self._isOpen: raise portNotOpenError
         self.rfc2217SendPurge(PURGE_TRANSMIT_BUFFER)
 
-    def sendBreak(self, duration=0.25):
-        """\
-        Send break condition. Timed, returns to idle state after given
-        duration.
-        """
-        if not self._isOpen: raise portNotOpenError
-        self.setBreak(True)
-        time.sleep(duration)
-        self.setBreak(False)
-
-    def setBreak(self, level=True):
+    def _update_break_state(self):
         """\
         Set break: Controls TXD. When active, to transmitting is
         possible.
         """
         if not self._isOpen: raise portNotOpenError
         if self.logger:
-            self.logger.info('set BREAK to %s' % ('active' if level else 'inactive'))
-        if level:
+            self.logger.info('set BREAK to %s' % ('active' if self._break_state else 'inactive'))
+        if self._break_state:
             self.rfc2217SetControl(SET_CONTROL_BREAK_ON)
         else:
             self.rfc2217SetControl(SET_CONTROL_BREAK_OFF)
 
-    def setRTS(self, level=True):
+    def _update_rts_state(self):
         """Set terminal status line: Request To Send."""
         if not self._isOpen: raise portNotOpenError
         if self.logger:
-            self.logger.info('set RTS to %s' % ('active' if level else 'inactive'))
-        if level:
+            self.logger.info('set RTS to %s' % ('active' if self._rts_state else 'inactive'))
+        if self._rts_state:
             self.rfc2217SetControl(SET_CONTROL_RTS_ON)
         else:
             self.rfc2217SetControl(SET_CONTROL_RTS_OFF)
 
-    def setDTR(self, level=True):
+    def _update_dtr_state(self, level=True):
         """Set terminal status line: Data Terminal Ready."""
         if not self._isOpen: raise portNotOpenError
         if self.logger:
-            self.logger.info('set DTR to %s' % ('active' if level else 'inactive'))
-        if level:
+            self.logger.info('set DTR to %s' % ('active' if self._dtr_state else 'inactive'))
+        if self._dtr_state:
             self.rfc2217SetControl(SET_CONTROL_DTR_ON)
         else:
             self.rfc2217SetControl(SET_CONTROL_DTR_OFF)
 
-    def getCTS(self):
+    @property
+    def cts(self):
         """Read terminal status line: Clear To Send."""
         if not self._isOpen: raise portNotOpenError
         return bool(self.getModemState() & MODEMSTATE_MASK_CTS)
 
-    def getDSR(self):
+    @property
+    def dsr(self):
         """Read terminal status line: Data Set Ready."""
         if not self._isOpen: raise portNotOpenError
         return bool(self.getModemState() & MODEMSTATE_MASK_DSR)
 
-    def getRI(self):
+    @property
+    def ri(self):
         """Read terminal status line: Ring Indicator."""
         if not self._isOpen: raise portNotOpenError
         return bool(self.getModemState() & MODEMSTATE_MASK_RI)
 
-    def getCD(self):
+    @property
+    def cd(self):
         """Read terminal status line: Carrier Detect."""
         if not self._isOpen: raise portNotOpenError
         return bool(self.getModemState() & MODEMSTATE_MASK_CD)
diff --git a/serial/serialposix.py b/serial/serialposix.py
index 4db261b..62c0b58 100644
--- a/serial/serialposix.py
+++ b/serial/serialposix.py
@@ -307,7 +307,11 @@
             raise
         else:
             self._isOpen = True
-        self.flushInput()
+        if not self.dsrdtr:
+            self._update_dtr_state()
+        if not self.rtscts:
+            self._update_rts_state()
+        self.reset_input_buffer()
 
 
     def _reconfigurePort(self):
@@ -453,7 +457,8 @@
 
     #  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -
 
-    def inWaiting(self):
+    @property
+    def in_waiting(self):
         """Return the number of characters currently in the input buffer."""
         #~ s = fcntl.ioctl(self.fd, termios.FIONREAD, TIOCM_zero_str)
         s = fcntl.ioctl(self.fd, TIOCINQ, TIOCM_zero_str)
@@ -541,12 +546,12 @@
         """
         self.drainOutput()
 
-    def flushInput(self):
+    def reset_input_buffer(self):
         """Clear input buffer, discarding all that is in the buffer."""
         if not self._isOpen: raise portNotOpenError
         termios.tcflush(self.fd, termios.TCIFLUSH)
 
-    def flushOutput(self):
+    def reset_output_buffer(self):
         """\
         Clear output buffer, aborting the current output and discarding all
         that is in the buffer.
@@ -554,7 +559,7 @@
         if not self._isOpen: raise portNotOpenError
         termios.tcflush(self.fd, termios.TCOFLUSH)
 
-    def sendBreak(self, duration=0.25):
+    def send_break(self, duration=0.25):
         """\
         Send break condition. Timed, returns to idle state after given
         duration.
@@ -562,51 +567,52 @@
         if not self._isOpen: raise portNotOpenError
         termios.tcsendbreak(self.fd, int(duration/0.25))
 
-    def setBreak(self, level=1):
+    def _update_break_state(self):
         """\
         Set break: Controls TXD. When active, no transmitting is possible.
         """
-        if self.fd is None: raise portNotOpenError
-        if level:
+        if self._break_state:
             fcntl.ioctl(self.fd, TIOCSBRK)
         else:
             fcntl.ioctl(self.fd, TIOCCBRK)
 
-    def setRTS(self, level=1):
+    def _update_rts_state(self):
         """Set terminal status line: Request To Send"""
-        if not self._isOpen: raise portNotOpenError
-        if level:
+        if self._rts_state:
             fcntl.ioctl(self.fd, TIOCMBIS, TIOCM_RTS_str)
         else:
             fcntl.ioctl(self.fd, TIOCMBIC, TIOCM_RTS_str)
 
-    def setDTR(self, level=1):
+    def _update_dtr_state(self):
         """Set terminal status line: Data Terminal Ready"""
-        if not self._isOpen: raise portNotOpenError
-        if level:
+        if self._dtr_state:
             fcntl.ioctl(self.fd, TIOCMBIS, TIOCM_DTR_str)
         else:
             fcntl.ioctl(self.fd, TIOCMBIC, TIOCM_DTR_str)
 
-    def getCTS(self):
+    @property
+    def cts(self):
         """Read terminal status line: Clear To Send"""
         if not self._isOpen: raise portNotOpenError
         s = fcntl.ioctl(self.fd, TIOCMGET, TIOCM_zero_str)
         return struct.unpack('I',s)[0] & TIOCM_CTS != 0
 
-    def getDSR(self):
+    @property
+    def dsr(self):
         """Read terminal status line: Data Set Ready"""
         if not self._isOpen: raise portNotOpenError
         s = fcntl.ioctl(self.fd, TIOCMGET, TIOCM_zero_str)
         return struct.unpack('I',s)[0] & TIOCM_DSR != 0
 
-    def getRI(self):
+    @property
+    def ri(self):
         """Read terminal status line: Ring Indicator"""
         if not self._isOpen: raise portNotOpenError
         s = fcntl.ioctl(self.fd, TIOCMGET, TIOCM_zero_str)
         return struct.unpack('I',s)[0] & TIOCM_RI != 0
 
-    def getCD(self):
+    @property
+    def cd(self):
         """Read terminal status line: Carrier Detect"""
         if not self._isOpen: raise portNotOpenError
         s = fcntl.ioctl(self.fd, TIOCMGET, TIOCM_zero_str)
diff --git a/serial/serialutil.py b/serial/serialutil.py
index 9bd223f..87733b7 100644
--- a/serial/serialutil.py
+++ b/serial/serialutil.py
@@ -140,6 +140,9 @@
         self._dsrdtr   = None           # correct value is assigned below through properties
         self._interCharTimeout = None   # correct value is assigned below through properties
         self._rs485_mode = None         # disabled by default
+        self._rts_state = True
+        self._dtr_state = True
+        self._break_state = False
 
         # assign values using get/set methods using the properties feature
         self.port     = port
@@ -435,6 +438,78 @@
         self.close()
 
     #  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -
+
+    def send_break(self, duration=0.25):
+        """\
+        Send break condition. Timed, returns to idle state after given
+        duration.
+        """
+        if not self._isOpen: raise portNotOpenError
+        self.break_condition = True
+        time.sleep(duration)
+        self.break_condition = False
+
+    #  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -
+    # backwards compatibility / deprecated functions
+
+    def flushInput(self):
+        self.reset_input_buffer()
+
+    def flushOutput(self):
+        self.reset_output_buffer()
+
+    def inWaiting(self):
+        return self.in_waiting
+
+    def sendBreak(self, duration=0.25):
+        self.send_break(duration)
+
+    def setRTS(self, value=1):
+        self.rts = value
+
+    def setDTR(self, value=1):
+        self.dtr = value
+
+    def getCTS(self):
+        return self.cts
+
+    def getDSR(self):
+        return self.dsr
+
+    def getRI(self):
+        return self.ri
+
+    def getCD(self):
+        return self.cd
+
+    @property
+    def rts(self):
+        return self._rts_state
+    @rts.setter
+    def rts(self, value):
+        self._rts_state = value
+        if self._isOpen:
+            self._update_rts_state()
+
+    @property
+    def dtr(self):
+        return self._dtr_state
+    @dtr.setter
+    def dtr(self, value):
+        self._dtr_state = value
+        if self._isOpen:
+            self._update_dtr_state()
+
+    @property
+    def break_condition(self):
+        return self._break_state
+    @break_condition.setter
+    def break_condition(self, value):
+        self._break_state = value
+        if self._isOpen:
+            self._update_break_state()
+
+    #  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -
     # additional functionality
 
     def read_until(self, terminator=LF, size=None):
diff --git a/serial/serialwin32.py b/serial/serialwin32.py
index e8df919..59a3388 100644
--- a/serial/serialwin32.py
+++ b/serial/serialwin32.py
@@ -32,10 +32,6 @@
         self.hComPort = None
         self._overlappedRead = None
         self._overlappedWrite = None
-        self._rtsState = win32.RTS_CONTROL_ENABLE
-        self._dtrState = win32.DTR_CONTROL_ENABLE
-
-
         SerialBase.__init__(self, *args, **kwargs)
 
     def open(self):
@@ -50,7 +46,7 @@
         # the "\\.\COMx" format is required for devices other than COM1-COM8
         # not all versions of windows seem to support this properly
         # so that the first few ports are used with the DOS device name
-        port = self.portstr
+        port = self.name
         try:
             if port.upper().startswith('COM') and int(port[3:]) > 8:
                 port = '\\\\.\\' + port
@@ -181,7 +177,7 @@
             if self._rtscts:
                 comDCB.fRtsControl = win32.RTS_CONTROL_HANDSHAKE
             else:
-                comDCB.fRtsControl = self._rtsState
+                comDCB.fRtsControl = win32.RTS_CONTROL_ENABLE if self._rts_state else win32.RTS_CONTROL_DISABLE
             comDCB.fOutxCtsFlow = self._rtscts
         else:
             # checks for unsupported settings
@@ -212,7 +208,7 @@
         if self._dsrdtr:
             comDCB.fDtrControl  = win32.DTR_CONTROL_HANDSHAKE
         else:
-            comDCB.fDtrControl  = self._dtrState
+            comDCB.fDtrControl  = win32.DTR_CONTROL_ENABLE if self._dtr_state else win32.DTR_CONTROL_DISABLE
         comDCB.fOutxDsrFlow     = self._dsrdtr
         comDCB.fOutX            = self._xonxoff
         comDCB.fInX             = self._xonxoff
@@ -255,7 +251,8 @@
 
     #  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -
 
-    def inWaiting(self):
+    @property
+    def in_waiting(self):
         """Return the number of characters currently in the input buffer."""
         flags = win32.DWORD()
         comstat = win32.COMSTAT()
@@ -333,12 +330,12 @@
         # require overlapped IO and its also only possible to set a single mask
         # on the port---
 
-    def flushInput(self):
+    def reset_input_buffer(self):
         """Clear input buffer, discarding all that is in the buffer."""
         if not self.hComPort: raise portNotOpenError
         win32.PurgeComm(self.hComPort, win32.PURGE_RXCLEAR | win32.PURGE_RXABORT)
 
-    def flushOutput(self):
+    def reset_output_buffer(self):
         """\
         Clear output buffer, aborting the current output and discarding all
         that is in the buffer.
@@ -346,74 +343,52 @@
         if not self.hComPort: raise portNotOpenError
         win32.PurgeComm(self.hComPort, win32.PURGE_TXCLEAR | win32.PURGE_TXABORT)
 
-    def sendBreak(self, duration=0.25):
-        """\
-        Send break condition. Timed, returns to idle state after given duration.
-        """
-        if not self.hComPort: raise portNotOpenError
-        win32.SetCommBreak(self.hComPort)
-        time.sleep(duration)
-        win32.ClearCommBreak(self.hComPort)
-
-    def setBreak(self, level=1):
+    def _update_break_state(self):
         """Set break: Controls TXD. When active, to transmitting is possible."""
         if not self.hComPort: raise portNotOpenError
-        if level:
+        if self._break_state:
             win32.SetCommBreak(self.hComPort)
         else:
             win32.ClearCommBreak(self.hComPort)
 
-    def setRTS(self, level=1):
+    def _update_rts_state(self):
         """Set terminal status line: Request To Send"""
-        # remember level for reconfigure
-        if level:
-            self._rtsState = win32.RTS_CONTROL_ENABLE
+        if self._rts_state:
+            win32.EscapeCommFunction(self.hComPort, win32.SETRTS)
         else:
-            self._rtsState = win32.RTS_CONTROL_DISABLE
-        # also apply now if port is open
-        if self.hComPort:
-            if level:
-                win32.EscapeCommFunction(self.hComPort, win32.SETRTS)
-            else:
-                win32.EscapeCommFunction(self.hComPort, win32.CLRRTS)
+            win32.EscapeCommFunction(self.hComPort, win32.CLRRTS)
 
-    def setDTR(self, level=1):
+    def _update_dtr_state(self):
         """Set terminal status line: Data Terminal Ready"""
-        # remember level for reconfigure
-        if level:
-            self._dtrState = win32.DTR_CONTROL_ENABLE
+        if self._dtr_state:
+            win32.EscapeCommFunction(self.hComPort, win32.SETDTR)
         else:
-            self._dtrState = win32.DTR_CONTROL_DISABLE
-        # also apply now if port is open
-        if self.hComPort:
-            if level:
-                win32.EscapeCommFunction(self.hComPort, win32.SETDTR)
-            else:
-                win32.EscapeCommFunction(self.hComPort, win32.CLRDTR)
+            win32.EscapeCommFunction(self.hComPort, win32.CLRDTR)
 
     def _GetCommModemStatus(self):
+        if not self.hComPort: raise portNotOpenError
         stat = win32.DWORD()
         win32.GetCommModemStatus(self.hComPort, ctypes.byref(stat))
         return stat.value
 
-    def getCTS(self):
+    @property
+    def cts(self):
         """Read terminal status line: Clear To Send"""
-        if not self.hComPort: raise portNotOpenError
         return win32.MS_CTS_ON & self._GetCommModemStatus() != 0
 
-    def getDSR(self):
+    @property
+    def dsr(self):
         """Read terminal status line: Data Set Ready"""
-        if not self.hComPort: raise portNotOpenError
         return win32.MS_DSR_ON & self._GetCommModemStatus() != 0
 
-    def getRI(self):
+    @property
+    def ri(self):
         """Read terminal status line: Ring Indicator"""
-        if not self.hComPort: raise portNotOpenError
         return win32.MS_RING_ON & self._GetCommModemStatus() != 0
 
-    def getCD(self):
+    @property
+    def cd(self):
         """Read terminal status line: Carrier Detect"""
-        if not self.hComPort: raise portNotOpenError
         return win32.MS_RLSD_ON & self._GetCommModemStatus() != 0
 
     # - - platform specific - - - -
diff --git a/serial/urlhandler/protocol_loop.py b/serial/urlhandler/protocol_loop.py
index 10dedeb..a3bfbc9 100644
--- a/serial/urlhandler/protocol_loop.py
+++ b/serial/urlhandler/protocol_loop.py
@@ -58,8 +58,6 @@
             raise SerialException("Port is already open.")
         self.logger = None
         self.queue = queue.Queue(self.buffer_size)
-        self.cts = False
-        self.dsr = False
 
         if self._port is None:
             raise SerialException("Port must be configured before it can be used.")
@@ -71,11 +69,12 @@
         self._reconfigurePort()
         # all things set up get, now a clean start
         self._isOpen = True
+        if not self.dsrdtr:
+            self._update_dtr_state()
         if not self._rtscts:
-            self.setRTS(True)
-            self.setDTR(True)
-        self.flushInput()
-        self.flushOutput()
+            self._update_rts_state()
+        self.reset_input_buffer()
+        self.reset_output_buffer()
 
     def close(self):
         self.queue.put(None)
@@ -119,7 +118,8 @@
 
     #  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -
 
-    def inWaiting(self):
+    @property
+    def in_waiting(self):
         """Return the number of characters currently in the input buffer."""
         if not self._isOpen: raise portNotOpenError
         if self.logger:
@@ -172,7 +172,7 @@
             self.queue.put(byte, timeout=self._writeTimeout)
         return len(data)
 
-    def flushInput(self):
+    def reset_input_buffer(self):
         """Clear input buffer, discarding all that is in the buffer."""
         if not self._isOpen: raise portNotOpenError
         if self.logger:
@@ -183,7 +183,7 @@
         except queue.Empty:
             pass
 
-    def flushOutput(self):
+    def reset_output_buffer(self):
         """\
         Clear output buffer, aborting the current output and
         discarding all that is in the buffer.
@@ -197,59 +197,49 @@
         except queue.Empty:
             pass
 
-    def sendBreak(self, duration=0.25):
-        """\
-        Send break condition. Timed, returns to idle state after given
-        duration.
-        """
-        if not self._isOpen: raise portNotOpenError
-        time.sleep(duration)
-
-    def setBreak(self, level=True):
+    def _update_break_state(self):
         """\
         Set break: Controls TXD. When active, to transmitting is
         possible.
         """
-        if not self._isOpen: raise portNotOpenError
         if self.logger:
-            self.logger.info('setBreak(%r)' % (level,))
+            self.logger.info('setBreak(%r)' % (self._break_state,))
 
-    def setRTS(self, level=True):
+    def _update_rts_state(self):
         """Set terminal status line: Request To Send"""
-        if not self._isOpen: raise portNotOpenError
         if self.logger:
-            self.logger.info('setRTS(%r) -> state of CTS' % (level,))
-        self.cts = level
+            self.logger.info('setRTS(%r) -> state of CTS' % (self._rts_state,))
 
-    def setDTR(self, level=True):
+    def _update_dtr_state(self):
         """Set terminal status line: Data Terminal Ready"""
-        if not self._isOpen: raise portNotOpenError
         if self.logger:
-            self.logger.info('setDTR(%r) -> state of DSR' % (level,))
-        self.dsr = level
+            self.logger.info('setDTR(%r) -> state of DSR' % (self._dtr_state,))
 
-    def getCTS(self):
+    @property
+    def cts(self):
         """Read terminal status line: Clear To Send"""
         if not self._isOpen: raise portNotOpenError
         if self.logger:
-            self.logger.info('getCTS() -> state of RTS (%r)' % (self.cts,))
-        return self.cts
+            self.logger.info('getCTS() -> state of RTS (%r)' % (self._rts_state,))
+        return self._rts_state
 
-    def getDSR(self):
+    @property
+    def dsr(self):
         """Read terminal status line: Data Set Ready"""
-        if not self._isOpen: raise portNotOpenError
         if self.logger:
-            self.logger.info('getDSR() -> state of DTR (%r)' % (self.dsr,))
-        return self.dsr
+            self.logger.info('getDSR() -> state of DTR (%r)' % (self._dtr_state,))
+        return self._dtr_state
 
-    def getRI(self):
+    @property
+    def ri(self):
         """Read terminal status line: Ring Indicator"""
         if not self._isOpen: raise portNotOpenError
         if self.logger:
             self.logger.info('returning dummy for getRI()')
         return False
 
-    def getCD(self):
+    @property
+    def cd(self):
         """Read terminal status line: Carrier Detect"""
         if not self._isOpen: raise portNotOpenError
         if self.logger:
diff --git a/serial/urlhandler/protocol_socket.py b/serial/urlhandler/protocol_socket.py
index 3dedb48..c0e3dfb 100644
--- a/serial/urlhandler/protocol_socket.py
+++ b/serial/urlhandler/protocol_socket.py
@@ -67,11 +67,12 @@
         self._reconfigurePort()
         # all things set up get, now a clean start
         self._isOpen = True
+        if not self.dsrdtr:
+            self._update_dtr_state()
         if not self._rtscts:
-            self.setRTS(True)
-            self.setDTR(True)
-        self.flushInput()
-        self.flushOutput()
+            self._update_rts_state()
+        self.reset_input_buffer()
+        self.reset_output_buffer()
 
     def _reconfigurePort(self):
         """\
@@ -125,7 +126,8 @@
 
     #  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -
 
-    def inWaiting(self):
+    @property
+    def in_waiting(self):
         """Return the number of characters currently in the input buffer."""
         if not self._isOpen: raise portNotOpenError
         # Poll the socket to see if it is ready for reading.
@@ -180,75 +182,76 @@
             raise SerialException("socket connection failed: %s" % e)
         return len(data)
 
-    def flushInput(self):
+    def reset_input_buffer(self):
         """Clear input buffer, discarding all that is in the buffer."""
         if not self._isOpen: raise portNotOpenError
         if self.logger:
-            self.logger.info('ignored flushInput')
+            self.logger.info('ignored reset_input_buffer')
 
-    def flushOutput(self):
+    def reset_output_buffer(self):
         """\
         Clear output buffer, aborting the current output and
         discarding all that is in the buffer.
         """
         if not self._isOpen: raise portNotOpenError
         if self.logger:
-            self.logger.info('ignored flushOutput')
+            self.logger.info('ignored reset_output_buffer')
 
-    def sendBreak(self, duration=0.25):
+    def send_break(self, duration=0.25):
         """\
         Send break condition. Timed, returns to idle state after given
         duration.
         """
         if not self._isOpen: raise portNotOpenError
         if self.logger:
-            self.logger.info('ignored sendBreak(%r)' % (duration,))
+            self.logger.info('ignored send_break(%r)' % (duration,))
 
-    def setBreak(self, level=True):
+    def _update_break_state(self):
         """Set break: Controls TXD. When active, to transmitting is
         possible."""
-        if not self._isOpen: raise portNotOpenError
         if self.logger:
-            self.logger.info('ignored setBreak(%r)' % (level,))
+            self.logger.info('ignored _update_break_state(%r)' % (self._break_state,))
 
-    def setRTS(self, level=True):
+    def _update_rts_state(self):
         """Set terminal status line: Request To Send"""
-        if not self._isOpen: raise portNotOpenError
         if self.logger:
-            self.logger.info('ignored setRTS(%r)' % (level,))
+            self.logger.info('ignored _update_rts_state(%r)' % (self._rts_state,))
 
-    def setDTR(self, level=True):
+    def _update_dtr_state(self):
         """Set terminal status line: Data Terminal Ready"""
-        if not self._isOpen: raise portNotOpenError
         if self.logger:
-            self.logger.info('ignored setDTR(%r)' % (level,))
+            self.logger.info('ignored _update_dtr_state(%r)' % (self._dtr_state,))
 
-    def getCTS(self):
+    @property
+    def cts(self):
         """Read terminal status line: Clear To Send"""
         if not self._isOpen: raise portNotOpenError
         if self.logger:
-            self.logger.info('returning dummy for getCTS()')
+            self.logger.info('returning dummy for cts')
         return True
 
-    def getDSR(self):
+    @property
+    def dsr(self):
         """Read terminal status line: Data Set Ready"""
         if not self._isOpen: raise portNotOpenError
         if self.logger:
-            self.logger.info('returning dummy for getDSR()')
+            self.logger.info('returning dummy for dsr')
         return True
 
-    def getRI(self):
+    @property
+    def ri(self):
         """Read terminal status line: Ring Indicator"""
         if not self._isOpen: raise portNotOpenError
         if self.logger:
-            self.logger.info('returning dummy for getRI()')
+            self.logger.info('returning dummy for ri')
         return False
 
-    def getCD(self):
+    @property
+    def cd(self):
         """Read terminal status line: Carrier Detect"""
         if not self._isOpen: raise portNotOpenError
         if self.logger:
-            self.logger.info('returning dummy for getCD()')
+            self.logger.info('returning dummy for cd)')
         return True
 
     # - - - platform specific - - -
diff --git a/serial/urlhandler/protocol_spy.py b/serial/urlhandler/protocol_spy.py
index a1993e7..f52b7fe 100644
--- a/serial/urlhandler/protocol_spy.py
+++ b/serial/urlhandler/protocol_spy.py
@@ -196,58 +196,65 @@
             self.formatter.rx(rx)
         return rx
 
-
-    def inWaiting(self):
-        n = super(Serial, self).inWaiting()
+    @property
+    def in_waiting(self):
+        n = super(Serial, self).in_waiting
         if self.show_all:
-            self.formatter.control('Q-RX', 'inWaiting -> {}'.format(n))
+            self.formatter.control('Q-RX', 'in_waiting -> {}'.format(n))
         return n
 
     def flush(self):
         self.formatter.control('Q-TX', 'flush')
         super(Serial, self).flush()
 
-    def flushInput(self):
-        self.formatter.control('Q-RX', 'flushInput')
-        super(Serial, self).flushInput()
+    def reset_input_buffer(self):
+        self.formatter.control('Q-RX', 'reset_input_buffer')
+        super(Serial, self).reset_input_buffer()
 
-    def flushOutput(self):
-        self.formatter.control('Q-TX', 'flushOutput')
-        super(Serial, self).flushOutput()
+    def reset_output_buffer(self):
+        self.formatter.control('Q-TX', 'reset_output_buffer')
+        super(Serial, self).reset_output_buffer()
 
-    def sendBreak(self, duration=0.25):
-        self.formatter.control('BRK', 'sendBreak {}s'.format(duration))
-        super(Serial, self).sendBreak(duration)
+    def send_break(self, duration=0.25):
+        self.formatter.control('BRK', 'send_break {}s'.format(duration))
+        super(Serial, self).send_break(duration)
 
-    def setBreak(self, level=1):
+    @serial.Serial.break_condition.setter
+    def break_condition(self, level):
         self.formatter.control('BRK', 'active' if level else 'inactive')
-        super(Serial, self).setBreak(level)
+        serial.Serial.break_condition.__set__(self, level)
 
-    def setRTS(self, level=1):
+    @serial.Serial.rts.setter
+    def rts(self, level):
         self.formatter.control('RTS', 'active' if level else 'inactive')
-        super(Serial, self).setRTS(level)
+        serial.Serial.rts.__set__(self, level)
 
-    def setDTR(self, level=1):
+    @serial.Serial.dtr.setter
+    def dtr(self, level):
         self.formatter.control('DTR', 'active' if level else 'inactive')
-        super(Serial, self).setDTR(level)
+        serial.Serial.dtr.__set__(self, level)
 
-    def getCTS(self):
-        level = super(Serial, self).getCTS()
+    @serial.Serial.cts.getter
+    def cts(self):
+        level = super(Serial, self).cts
         self.formatter.control('CTS', 'active' if level else 'inactive')
         return level
 
-    def getDSR(self):
-        level = super(Serial, self).getDSR()
+    @serial.Serial.dsr.getter
+    def dsr(self):
+        level = super(Serial, self).dsr
         self.formatter.control('DSR', 'active' if level else 'inactive')
         return level
 
-    def getRI(self):
-        level = super(Serial, self).getRI()
+    @serial.Serial.ri.getter
+    def ri(self):
+        level = super(Serial, self).ri
         self.formatter.control('RI', 'active' if level else 'inactive')
         return level
 
-    def getCD(self):
-        level = super(Serial, self).getCD()
+    @serial.Serial.cd.getter
+    def cd(self):
+        level = super(Serial, self).cd
         self.formatter.control('CD', 'active' if level else 'inactive')
         return level