serialport 0.7.4

data/CHANGELOG

@@ -0,0 +1,29 @@
+0.7.4 => 10/12/2009:	Conditional 1.8.6 & 1.9 support (POSIX only). MinGW support.
+
+0.7.3 => 10/09/2009:    http://makrotopia.org/browser/makrosys/makrobe/ruby-serialport/patches/10-fix-for-ruby-1.9 
+                        applied for 1.9 support (POSIX only)
+
+0.7.2 => 02/09/2008:    Fix several Windows and POSIX compilation problems.
+                        Make GCC compile the code without any warnings.
+                        Make RDoc not be so talkative during gem installation.
+
+0.7.1 => 31/08/2008:    Change to gemspec creation and fix posix compilation.
+
+0.7.0 => 03/07/2008:    Major Code Cleanup
+
+0.6.1 => 25/03/2003:    Minor changes
+
+0.6 => 12/02/2003:      Windows support
+                        Get/set modem parameters
+                        Read and write timeouts
+                        Open method
+
+0.5 => 25/10/2002:      Cygwin support
+
+0.4 => 19/09/2002:      Added more serial ports (total of 8 ports)
+
+0.3 => 15/03/2002:      Damn, another bug found
+
+0.2 => 14/03/2002:      A bug fixed (read() was not blocking)
+
+0.1 => 14/03/2002:      First release

data/MANIFEST

@@ -0,0 +1,11 @@
+CHANGELOG
+README
+MANIFEST
+serialport.gemspec
+extconf.rb
+lib/serialport.rb
+src/posix_serialport_impl.c
+src/serialport.c
+src/serialport.h
+src/win_serialport_impl.c
+test/miniterm.rb

data/README

