tiny_tds 2.1.2 → 3.2.0

data/ext/tiny_tds/client.c

@@ -24,25 +24,25 @@ VALUE opt_escape_regex, opt_escape_dblquote;
 
 // Lib Backend (Helpers)
 
-VALUE rb_tinytds_raise_error(DBPROCESS *dbproc, int is_message, int cancel, const char *error, const char *source, int severity, int dberr, int oserr) {
+VALUE rb_tinytds_raise_error(DBPROCESS *dbproc, tinytds_errordata error) {
   VALUE e;
   GET_CLIENT_USERDATA(dbproc);
-  if (cancel && !dbdead(dbproc) && userdata && !userdata->closed) {
+  if (error.cancel && !dbdead(dbproc) && userdata && !userdata->closed) {
     userdata->dbsqlok_sent = 1;
     dbsqlok(dbproc);
     userdata->dbcancel_sent = 1;
     dbcancel(dbproc);
   }
-  e = rb_exc_new2(cTinyTdsError, error);
-  rb_funcall(e, intern_source_eql, 1, rb_str_new2(source));
-  if (severity)
-    rb_funcall(e, intern_severity_eql, 1, INT2FIX(severity));
-  if (dberr)
-    rb_funcall(e, intern_db_error_number_eql, 1, INT2FIX(dberr));
-  if (oserr)
-    rb_funcall(e, intern_os_error_number_eql, 1, INT2FIX(oserr));
-
-  if (severity <= 10 && is_message) {
+  e = rb_exc_new2(cTinyTdsError, error.error);
+  rb_funcall(e, intern_source_eql, 1, rb_str_new2(error.source));
+  if (error.severity)
+    rb_funcall(e, intern_severity_eql, 1, INT2FIX(error.severity));
+  if (error.dberr)
+    rb_funcall(e, intern_db_error_number_eql, 1, INT2FIX(error.dberr));
+  if (error.oserr)
+    rb_funcall(e, intern_os_error_number_eql, 1, INT2FIX(error.oserr));
+
+  if (error.severity <= 10 && error.is_message) {
     VALUE message_handler = userdata && userdata->message_handler ? userdata->message_handler : Qnil;
     if (message_handler && message_handler != Qnil && rb_respond_to(message_handler, intern_call) != 0) {
       rb_funcall(message_handler, intern_call, 1, e);
@@ -57,6 +57,16 @@ VALUE rb_tinytds_raise_error(DBPROCESS *dbproc, int is_message, int cancel, cons
 
 
 // Lib Backend (Memory Management & Handlers)
+static void push_userdata_error(tinytds_client_userdata *userdata, tinytds_errordata error) {
+  // reallocate memory for the array as needed
+  if (userdata->nonblocking_errors_size == userdata->nonblocking_errors_length) {
+    userdata->nonblocking_errors_size *= 2;
+    userdata->nonblocking_errors = realloc(userdata->nonblocking_errors, userdata->nonblocking_errors_size * sizeof(tinytds_errordata));
+  }
+
+  userdata->nonblocking_errors[userdata->nonblocking_errors_length] = error;
+  userdata->nonblocking_errors_length++;
+}
 
 int tinytds_err_handler(DBPROCESS *dbproc, int severity, int dberr, int oserr, char *dberrstr, char *oserrstr) {
   static const char *source = "error";
@@ -86,6 +96,13 @@ int tinytds_err_handler(DBPROCESS *dbproc, int severity, int dberr, int oserr, c
       but we don't ever want to automatically retry. Instead have the app
       decide what to do.
       */
+      if (userdata && userdata->timing_out) {
+        return INT_CANCEL;
+      }
+      // userdata will not be set if hitting timeout during login so check for it first
+      if (userdata) {
+        userdata->timing_out = 1;
+      }
       return_value = INT_TIMEOUT;
       cancel = 1;
       break;
@@ -99,6 +116,16 @@ int tinytds_err_handler(DBPROCESS *dbproc, int severity, int dberr, int oserr, c
       break;
   }
 
+  tinytds_errordata error_data = {
+    .is_message = 0,
+    .cancel = cancel,
+    .severity = severity,
+    .dberr = dberr,
+    .oserr = oserr
+  };
+  strncpy(error_data.error, dberrstr, ERROR_MSG_SIZE);
+  strncpy(error_data.source, source, ERROR_MSG_SIZE);
+
   /*
   When in non-blocking mode we need to store the exception data to throw it
   once the blocking call returns, otherwise we will segfault ruby since part
@@ -110,27 +137,9 @@ int tinytds_err_handler(DBPROCESS *dbproc, int severity, int dberr, int oserr, c
       dbcancel(dbproc);
       userdata->dbcancel_sent = 1;
     }
-
-    /*
-    If we've already captured an error message, don't overwrite it. This is
-    here because FreeTDS sends a generic "General SQL Server error" message
-    that will overwrite the real message. This is not normally a problem
-    because a ruby exception is normally thrown and we bail before the
-    generic message can be sent.
-    */
-    if (!userdata->nonblocking_error.is_set) {
-      userdata->nonblocking_error.is_message = 0;
-      userdata->nonblocking_error.cancel = cancel;
-      strncpy(userdata->nonblocking_error.error, dberrstr, ERROR_MSG_SIZE);
-      strncpy(userdata->nonblocking_error.source, source, ERROR_MSG_SIZE);
-      userdata->nonblocking_error.severity = severity;
-      userdata->nonblocking_error.dberr = dberr;
-      userdata->nonblocking_error.oserr = oserr;
-      userdata->nonblocking_error.is_set = 1;
-    }
-
+    push_userdata_error(userdata, error_data);
   } else {
-    rb_tinytds_raise_error(dbproc, 0, cancel, dberrstr, source, severity, dberr, oserr);
+    rb_tinytds_raise_error(dbproc, error_data);
   }
 
   return return_value;
@@ -142,36 +151,72 @@ int tinytds_msg_handler(DBPROCESS *dbproc, DBINT msgno, int msgstate, int severi
 
   int is_message_an_error = severity > 10 ? 1 : 0;
 
+  tinytds_errordata error_data = {
+    .is_message = !is_message_an_error,
+    .cancel = is_message_an_error,
+    .severity = severity,
+    .dberr = msgno,
+    .oserr = msgstate
+  };
+  strncpy(error_data.error, msgtext, ERROR_MSG_SIZE);
+  strncpy(error_data.source, source, ERROR_MSG_SIZE);
+
   // See tinytds_err_handler() for info about why we do this
   if (userdata && userdata->nonblocking) {
-    if (!userdata->nonblocking_error.is_set) {
-      userdata->nonblocking_error.is_message = !is_message_an_error;
-      userdata->nonblocking_error.cancel = is_message_an_error;
-      strncpy(userdata->nonblocking_error.error, msgtext, ERROR_MSG_SIZE);
-      strncpy(userdata->nonblocking_error.source, source, ERROR_MSG_SIZE);
-      userdata->nonblocking_error.severity = severity;
-      userdata->nonblocking_error.dberr = msgno;
-      userdata->nonblocking_error.oserr = msgstate;
-      userdata->nonblocking_error.is_set = 1;
-    }
+    /*
+    In the case of non-blocking command batch execution we can receive multiple messages
+    (including errors). We keep track of those here so they can be processed once the
+    non-blocking call returns.
+    */
+    push_userdata_error(userdata, error_data);
 
     if (is_message_an_error && !dbdead(dbproc) && !userdata->closed) {
       dbcancel(dbproc);
       userdata->dbcancel_sent = 1;
     }
   } else {
-    rb_tinytds_raise_error(dbproc, !is_message_an_error, is_message_an_error, msgtext, source, severity, msgno, msgstate);
+    rb_tinytds_raise_error(dbproc, error_data);
   }
   return 0;
 }
 
+/*
+Used by dbsetinterrupt -
+This gets called periodically while waiting on a read from the server
+Right now, we only care about cases where a read from the server is
+taking longer than the specified timeout and dbcancel is not working.
+In these cases we decide that we actually want to handle the interrupt
+*/
+static int check_interrupt(void *ptr) {
+  GET_CLIENT_USERDATA((DBPROCESS *)ptr);
+  return userdata->timing_out;
+}
+
+/*
+Used by dbsetinterrupt -
+This gets called if check_interrupt returns TRUE.
+Right now, this is only used in cases where a read from the server is
+taking longer than the specified timeout and dbcancel is not working.
+Return INT_CANCEL to abort the current command batch.
+*/
+static int handle_interrupt(void *ptr) {
+  GET_CLIENT_USERDATA((DBPROCESS *)ptr);
+  if (userdata->timing_out) {
+    return INT_CANCEL;
+  }
+  return INT_CONTINUE;
+}
+
 static void rb_tinytds_client_reset_userdata(tinytds_client_userdata *userdata) {
   userdata->timing_out = 0;
   userdata->dbsql_sent = 0;
   userdata->dbsqlok_sent = 0;
   userdata->dbcancel_sent = 0;
   userdata->nonblocking = 0;
-  userdata->nonblocking_error.is_set = 0;
+  // the following is mainly done for consistency since the values are reset accordingly in nogvl_setup/cleanup.
+  // the nonblocking_errors array does not need to be freed here. That is done as part of nogvl_cleanup.
+  userdata->nonblocking_errors_length = 0;
+  userdata->nonblocking_errors_size = 0;
 }
 
 static void rb_tinytds_client_mark(void *ptr) {
@@ -187,6 +232,7 @@ static void rb_tinytds_client_free(void *ptr) {
     dbloginfree(cwrap->login);
   if (cwrap->client && !cwrap->closed) {
     dbclose(cwrap->client);
+    cwrap->client = NULL;
     cwrap->closed = 1;
     cwrap->userdata->closed = 1;
   }
@@ -218,6 +264,7 @@ static VALUE rb_tinytds_close(VALUE self) {
   GET_CLIENT_WRAPPER(self);
   if (cwrap->client && !cwrap->closed) {
     dbclose(cwrap->client);
+    cwrap->client = NULL;
     cwrap->closed = 1;
     cwrap->userdata->closed = 1;
   }
@@ -252,8 +299,7 @@ static VALUE rb_tinytds_execute(VALUE self, VALUE sql) {
   REQUIRE_OPEN_CLIENT(cwrap);
   dbcmd(cwrap->client, StringValueCStr(sql));
   if (dbsqlsend(cwrap->client) == FAIL) {
-    rb_warn("TinyTds: dbsqlsend() returned FAIL.\n");
-    return Qfalse;
+    rb_raise(cTinyTdsError, "failed dbsqlsend() function");
   }
   cwrap->userdata->dbsql_sent = 1;
   result = rb_tinytds_new_result_obj(cwrap);
@@ -357,17 +403,15 @@ static VALUE rb_tinytds_connect(VALUE self, VALUE opts) {
       #endif
     }
   }
-  #ifdef DBSETUTF16
-    if (use_utf16 == Qtrue)  { DBSETLUTF16(cwrap->login, 1); }
-    if (use_utf16 == Qfalse) { DBSETLUTF16(cwrap->login, 0); }
-  #else
-    if (use_utf16 == Qtrue || use_utf16 == Qfalse) {
-      rb_warning("TinyTds: Please consider upgrading to FreeTDS 0.99 or higher for better unicode support.\n");
-    }
-  #endif
+  if (use_utf16 == Qtrue)  { DBSETLUTF16(cwrap->login, 1); }
+  if (use_utf16 == Qfalse) { DBSETLUTF16(cwrap->login, 0); }
 
   cwrap->client = dbopen(cwrap->login, StringValueCStr(dataserver));
   if (cwrap->client) {
+    if (dbtds(cwrap->client) < 11) {
+      rb_raise(cTinyTdsError, "connecting with a TDS version older than 7.3!");
+    }
+
     VALUE transposed_encoding, timeout_string;
 
     cwrap->closed = 0;
@@ -381,17 +425,14 @@ static VALUE rb_tinytds_connect(VALUE self, VALUE opts) {
       }
     }
     dbsetuserdata(cwrap->client, (BYTE*)cwrap->userdata);
+    dbsetinterrupt(cwrap->client, check_interrupt, handle_interrupt);
     cwrap->userdata->closed = 0;
     if (!NIL_P(database) && (azure != Qtrue)) {
       dbuse(cwrap->client, StringValueCStr(database));
     }
     transposed_encoding = rb_funcall(cTinyTdsClient, intern_transpose_iconv_encoding, 1, charset);
     cwrap->encoding = rb_enc_find(StringValueCStr(transposed_encoding));
-    if (dbtds(cwrap->client) <= 7) {
-      cwrap->identity_insert_sql = "SELECT CAST(@@IDENTITY AS bigint) AS Ident";
-    } else {
-      cwrap->identity_insert_sql = "SELECT CAST(SCOPE_IDENTITY() AS bigint) AS Ident";
-    }
+    cwrap->identity_insert_sql = "SELECT CAST(SCOPE_IDENTITY() AS bigint) AS Ident";
   }
   return self;
 }

data/ext/tiny_tds/client.h

@@ -5,9 +5,9 @@
 void init_tinytds_client();
 
 #define ERROR_MSG_SIZE 1024
+#define ERRORS_STACK_INIT_SIZE 2
 
 typedef struct {
-  short int is_set;
   int is_message;
   int cancel;
   char error[ERROR_MSG_SIZE];
@@ -25,7 +25,9 @@ typedef struct {
   RETCODE dbsqlok_retcode;
   short int dbcancel_sent;
   short int nonblocking;
-  tinytds_errordata nonblocking_error;
+  short int nonblocking_errors_length;
+  short int nonblocking_errors_size;
+  tinytds_errordata *nonblocking_errors;
   VALUE message_handler;
 } tinytds_client_userdata;
 
@@ -40,7 +42,7 @@ typedef struct {
   rb_encoding *encoding;
 } tinytds_client_wrapper;
 
-VALUE rb_tinytds_raise_error(DBPROCESS *dbproc, int is_message, int cancel, const char *error, const char *source, int severity, int dberr, int oserr);
+VALUE rb_tinytds_raise_error(DBPROCESS *dbproc, tinytds_errordata error);
 
 // Lib Macros
 

data/ext/tiny_tds/extconf.rb

@@ -1,69 +1,190 @@
-ENV['RC_ARCHS'] = '' if RUBY_PLATFORM =~ /darwin/
+require "mkmf"
+require_relative "extconsts"
 
-# :stopdoc:
+if ENV["MAINTAINER_MODE"]
+  warn "Maintainer mode enabled."
+  $CFLAGS << # standard:disable Style/GlobalVars
+    " -Wall" \
+    " -ggdb" \
+    " -DDEBUG" \
+    " -pedantic"
+  $LDFLAGS << # standard:disable Style/GlobalVars
+    " -ggdb"
+end
 
-require 'mkmf'
-require 'rbconfig'
-require_relative './extconsts'
+if (gem_platform = with_config("cross-build"))
+  require "mini_portile2"
 
-# Shamelessly copied from nokogiri
-#
+  openssl_platform = with_config("openssl-platform")
 
-def do_help
-  print <<HELP
-usage: ruby #{$0} [options]
-    --with-freetds-dir=DIR
-      Use the freetds library placed under DIR.
-HELP
-  exit! 0
-end
+  class BuildRecipe < MiniPortile
+    attr_accessor :gem_platform
+
+    def initialize(name, version, files)
+      super(name, version)
+      self.files = files
+      rootdir = File.expand_path("../../..", __FILE__)
+      self.target = File.join(rootdir, "ports")
+      self.patch_files = Dir[File.join("patches", self.name, self.version, "*.patch")].sort
+    end
+
+    # this will yield all ports into the same directory, making our path configuration for the linker easier
+    def port_path
+      "#{@target}/#{gem_platform}"
+    end
+
+    def cook_and_activate
+      checkpoint = File.join(target, "#{name}-#{version}-#{gem_platform}.installed")
+
+      unless File.exist?(checkpoint)
+        cook
+        FileUtils.touch checkpoint
+      end
+
+      activate
+      self
+    end
+  end
+
+  openssl_recipe = BuildRecipe.new("openssl", OPENSSL_VERSION, [OPENSSL_SOURCE_URI]).tap do |recipe|
+    class << recipe
+      attr_accessor :openssl_platform
+
+      def configure
+        envs = []
+        envs << "CFLAGS=-DDSO_WIN32 -DOPENSSL_THREADS" if MiniPortile.windows?
+        envs << "CFLAGS=-fPIC -DOPENSSL_THREADS" if MiniPortile.linux?
+        execute("configure", ["env", *envs, "./Configure", openssl_platform, "threads", "-static", "CROSS_COMPILE=#{host}-", configure_prefix, "--libdir=lib"], altlog: "config.log")
+      end
+
+      def compile
+        execute("compile", "#{make_cmd} build_libs")
+      end
+
+      def install
+        execute("install", "#{make_cmd} install_dev")
+      end
+    end
+
+    recipe.gem_platform = gem_platform
+    recipe.openssl_platform = openssl_platform
+    recipe.cook_and_activate
+  end
+
+  libiconv_recipe = BuildRecipe.new("libiconv", ICONV_VERSION, [ICONV_SOURCE_URI]).tap do |recipe|
+    recipe.configure_options << "CFLAGS=-fPIC" if MiniPortile.linux?
+    recipe.gem_platform = gem_platform
+
+    recipe.cook_and_activate
+  end
 
-do_help if arg_config('--help')
+  # remove the ".la" files, otherwise libtool starts to complain when linking into FreeTDS
+  Dir.glob(File.join(libiconv_recipe.path, "lib", "**", "*.la")).each do |la_file|
+    File.delete(la_file)
+  end
 
-# Make sure to check the ports path for the configured host
-host = RbConfig::CONFIG['host']
-project_dir = File.join(['..']*4)
-freetds_ports_dir = File.join(project_dir, 'ports', host, 'freetds', FREETDS_VERSION)
-freetds_ports_dir = File.expand_path(freetds_ports_dir)
+  freetds_recipe = BuildRecipe.new("freetds", FREETDS_VERSION, [FREETDS_SOURCE_URI]).tap do |recipe|
+    class << recipe
+      def configure_defaults
+        [
+          "--host=#{@host}",
+          "--enable-shared",
+          "--disable-static",
+          "--disable-odbc"
+        ]
+      end
+    end
 
-# Add all the special path searching from the original tiny_tds build
-# order is important here! First in, last searched.
-DIRS = %w(
-  /usr/local
-  /opt/local
-)
+    # i am not 100% what is going on behind the scenes
+    # it seems that FreeTDS build system prefers OPENSSL_CFLAGS and OPENSSL_LIBS
+    # but the linker still relies on LIBS and CPPFLAGS
+    # removing one or the other leads to build failures in any case of FreeTDS
+    if MiniPortile.linux?
+      recipe.configure_options << "CFLAGS=-fPIC"
+    elsif MiniPortile.windows?
+      recipe.configure_options << "--enable-sspi"
+    end
 
-# Grab freetds environment variable for use by people on services like
-# Heroku who they can't easily use bundler config to set directories
-DIRS.push(ENV['FREETDS_DIR']) if ENV.has_key?('FREETDS_DIR')
+    # pass an additional runtime path to the linker so defncopy and tsql can find our shared sybdb
+    recipe.configure_options << "LDFLAGS=-L#{openssl_recipe.path}/lib #{"-Wl,-rpath='$$ORIGIN/../lib'" if MiniPortile.linux?}"
+    recipe.configure_options << "LIBS=-liconv -lssl -lcrypto #{"-lwsock32 -lgdi32 -lws2_32 -lcrypt32" if MiniPortile.windows?} #{"-ldl -lpthread" if MiniPortile.linux?}"
+    recipe.configure_options << "CPPFLAGS=-I#{openssl_recipe.path}/include"
 
-# Add the ports directory if it exists for local developer builds
-DIRS.push(freetds_ports_dir) if File.directory?(freetds_ports_dir)
+    recipe.configure_options << "OPENSSL_CFLAGS=-L#{openssl_recipe.path}/lib"
+    recipe.configure_options << "OPENSSL_LIBS=-lssl -lcrypto #{"-lwsock32 -lgdi32 -lws2_32 -lcrypt32" if MiniPortile.windows?} #{"-ldl -lpthread" if MiniPortile.linux?}"
 
-# Add the search paths for freetds configured above
-DIRS.each do |path|
-  idir = "#{path}/include"
-  ldir = "#{path}/lib"
+    recipe.configure_options << "--with-openssl=#{openssl_recipe.path}"
+    recipe.configure_options << "--with-libiconv-prefix=#{libiconv_recipe.path}"
+    recipe.configure_options << "--sysconfdir=C:/Sites" if MiniPortile.windows?
 
-  dir_config('freetds',
-    [idir, "#{idir}/freetds"],
+    recipe.gem_platform = gem_platform
+    recipe.cook_and_activate
+  end
+
+  # enable relative path to later load the FreeTDS shared library
+  $LDFLAGS << " '-Wl,-rpath=$$ORIGIN/../../../ports/#{gem_platform}/lib'" # standard:disable Style/GlobalVars
+
+  dir_config("freetds", "#{freetds_recipe.path}/include", "#{freetds_recipe.path}/lib")
+else
+  # Make sure to check the ports path for the configured host
+  architecture = RbConfig::CONFIG["arch"]
+
+  project_dir = File.expand_path("../../..", __FILE__)
+  freetds_ports_dir = File.join(project_dir, "ports", architecture, "freetds", FREETDS_VERSION)
+  freetds_ports_dir = File.expand_path(freetds_ports_dir)
+
+  # Add all the special path searching from the original tiny_tds build
+  # order is important here! First in, first searched.
+  DIRS = %w[
+    /opt/local
+    /usr/local
+  ]
+
+  if /darwin/i.match?(RbConfig::CONFIG["host_os"])
+    # Ruby below 2.7 seems to label the host CPU on Apple Silicon as aarch64
+    # 2.7 and above print is as ARM64
+    target_host_cpu = (Gem::Version.new(RUBY_VERSION) < Gem::Version.new("2.7")) ? "aarch64" : "arm64"
+
+    if RbConfig::CONFIG["host_cpu"] == target_host_cpu
+      # Homebrew on Apple Silicon installs into /opt/hombrew
+      # https://docs.brew.sh/Installation
+      # On Intel Macs, it is /usr/local, so no changes necessary to DIRS
+      DIRS.unshift("/opt/homebrew")
+    end
+  end
+
+  if ENV["RI_DEVKIT"] && ENV["MINGW_PREFIX"] # RubyInstaller Support
+    DIRS.unshift(File.join(ENV["RI_DEVKIT"], ENV["MINGW_PREFIX"]))
+  end
+
+  # Add the ports directory if it exists for local developer builds
+  DIRS.unshift(freetds_ports_dir) if File.directory?(freetds_ports_dir)
+
+  # Grab freetds environment variable for use by people on services like
+  # Heroku who they can't easily use bundler config to set directories
+  DIRS.unshift(ENV["FREETDS_DIR"]) if ENV.has_key?("FREETDS_DIR")
+
+  # Add the search paths for freetds configured above
+  ldirs = DIRS.flat_map do |path|
+    ldir = "#{path}/lib"
     [ldir, "#{ldir}/freetds"]
-  )
-end
+  end
 
-have_dependencies = [
-  find_header('sybfront.h'),
-  find_header('sybdb.h'),
-  find_library('sybdb', 'tdsdbopen'),
-  find_library('sybdb', 'dbanydatecrack')
-].inject(true) do |memo, current|
-  memo && current
-end
+  idirs = DIRS.flat_map do |path|
+    idir = "#{path}/include"
+    [idir, "#{idir}/freetds"]
+  end
 
-unless have_dependencies
-  abort 'Failed! Do you have FreeTDS 0.95.80 or higher installed?'
+  puts "looking for freetds headers in the following directories:\n#{idirs.map { |a| " - #{a}\n" }.join}"
+  puts "looking for freetds library in the following directories:\n#{ldirs.map { |a| " - #{a}\n" }.join}"
+  dir_config("freetds", idirs, ldirs)
 end
 
-create_makefile('tiny_tds/tiny_tds')
+find_header("sybfront.h") or abort "Can't find the 'sybfront.h' header"
+find_header("sybdb.h") or abort "Can't find the 'sybdb.h' header"
+
+unless have_library("sybdb", "dbanydatecrack")
+  abort "Failed! Do you have FreeTDS 1.0.0 or higher installed?"
+end
 
-# :startdoc:
+create_makefile("tiny_tds/tiny_tds")

data/ext/tiny_tds/extconsts.rb

@@ -1,15 +1,8 @@
-
-ICONV_VERSION = ENV['TINYTDS_ICONV_VERSION'] || "1.15"
+ICONV_VERSION = ENV["TINYTDS_ICONV_VERSION"] || "1.18"
 ICONV_SOURCE_URI = "http://ftp.gnu.org/pub/gnu/libiconv/libiconv-#{ICONV_VERSION}.tar.gz"
 
-OPENSSL_VERSION = ENV['TINYTDS_OPENSSL_VERSION'] || '1.1.0e'
+OPENSSL_VERSION = ENV["TINYTDS_OPENSSL_VERSION"] || "3.4.0"
 OPENSSL_SOURCE_URI = "https://www.openssl.org/source/openssl-#{OPENSSL_VERSION}.tar.gz"
 
-FREETDS_VERSION = ENV['TINYTDS_FREETDS_VERSION'] || "1.00.27"
-FREETDS_VERSION_INFO = Hash.new { |h,k|
-  h[k] = {files: "http://www.freetds.org/files/stable/freetds-#{k}.tar.bz2"}
-}
-FREETDS_VERSION_INFO['1.00'] = {files: 'http://www.freetds.org/files/stable/freetds-1.00.tar.bz2'}
-FREETDS_VERSION_INFO['0.99'] = {files: 'http://www.freetds.org/files/current/freetds-dev.0.99.678.tar.gz'}
-FREETDS_VERSION_INFO['0.95'] = {files: 'http://www.freetds.org/files/stable/freetds-0.95.92.tar.gz'}
-FREETDS_SOURCE_URI = FREETDS_VERSION_INFO[FREETDS_VERSION][:files]
+FREETDS_VERSION = ENV["TINYTDS_FREETDS_VERSION"] || "1.4.26"
+FREETDS_SOURCE_URI = "http://www.freetds.org/files/stable/freetds-#{FREETDS_VERSION}.tar.bz2"