@@ -0,0 +1,156 @@
+-----Ruby/SerialPort-----
+
+-- Description --
+
+Ruby/SerialPort is a Ruby library that provides a class for using
+RS-232 serial ports.  This class also contains low-level functions to
+check and set the current state of the signals on the line.
+
+The native Windows version of this library supports Microsoft's Visual C++, Borland's C++, and MinGW compilers.
+
+-- Installation --
+
+This gem is hosted at Gemcutter. Before you can install this, or any other Gemcutter gem you must
+add it as a gem source:
+  gem sources -a http://gemcutter.org
+
+Then you can install the gem as normal:
+  sudo gem install serialport
+
+-- Testing --
+
+* test/miniterm.rb
+
+Ruby's copy of miniterm.c !
+
+
+-- API --
+
+  **** Class SerialPort, Parent IO ****
+
+    ** Class constants **
+
+       VERSION -> aString (this release is "0.6")
+       NONE, HARD, SOFT, SPACE, MARK, EVEN, ODD -> anInteger
+
+    ** Class methods **
+
+      * new(port_num [, modem_parameters]) -> aSerialPort
+      * open(port_num [, modem_parameters]) -> aSerialPort
+      * open(port_num [, modem_parameters]) {|aSerialPort| block} ->
+                value of the block
+
+        port_num -> anInteger: port number, 0 for first port which is
+                      "/dev/ttyS0" on GNU/Linux and "COM1" on Windows,
+                or  aString: file name of the device (example: "/dev/ttyS2")
+
+        Optional modem_parameters:
+
+        baudrate -> anInteger: from 50 to 256000, depends on platform.
+
+        databits -> anInteger: from 5 to 8 (4 is allowed on Windows)
+
+        stopbits -> anInteger: 1 or 2 (1.5 is not supported)
+
+        parity -> anInteger: SerialPort::NONE, SerialPort::EVEN,
+                  SerialPort::ODD, SerialPort::MARK, SerialPort::SPACE
+                  (MARK and SPACE are not supported on Posix)
+
+        Raise an argError on bad argument.
+
+        SerialPort::new and SerialPort::open without a block return an
+        instance of SerialPort.  SerialPort::open with a block passes
+        a SerialPort to the block and closes it when the block exits
+        (like File::open).
+
+
+    ** Instance methods **
+
+      * modem_params() -> aHash
+      * modem_params=(aHash) -> aHash
+      * get_modem_params() -> aHash
+      * set_modem_params(aHash) -> aHash
+      * set_modem_params(baudrate [, databits [, stopbits [, parity]]])
+
+        Get and set the modem parameters.  Hash keys are "baud", "data_bits",
+        "stop_bits", and "parity" (see above).
+
+        Parameters not present in the hash or set to nil remain unchanged.
+        Default parameter values for the set_modem_params method are:
+        databits = 8, stopbits = 1, parity = (databits == 8 ?
+        SerialPort::NONE : SerialPort::EVEN).
+
+      * baud() -> anInteger
+      * baud=(anInteger) -> anInteger
+      * data_bits() -> 4, 5, 6, 7, or 8
+      * data_bits=(anInteger) -> anInteger
+      * stop_bits() -> 1 or 2
+      * stop_bits=(anInteger) -> anInteger
+      * parity() -> anInteger: SerialPort::NONE, SerialPort::EVEN,
+          SerialPort::ODD, SerialPort::MARK, or SerialPort::SPACE
+      * parity=(anInteger) -> anInteger
+
+        Get and set the corresponding modem parameter.
+
+      * flow_control() -> anInteger
+      * flow_control=(anInteger) -> anInteger
+
+        Get and set the flow control: SerialPort::NONE, SerialPort::HARD,
+        SerialPort::SOFT, or (SerialPort::HARD | SerialPort::SOFT).
+
+        Note: SerialPort::HARD mode is not supported on all platforms.
+        SerialPort::HARD uses RTS/CTS handshaking; DSR/DTR is not
+        supported.
+
+      * read_timeout() -> anInteger
+      * read_timeout=(anInteger) -> anInteger
+      * write_timeout() -> anInteger
+      * write_timeout=(anInteger) -> anInteger
+
+        Get and set timeout values (in milliseconds) for reading and writing.
+        A negative read timeout will return all the available data without
+        waiting, a zero read timeout will not return until at least one
+        byte is available, and a positive read timeout returns when the
+        requested number of bytes is available or the interval between the
+        arrival of two bytes exceeds the timeout value.
+
+        Note: Read timeouts don't mix well with multi-threading.
+
+        Note: Under Posix, write timeouts are not implemented.
+
+      * break(time) -> nil
+
+        Send a break for the given time.  
+
+        time -> anInteger: tenths-of-a-second for the break.
+        Note: Under Posix, this value is very approximate.
+
+      * signals() -> aHash
+
+        Return a hash with the state of each line status bit.  Keys are
+        "rts", "dtr", "cts", "dsr", "dcd", and "ri".
+
+        Note: Under Windows, the rts and dtr values are not included.
+
+      * rts()
+      * dtr()
+      * cts()
+      * dsr()
+      * dcd()
+      * ri() -> 0 or 1
+
+      * rts=(0 or 1)
+      * dtr=(0 or 1) -> 0 or 1
+
+        Get and set the corresponding line status bit.
+
+        Note: Under Windows, rts() and dtr() are not implemented.
+
+-- License --
+
+GPL
+
+Guillaume Pierronnet <moumar@netcourrier.com>
+Alan Stern <stern@rowland.harvard.edu>
+Tobin Richard <tobin.richard@gmail.com>
+Hector Parra <hector@hectorparra.com>

data/Rakefile

@@ -0,0 +1,19 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "serialport"
+    gemspec.summary = "Library for using RS-232 serial ports."
+    gemspec.description = "Ruby/SerialPort is a Ruby library that provides a class for using RS-232 serial ports."
+    gemspec.email = "hector@hectorparra.com"
+    gemspec.homepage = 'http://github.com/hparra/ruby-serialport/'
+    gemspec.authors = ['Guillaume Pierronnet', 'Alan Stern', 'Daniel E. Shipton', 'Tobin Richard']
+    gemspec.has_rdoc = false
+    gemspec.extensions << 'extconf.rb'
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install jeweler -s http://gemcutter.org"
+end

data/VERSION

@@ -0,0 +1 @@
+0.7.4

data/extconf.rb

@@ -0,0 +1,13 @@
+require 'mkmf'
+
+printf("checking for OS... ")
+STDOUT.flush
+os = /-([a-z]+)/.match(RUBY_PLATFORM)[1]
+puts(os)
+$CFLAGS += " -DOS_#{os.upcase}"
+
+if !(os == 'mswin' or os == 'bccwin' or os == 'mingw')
+  exit(1) if not have_header("termios.h") or not have_header("unistd.h")
+end
+
+create_makefile('serialport','src')

data/lib/serialport.rb

@@ -0,0 +1,32 @@
+require "serialport.so"
+
+class SerialPort
+   private_class_method(:create)
+
+   def SerialPort::new(port, *params)
+      sp = create(port)
+      begin
+         sp.set_modem_params(*params)
+      rescue
+         sp.close
+         raise
+      end
+      return sp
+   end
+
+   def SerialPort::open(port, *params)
+      sp = create(port)
+      begin
+         sp.set_modem_params(*params)
+         if (block_given?)
+            yield sp
+            sp.close
+            return nil
+         end
+      rescue
+         sp.close
+         raise
+      end
+      return sp
+   end
+end

data/serialport.gemspec

@@ -0,0 +1,52 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE
+# Instead, edit Jeweler::Tasks in Rakefile, and run `rake gemspec`
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{serialport}
+  s.version = "0.7.4"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Guillaume Pierronnet", "Alan Stern", "Daniel E. Shipton", "Tobin Richard"]
+  s.date = %q{2009-10-13}
+  s.description = %q{Ruby/SerialPort is a Ruby library that provides a class for using RS-232 serial ports.}
+  s.email = %q{hector@hectorparra.com}
+  s.extensions = ["extconf.rb"]
+  s.extra_rdoc_files = [
+    "README"
+  ]
+  s.files = [
+    "CHANGELOG",
+     "MANIFEST",
+     "README",
+     "Rakefile",
+     "VERSION",
+     "extconf.rb",
+     "lib/serialport.rb",
+     "serialport.gemspec",
+     "src/posix_serialport_impl.c",
+     "src/serialport.c",
+     "src/serialport.h",
+     "src/win_serialport_impl.c",
+     "test/miniterm.rb"
+  ]
+  s.homepage = %q{http://github.com/hparra/ruby-serialport/}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Library for using RS-232 serial ports.}
+  s.test_files = [
+    "test/miniterm.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/src/posix_serialport_impl.c

@@ -0,0 +1,687 @@
+/* Ruby/SerialPort $Id$
+ * Guillaume Pierronnet <moumar@netcourrier.com>
+ * Alan Stern <stern@rowland.harvard.edu>
+ * Daniel E. Shipton <dshipton@redshiptechnologies.com>
+ *
+ * This code is hereby licensed for public consumption under either the
+ * GNU GPL v2 or greater.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * For documentation on serial programming, see the excellent:
+ * "Serial Programming Guide for POSIX Operating Systems"
+ * written Michael R. Sweet.
+ * http://www.easysw.com/~mike/serial/
+ */
+
+#include "serialport.h"
+
+/* Check if we are on a posix compliant system. */
+#if !defined(OS_MSWIN) && !defined(OS_BCCWIN) && !defined(OS_MINGW)
+
+#include <stdio.h>   /* Standard input/output definitions */
+#include <unistd.h>  /* UNIX standard function definitions */
+#include <fcntl.h>   /* File control definitions */
+#include <errno.h>   /* Error number definitions */
+#include <termios.h> /* POSIX terminal control definitions */
+#include <sys/ioctl.h>
+
+#ifdef CRTSCTS
+#define HAVE_FLOWCONTROL_HARD 1
+#else
+#undef HAVE_FLOWCONTROL_HARD
+#endif
+
+
+static char sTcgetattr[] = "tcgetattr";
+static char sTcsetattr[] = "tcsetattr";
+static char sIoctl[] = "ioctl";
+
+
+int get_fd_helper(obj)
+   VALUE obj;
+{
+#if RUBY_VERSION >= '1.9.0'
+	rb_io_t *fptr;
+#else
+	OpenFile *fptr;
+#endif
+   GetOpenFile(obj, fptr);
+#if RUBY_VERSION >= '1.9.0'
+	return (fptr->fd);
+#else
+	return (fileno(fptr->f));
+#endif
+}
+
+VALUE sp_create_impl(class, _port)
+   VALUE class, _port;
+{
+#if RUBY_VERSION >= '1.9.0'
+	rb_io_t *fp;
+#else
+	OpenFile *fp;
+#endif
+
+   int fd;
+   int num_port;
+   char *port;
+   char *ports[] = {
+#if defined(OS_LINUX) || defined(OS_CYGWIN)
+      "/dev/ttyS0", "/dev/ttyS1", "/dev/ttyS2", "/dev/ttyS3",
+      "/dev/ttyS4", "/dev/ttyS5", "/dev/ttyS6", "/dev/ttyS7"
+#elif defined(OS_FREEBSD) || defined(OS_NETBSD) || defined(OS_OPENBSD)
+         "/dev/cuaa0", "/dev/cuaa1", "/dev/cuaa2", "/dev/cuaa3",
+      "/dev/cuaa4", "/dev/cuaa5", "/dev/cuaa6", "/dev/cuaa7"
+#elif defined(OS_SOLARIS)
+         "/dev/ttya", "/dev/ttyb", "/dev/ttyc", "/dev/ttyd",
+      "/dev/ttye", "/dev/ttyf", "/dev/ttyg", "/dev/ttyh"
+#elif defined(OS_AIX)
+         "/dev/tty0", "/dev/tty1", "/dev/tty2", "/dev/tty3",
+      "/dev/tty4", "/dev/tty5", "/dev/tty6", "/dev/tty7"
+#elif defined(OS_IRIX)
+         "/dev/ttyf1", "/dev/ttyf2", "/dev/ttyf3", "/dev/ttyf4",
+      "/dev/ttyf5", "/dev/ttyf6", "/dev/ttyf7", "/dev/ttyf8"
+#endif
+   };
+   struct termios params;
+
+   NEWOBJ(sp, struct RFile);
+   rb_secure(4);
+   OBJSETUP(sp, class, T_FILE);
+   MakeOpenFile((VALUE) sp, fp);
+
+   switch(TYPE(_port))
+   {
+      case T_FIXNUM:
+         num_port = FIX2INT(_port);
+         if (num_port < 0 || num_port > sizeof(ports) / sizeof(ports[0]))
+         {
+            rb_raise(rb_eArgError, "illegal port number");
+         }
+         port = ports[num_port];
+         break;
+
+      case T_STRING:
+         Check_SafeStr(_port);
+#if RUBY_VERSION >= '1.9.0'
+			port = RSTRING_PTR(_port);
+#else
+			port = RSTRING(_port)->ptr;
+#endif
+         break;
+
+      default:
+         rb_raise(rb_eTypeError, "wrong argument type");
+         break;
+   }
+
+   fd = open(port, O_RDWR | O_NOCTTY | O_NDELAY);
+   if (fd == -1)
+   {
+      rb_sys_fail(port);
+   }
+
+   if (!isatty(fd))
+   {
+      close(fd);
+      rb_raise(rb_eArgError, "not a serial port");
+   }
+
+   /* enable blocking read */
+   fcntl(fd, F_SETFL, fcntl(fd, F_GETFL, 0) & ~O_NONBLOCK);
+
+   if (tcgetattr(fd, &params) == -1)
+   {
+      close(fd);
+      rb_sys_fail(sTcgetattr);
+   }
+
+   params.c_oflag = 0;
+   params.c_lflag = 0;
+   params.c_iflag &= (IXON | IXOFF | IXANY);
+   params.c_cflag |= CLOCAL | CREAD;
+   params.c_cflag &= ~HUPCL;
+
+   if (tcsetattr(fd, TCSANOW, &params) == -1)
+   {
+      close(fd);
+      rb_sys_fail(sTcsetattr);
+   }
+
+#if RUBY_VERSION >= '1.9.0'
+	fp->fd = fd;
+#else
+	fp->f = rb_fdopen(fd, "r+");
+#endif
+   fp->mode = FMODE_READWRITE | FMODE_SYNC;
+
+   return (VALUE) sp;
+}
+
+VALUE sp_set_modem_params_impl(argc, argv, self)
+   int argc;
+   VALUE *argv, self;
+{
+   int fd;
+   struct termios params;
+   VALUE _data_rate, _data_bits, _parity, _stop_bits;
+   int use_hash = 0;
+   int data_rate, data_bits;
+   _data_rate = _data_bits = _parity = _stop_bits = Qnil;
+
+   if (argc == 0)
+   {
+      return self;
+   }
+
+   if (argc == 1 && T_HASH == TYPE(argv[0]))
+   {
+      use_hash = 1;
+      _data_rate = rb_hash_aref(argv[0], sBaud);
+      _data_bits = rb_hash_aref(argv[0], sDataBits);
+      _stop_bits = rb_hash_aref(argv[0], sStopBits);
+      _parity = rb_hash_aref(argv[0], sParity);
+   }
+
+   fd = get_fd_helper(self);
+   if (tcgetattr(fd, &params) == -1)
+   {
+      rb_sys_fail(sTcgetattr);
+   }
+
+   if (!use_hash)
+   {
+      _data_rate = argv[0];
+   }
+
+   if (NIL_P(_data_rate))
+   {
+      goto SkipDataRate;
+   }
+   Check_Type(_data_rate, T_FIXNUM);
+
+   switch(FIX2INT(_data_rate))
+   {
+      case 50:    data_rate = B50; break;
+      case 75:    data_rate = B75; break;
+      case 110:   data_rate = B110; break;
+      case 134:   data_rate = B134; break;
+      case 150:   data_rate = B150; break;
+      case 200:   data_rate = B200; break;
+      case 300:   data_rate = B300; break;
+      case 600:   data_rate = B600; break;
+      case 1200:  data_rate = B1200; break;
+      case 1800:  data_rate = B1800; break;
+      case 2400:  data_rate = B2400; break;
+      case 4800:  data_rate = B4800; break;
+      case 9600:  data_rate = B9600; break;
+      case 19200: data_rate = B19200; break;
+      case 38400: data_rate = B38400; break;
+#ifdef B57600
+      case 57600: data_rate = B57600; break;
+#endif
+#ifdef B76800
+      case 76800: data_rate = B76800; break;
+#endif
+#ifdef B115200
+      case 115200: data_rate = B115200; break;
+#endif
+#ifdef B230400
+      case 230400: data_rate = B230400; break;
+#endif
+
+      default:
+                   rb_raise(rb_eArgError, "unknown baud rate");
+                   break;
+   }
+   cfsetispeed(&params, data_rate);
+   cfsetospeed(&params, data_rate);
+
+   SkipDataRate:
+
+   if (!use_hash)
+   {
+      _data_bits = (argc >= 2 ? argv[1] : INT2FIX(8));
+   }
+
+   if (NIL_P(_data_bits))
+   {
+      goto SkipDataBits;
+   }
+   Check_Type(_data_bits, T_FIXNUM);
+
+   switch(FIX2INT(_data_bits))
+   {
+      case 5:
+         data_bits = CS5;
+         break;
+      case 6:
+         data_bits = CS6;
+         break;
+      case 7:
+         data_bits = CS7;
+         break;
+      case 8:
+         data_bits = CS8;
+         break;
+      default:
+         rb_raise(rb_eArgError, "unknown character size");
+         break;
+   }
+   params.c_cflag &= ~CSIZE;
+   params.c_cflag |= data_bits;
+
+   SkipDataBits:
+
+   if (!use_hash)
+   {
+      _stop_bits = (argc >= 3 ? argv[2] : INT2FIX(1));
+   }
+
+   if (NIL_P(_stop_bits))
+   {
+      goto SkipStopBits;
+   }
+
+   Check_Type(_stop_bits, T_FIXNUM);
+
+   switch(FIX2INT(_stop_bits))
+   {
+      case 1:
+         params.c_cflag &= ~CSTOPB;
+         break;
+      case 2:
+         params.c_cflag |= CSTOPB;
+         break;
+      default:
+         rb_raise(rb_eArgError, "unknown number of stop bits");
+         break;
+   }
+
+   SkipStopBits:
+
+   if (!use_hash)
+   {
+      _parity = (argc >= 4 ? argv[3] : ((params.c_cflag & CSIZE) == CS8 ?
+               INT2FIX(NONE) : INT2FIX(EVEN)));
+   }
+
+   if (NIL_P(_parity))
+   {
+      goto SkipParity;
+   }
+
+   Check_Type(_parity, T_FIXNUM);
+
+   switch(FIX2INT(_parity))
+   {
+      case EVEN:
+         params.c_cflag |= PARENB;
+         params.c_cflag &= ~PARODD;
+         break;
+
+      case ODD:
+         params.c_cflag |= PARENB;
+         params.c_cflag |= PARODD;
+         break;
+
+      case NONE:
+         params.c_cflag &= ~PARENB;
+         break;
+
+      default:
+         rb_raise(rb_eArgError, "unknown parity");
+         break;
+   }
+
+   SkipParity:
+
+   if (tcsetattr(fd, TCSANOW, &params) == -1)
+   {
+      rb_sys_fail(sTcsetattr);
+   }
+   return argv[0];
+}
+
+void get_modem_params_impl(self, mp)
+   VALUE self;
+   struct modem_params *mp;
+{
+   int fd;
+   struct termios params;
+
+   fd = get_fd_helper(self);
+   if (tcgetattr(fd, &params) == -1)
+   {
+      rb_sys_fail(sTcgetattr);
+   }
+
+   switch (cfgetospeed(&params))
+   {
+      case B50:    mp->data_rate = 50; break;
+      case B75:    mp->data_rate = 75; break;
+      case B110:   mp->data_rate = 110; break;
+      case B134:   mp->data_rate = 134; break;
+      case B150:   mp->data_rate = 150; break;
+      case B200:   mp->data_rate = 200; break;
+      case B300:   mp->data_rate = 300; break;
+      case B600:   mp->data_rate = 600; break;
+      case B1200:  mp->data_rate = 1200; break;
+      case B1800:  mp->data_rate = 1800; break;
+      case B2400:  mp->data_rate = 2400; break;
+      case B4800:  mp->data_rate = 4800; break;
+      case B9600:  mp->data_rate = 9600; break;
+      case B19200: mp->data_rate = 19200; break;
+      case B38400: mp->data_rate = 38400; break;
+#ifdef B57600
+      case B57600: mp->data_rate = 57600; break;
+#endif
+#ifdef B76800
+      case B76800: mp->data_rate = 76800; break;
+#endif
+#ifdef B115200
+      case B115200: mp->data_rate = 115200; break;
+#endif
+#ifdef B230400
+      case B230400: mp->data_rate = 230400; break;
+#endif
+   }
+
+   switch(params.c_cflag & CSIZE)
+   {
+      case CS5:
+         mp->data_bits = 5;
+         break;
+      case CS6:
+         mp->data_bits = 6;
+         break;
+      case CS7:
+         mp->data_bits = 7;
+         break;
+      case CS8:
+         mp->data_bits = 8;
+         break;
+      default:
+         mp->data_bits = 0;
+         break;
+   }
+
+   mp->stop_bits = (params.c_cflag & CSTOPB ? 2 : 1);
+
+   if (!(params.c_cflag & PARENB))
+   {
+      mp->parity = NONE;
+   }
+   else if (params.c_cflag & PARODD)
+   {
+      mp->parity = ODD;
+   }
+   else
+   {
+      mp->parity = EVEN;
+   }
+}
+
+VALUE sp_set_flow_control_impl(self, val)
+   VALUE self, val;
+{
+   int fd;
+   int flowc;
+   struct termios params;
+
+   Check_Type(val, T_FIXNUM);
+
+   fd = get_fd_helper(self);
+   if (tcgetattr(fd, &params) == -1)
+   {
+      rb_sys_fail(sTcgetattr);
+   }
+
+   flowc = FIX2INT(val);
+   if (flowc & HARD)
+   {
+#ifdef HAVE_FLOWCONTROL_HARD
+      params.c_cflag |= CRTSCTS;
+   }
+   else
+   {
+      params.c_cflag &= ~CRTSCTS;
+   }
+#else
+      rb_raise(rb_eIOError, "Hardware flow control not supported");
+   }
+#endif
+
+   if (flowc & SOFT)
+   {
+      params.c_iflag |= (IXON | IXOFF | IXANY);
+   }
+   else
+   {
+      params.c_iflag &= ~(IXON | IXOFF | IXANY);
+   }
+
+   if (tcsetattr(fd, TCSANOW, &params) == -1)
+   {
+      rb_sys_fail(sTcsetattr);
+   }
+
+   return val;
+}
+
+VALUE sp_get_flow_control_impl(self)
+   VALUE self;
+{
+   int ret;
+   int fd;
+   struct termios params;
+
+   fd = get_fd_helper(self);
+   if (tcgetattr(fd, &params) == -1)
+   {
+      rb_sys_fail(sTcgetattr);
+   }
+
+   ret = 0;
+
+#ifdef HAVE_FLOWCONTROL_HARD
+   if (params.c_cflag & CRTSCTS)
+   {
+      ret += HARD;
+   }
+#endif
+
+   if (params.c_iflag & (IXON | IXOFF | IXANY))
+   {
+      ret += SOFT;
+   }
+
+   return INT2FIX(ret);
+}
+
+VALUE sp_set_read_timeout_impl(self, val)
+   VALUE self, val;
+{
+   int timeout;
+   int fd;
+   struct termios params;
+
+   Check_Type(val, T_FIXNUM);
+   timeout = FIX2INT(val);
+
+   fd = get_fd_helper(self);
+   if (tcgetattr(fd, &params) == -1)
+   {
+      rb_sys_fail(sTcgetattr);
+   }
+
+   if (timeout < 0)
+   {
+      params.c_cc[VTIME] = 0;
+      params.c_cc[VMIN] = 0;
+   }
+   else if (timeout == 0)
+   {
+      params.c_cc[VTIME] = 0;
+      params.c_cc[VMIN] = 1;
+   }
+   else
+   {
+      params.c_cc[VTIME] = (timeout + 50) / 100;
+      params.c_cc[VMIN] = 0;
+   }
+
+   if (tcsetattr(fd, TCSANOW, &params) == -1)
+   {
+      rb_sys_fail(sTcsetattr);
+   }
+
+   return val;
+}
+
+VALUE sp_get_read_timeout_impl(self)
+   VALUE self;
+{
+   int fd;
+   struct termios params;
+
+   fd = get_fd_helper(self);
+   if (tcgetattr(fd, &params) == -1)
+   {
+      rb_sys_fail(sTcgetattr);
+   }
+
+   if (params.c_cc[VTIME] == 0 && params.c_cc[VMIN] == 0)
+   {
+      return INT2FIX(-1);
+   }
+
+   return INT2FIX(params.c_cc[VTIME] * 100);
+}
+
+VALUE sp_set_write_timeout_impl(self, val)
+   VALUE self, val;
+{
+   rb_notimplement();
+   return self;
+}
+
+VALUE sp_get_write_timeout_impl(self)
+   VALUE self;
+{
+   rb_notimplement();
+   return self;
+}
+
+VALUE sp_break_impl(self, time)
+   VALUE self, time;
+{
+   int fd;
+
+   Check_Type(time, T_FIXNUM);
+
+   fd = get_fd_helper(self);
+
+   if (tcsendbreak(fd, FIX2INT(time) / 3) == -1)
+   {
+      rb_sys_fail("tcsendbreak");
+   }
+
+   return Qnil;
+}
+
+void get_line_signals_helper_impl(obj, ls)
+   VALUE obj;
+   struct line_signals *ls;
+{
+   int fd, status;
+
+   fd = get_fd_helper(obj);
+
+   if (ioctl(fd, TIOCMGET, &status) == -1)
+   {
+      rb_sys_fail(sIoctl);
+   }
+
+   ls->rts = (status & TIOCM_RTS ? 1 : 0);
+   ls->dtr = (status & TIOCM_DTR ? 1 : 0);
+   ls->cts = (status & TIOCM_CTS ? 1 : 0);
+   ls->dsr = (status & TIOCM_DSR ? 1 : 0);
+   ls->dcd = (status & TIOCM_CD ? 1 : 0);
+   ls->ri  = (status & TIOCM_RI ? 1 : 0);
+}
+
+VALUE set_signal_impl(obj, val, sig)
+   VALUE obj,val;
+   int sig;
+{
+   int status;
+   int fd;
+   int set;
+
+   Check_Type(val, T_FIXNUM);
+   fd = get_fd_helper(obj);
+
+   if (ioctl(fd, TIOCMGET, &status) == -1)
+   {
+      rb_sys_fail(sIoctl);
+   }
+
+   set = FIX2INT(val);
+
+   if (set == 0)
+   {
+      status &= ~sig;
+   }
+   else if (set == 1)
+   {
+      status |= sig;
+   }
+   else
+   {
+      rb_raise(rb_eArgError, "invalid value");
+   }
+
+   if (ioctl(fd, TIOCMSET, &status) == -1)
+   {
+      rb_sys_fail(sIoctl);
+   }
+
+   return val;
+}
+
+VALUE sp_set_rts_impl(self, val)
+   VALUE self, val;
+{
+   return set_signal_impl(self, val, TIOCM_RTS);
+}
+
+VALUE sp_set_dtr_impl(self, val)
+   VALUE self, val;
+{
+   return set_signal_impl(self, val, TIOCM_DTR);
+}
+
+VALUE sp_get_rts_impl(self)
+   VALUE self;
+{
+   struct line_signals ls;
+
+   get_line_signals_helper_impl(self, &ls);
+   return INT2FIX(ls.rts);
+}
+
+VALUE sp_get_dtr_impl(self)
+   VALUE self;
+{
+   struct line_signals ls;
+
+   get_line_signals_helper_impl(self, &ls);
+
+   return INT2FIX(ls.dtr);
+}
+
+#endif /* !defined(OS_MSWIN) && !defined(OS_BCCWIN) && !defined(OS_MINGW) */