trilogy_w_prepared_statements 2.2.0

data/ext/trilogy-ruby/src/vendor/curl_hostcheck.c

@@ -0,0 +1,206 @@
+/***************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 1998 - 2012, Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at http://curl.haxx.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ***************************************************************************/
+
+/* This file is an amalgamation of hostcheck.c and most of rawstr.c
+   from cURL.  The contents of the COPYING file mentioned above are:
+COPYRIGHT AND PERMISSION NOTICE
+Copyright (c) 1996 - 2013, Daniel Stenberg, <daniel@haxx.se>.
+All rights reserved.
+Permission to use, copy, modify, and distribute this software for any purpose
+with or without fee is hereby granted, provided that the above copyright
+notice and this permission notice appear in all copies.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN
+NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
+OR OTHER DEALINGS IN THE SOFTWARE.
+Except as contained in this notice, the name of a copyright holder shall not
+be used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization of the copyright holder.
+*/
+
+#include "trilogy/vendor/curl_hostcheck.h"
+#include <string.h>
+
+/* Portable, consistent toupper (remember EBCDIC). Do not use toupper() because
+   its behavior is altered by the current locale. */
+static char Curl_raw_toupper(char in)
+{
+    switch (in) {
+    case 'a':
+        return 'A';
+    case 'b':
+        return 'B';
+    case 'c':
+        return 'C';
+    case 'd':
+        return 'D';
+    case 'e':
+        return 'E';
+    case 'f':
+        return 'F';
+    case 'g':
+        return 'G';
+    case 'h':
+        return 'H';
+    case 'i':
+        return 'I';
+    case 'j':
+        return 'J';
+    case 'k':
+        return 'K';
+    case 'l':
+        return 'L';
+    case 'm':
+        return 'M';
+    case 'n':
+        return 'N';
+    case 'o':
+        return 'O';
+    case 'p':
+        return 'P';
+    case 'q':
+        return 'Q';
+    case 'r':
+        return 'R';
+    case 's':
+        return 'S';
+    case 't':
+        return 'T';
+    case 'u':
+        return 'U';
+    case 'v':
+        return 'V';
+    case 'w':
+        return 'W';
+    case 'x':
+        return 'X';
+    case 'y':
+        return 'Y';
+    case 'z':
+        return 'Z';
+    }
+    return in;
+}
+
+/*
+ * Curl_raw_equal() is for doing "raw" case insensitive strings. This is meant
+ * to be locale independent and only compare strings we know are safe for
+ * this.  See http://daniel.haxx.se/blog/2008/10/15/strcasecmp-in-turkish/ for
+ * some further explanation to why this function is necessary.
+ *
+ * The function is capable of comparing a-z case insensitively even for
+ * non-ascii.
+ */
+
+static int Curl_raw_equal(const char *first, const char *second)
+{
+    while (*first && *second) {
+        if (Curl_raw_toupper(*first) != Curl_raw_toupper(*second))
+            /* get out of the loop as soon as they don't match */
+            break;
+        first++;
+        second++;
+    }
+    /* we do the comparison here (possibly again), just to make sure that if the
+       loop above is skipped because one of the strings reached zero, we must
+       not return this as a successful match */
+    return (Curl_raw_toupper(*first) == Curl_raw_toupper(*second));
+}
+
+static int Curl_raw_nequal(const char *first, const char *second, size_t max)
+{
+    while (*first && *second && max) {
+        if (Curl_raw_toupper(*first) != Curl_raw_toupper(*second)) {
+            break;
+        }
+        max--;
+        first++;
+        second++;
+    }
+    if (0 == max)
+        return 1; /* they are equal this far */
+
+    return Curl_raw_toupper(*first) == Curl_raw_toupper(*second);
+}
+
+/*
+ * Match a hostname against a wildcard pattern.
+ * E.g.
+ *  "foo.host.com" matches "*.host.com".
+ *
+ * We use the matching rule described in RFC6125, section 6.4.3.
+ * http://tools.ietf.org/html/rfc6125#section-6.4.3
+ */
+
+static int hostmatch(const char *hostname, const char *pattern)
+{
+    const char *pattern_label_end, *pattern_wildcard, *hostname_label_end;
+    int wildcard_enabled;
+    size_t prefixlen, suffixlen;
+    pattern_wildcard = strchr(pattern, '*');
+    if (pattern_wildcard == NULL)
+        return Curl_raw_equal(pattern, hostname) ? CURL_HOST_MATCH : CURL_HOST_NOMATCH;
+
+    /* We require at least 2 dots in pattern to avoid too wide wildcard
+       match. */
+    wildcard_enabled = 1;
+    pattern_label_end = strchr(pattern, '.');
+    if (pattern_label_end == NULL || strchr(pattern_label_end + 1, '.') == NULL ||
+        pattern_wildcard > pattern_label_end || Curl_raw_nequal(pattern, "xn--", 4)) {
+        wildcard_enabled = 0;
+    }
+    if (!wildcard_enabled)
+        return Curl_raw_equal(pattern, hostname) ? CURL_HOST_MATCH : CURL_HOST_NOMATCH;
+
+    hostname_label_end = strchr(hostname, '.');
+    if (hostname_label_end == NULL || !Curl_raw_equal(pattern_label_end, hostname_label_end))
+        return CURL_HOST_NOMATCH;
+
+    /* The wildcard must match at least one character, so the left-most
+       label of the hostname is at least as large as the left-most label
+       of the pattern. */
+    if (hostname_label_end - hostname < pattern_label_end - pattern)
+        return CURL_HOST_NOMATCH;
+
+    prefixlen = (size_t)(pattern_wildcard - pattern);
+    suffixlen = (size_t)(pattern_label_end - (pattern_wildcard + 1));
+    return Curl_raw_nequal(pattern, hostname, prefixlen) &&
+                   Curl_raw_nequal(pattern_wildcard + 1, hostname_label_end - suffixlen, suffixlen)
+               ? CURL_HOST_MATCH
+               : CURL_HOST_NOMATCH;
+}
+
+int Curl_cert_hostcheck(const char *match_pattern, const char *hostname)
+{
+    if (!match_pattern || !*match_pattern || !hostname || !*hostname) /* sanity check */
+        return 0;
+
+    if (Curl_raw_equal(hostname, match_pattern)) /* trivial case */
+        return 1;
+
+    if (hostmatch(hostname, match_pattern) == CURL_HOST_MATCH)
+        return 1;
+    return 0;
+}

data/ext/trilogy-ruby/src/vendor/openssl_hostname_validation.c

@@ -0,0 +1,175 @@
+/* Obtained from: https://github.com/iSECPartners/ssl-conservatory */
+
+/*
+Copyright (C) 2012, iSEC Partners.
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+ */
+
+/*
+ * Helper functions to perform basic hostname validation using OpenSSL.
+ *
+ * Please read "everything-you-wanted-to-know-about-openssl.pdf" before
+ * attempting to use this code. This whitepaper describes how the code works,
+ * how it should be used, and what its limitations are.
+ *
+ * Author:  Alban Diquet
+ * License: See LICENSE
+ *
+ */
+
+// Get rid of OSX 10.7 and greater deprecation warnings.
+#if defined(__APPLE__) && defined(__clang__)
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+#endif
+
+#include <openssl/ssl.h>
+#include <openssl/x509v3.h>
+#include <string.h>
+
+#include "trilogy/vendor/curl_hostcheck.h"
+#include "trilogy/vendor/openssl_hostname_validation.h"
+
+#define HOSTNAME_MAX_SIZE 255
+
+#if (OPENSSL_VERSION_NUMBER < 0x10100000L) ||                                                                          \
+    (defined(LIBRESSL_VERSION_NUMBER) && LIBRESSL_VERSION_NUMBER < 0x20700000L)
+#define ASN1_STRING_get0_data ASN1_STRING_data
+#endif
+
+/**
+ * Tries to find a match for hostname in the certificate's Common Name field.
+ *
+ * Returns MatchFound if a match was found.
+ * Returns MatchNotFound if no matches were found.
+ * Returns MalformedCertificate if the Common Name had a NUL character embedded
+ * in it. Returns Error if the Common Name could not be extracted.
+ */
+static HostnameValidationResult matches_common_name(const char *hostname, const X509 *server_cert)
+{
+    int common_name_loc = -1;
+    X509_NAME_ENTRY *common_name_entry = NULL;
+    ASN1_STRING *common_name_asn1 = NULL;
+    const char *common_name_str = NULL;
+
+    // Find the position of the CN field in the Subject field of the certificate
+    common_name_loc = X509_NAME_get_index_by_NID(X509_get_subject_name((X509 *)server_cert), NID_commonName, -1);
+    if (common_name_loc < 0) {
+        return Error;
+    }
+
+    // Extract the CN field
+    common_name_entry = X509_NAME_get_entry(X509_get_subject_name((X509 *)server_cert), common_name_loc);
+    if (common_name_entry == NULL) {
+        return Error;
+    }
+
+    // Convert the CN field to a C string
+    common_name_asn1 = X509_NAME_ENTRY_get_data(common_name_entry);
+    if (common_name_asn1 == NULL) {
+        return Error;
+    }
+    common_name_str = (char *)ASN1_STRING_get0_data(common_name_asn1);
+
+    // Make sure there isn't an embedded NUL character in the CN
+    if ((size_t)ASN1_STRING_length(common_name_asn1) != strlen(common_name_str)) {
+        return MalformedCertificate;
+    }
+
+    // Compare expected hostname with the CN
+    if (Curl_cert_hostcheck(common_name_str, hostname) == CURL_HOST_MATCH) {
+        return MatchFound;
+    } else {
+        return MatchNotFound;
+    }
+}
+
+/**
+ * Tries to find a match for hostname in the certificate's Subject Alternative
+ * Name extension.
+ *
+ * Returns MatchFound if a match was found.
+ * Returns MatchNotFound if no matches were found.
+ * Returns MalformedCertificate if any of the hostnames had a NUL character
+ * embedded in it. Returns NoSANPresent if the SAN extension was not present in
+ * the certificate.
+ */
+static HostnameValidationResult matches_subject_alternative_name(const char *hostname, const X509 *server_cert)
+{
+    HostnameValidationResult result = MatchNotFound;
+    int i;
+    int san_names_nb = -1;
+    STACK_OF(GENERAL_NAME) *san_names = NULL;
+
+    // Try to extract the names within the SAN extension from the certificate
+    san_names = X509_get_ext_d2i((X509 *)server_cert, NID_subject_alt_name, NULL, NULL);
+    if (san_names == NULL) {
+        return NoSANPresent;
+    }
+    san_names_nb = sk_GENERAL_NAME_num(san_names);
+
+    // Check each name within the extension
+    for (i = 0; i < san_names_nb; i++) {
+        const GENERAL_NAME *current_name = sk_GENERAL_NAME_value(san_names, i);
+
+        if (current_name->type == GEN_DNS) {
+            // Current name is a DNS name, let's check it
+            const char *dns_name = (char *)ASN1_STRING_get0_data(current_name->d.dNSName);
+
+            // Make sure there isn't an embedded NUL character in the DNS name
+            if ((size_t)ASN1_STRING_length(current_name->d.dNSName) != strlen(dns_name)) {
+                result = MalformedCertificate;
+                break;
+            } else { // Compare expected hostname with the DNS name
+                if (Curl_cert_hostcheck(dns_name, hostname) == CURL_HOST_MATCH) {
+                    result = MatchFound;
+                    break;
+                }
+            }
+        }
+    }
+    sk_GENERAL_NAME_pop_free(san_names, GENERAL_NAME_free);
+
+    return result;
+}
+
+/**
+ * Validates the server's identity by looking for the expected hostname in the
+ * server's certificate. As described in RFC 6125, it first tries to find a
+ * match in the Subject Alternative Name extension. If the extension is not
+ * present in the certificate, it checks the Common Name instead.
+ *
+ * Returns MatchFound if a match was found.
+ * Returns MatchNotFound if no matches were found.
+ * Returns MalformedCertificate if any of the hostnames had a NUL character
+ * embedded in it. Returns Error if there was an error.
+ */
+HostnameValidationResult validate_hostname(const char *hostname, const X509 *server_cert)
+{
+    HostnameValidationResult result;
+
+    if ((hostname == NULL) || (server_cert == NULL))
+        return Error;
+
+    // First try the Subject Alternative Names extension
+    result = matches_subject_alternative_name(hostname, server_cert);
+    if (result == NoSANPresent) {
+        // Extension was not found: try the Common Name
+        result = matches_common_name(hostname, server_cert);
+    }
+
+    return result;
+}

data/ext/trilogy-ruby/trilogy-ruby.h

@@ -0,0 +1,37 @@
+#ifndef TRILOGY_RUBY_H
+#define TRILOGY_RUBY_H
+
+#include <stdbool.h>
+
+#include <trilogy.h>
+
+#define TRILOGY_FLAGS_CAST 1
+#define TRILOGY_FLAGS_CAST_BOOLEANS 2
+#define TRILOGY_FLAGS_LOCAL_TIMEZONE 4
+#define TRILOGY_FLAGS_FLATTEN_ROWS 8
+#define TRILOGY_FLAGS_DEFAULT (TRILOGY_FLAGS_CAST)
+
+struct rb_trilogy_cast_options {
+    bool cast;
+    bool cast_booleans;
+    bool database_local_time;
+    bool flatten_rows;
+};
+
+struct column_info {
+    TRILOGY_TYPE_t type;
+    TRILOGY_CHARSET_t charset;
+    uint32_t len;
+    uint16_t flags;
+    uint8_t decimals;
+};
+
+extern VALUE rb_cTrilogyError;
+
+VALUE
+rb_trilogy_cast_value(const trilogy_value_t *value, const struct column_info *column,
+                      const struct rb_trilogy_cast_options *options);
+
+void rb_trilogy_cast_init(void);
+
+#endif

data/lib/trilogy/version.rb

@@ -0,0 +1,3 @@
+class Trilogy
+  VERSION = "2.2.0"
+end

data/lib/trilogy.rb

@@ -0,0 +1,61 @@
+require "trilogy/cext"
+require "trilogy/version"
+
+class Trilogy
+  def in_transaction?
+    (server_status & SERVER_STATUS_IN_TRANS) != 0
+  end
+
+  def server_info
+    version_str = server_version
+
+    if /\A(\d+)\.(\d+)\.(\d+)/ =~ version_str
+      version_num = ($1.to_i * 10000) + ($2.to_i * 100) + $3.to_i
+    end
+
+    { :version => version_str, :id => version_num }
+  end
+
+  def connected_host
+    @connected_host ||= query_with_flags("select @@hostname", query_flags | QUERY_FLAGS_FLATTEN_ROWS).rows.first
+  end
+
+  def query_with_flags(sql, flags)
+    old_flags = query_flags
+    self.query_flags = flags
+
+    query(sql)
+  ensure
+    self.query_flags = old_flags
+  end
+end
+
+Trilogy::Result.class_eval do
+  def count
+    rows.count
+  end
+
+  def each_hash
+    return enum_for(:each_hash) unless block_given?
+
+    rows.each do |row|
+      this_row = {}
+
+      idx = 0
+      row.each do |col|
+        this_row[fields[idx]] = col
+        idx += 1
+      end
+
+      yield this_row
+    end
+
+    self
+  end
+
+  def each(&bk)
+    rows.each(&bk)
+  end
+
+  include Enumerable
+end

data/trilogy.gemspec

@@ -0,0 +1,27 @@
+require File.expand_path("../lib/trilogy/version", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name = 'trilogy_w_prepared_statements'
+  s.version = Trilogy::VERSION
+  s.authors = ['GitHub Engineering', 'Brian Lopez']
+  s.email = "opensource+trilogy@github.com"
+  s.license = "MIT"
+  s.homepage = "https://github.com/lorint/trilogy_w_prepared_statements"
+  s.summary = "A friendly MySQL-compatible library for Ruby, binding to libtrilogy"
+
+  s.extensions = "ext/trilogy-ruby/extconf.rb"
+
+  gem_files = %w[LICENSE README.md Rakefile trilogy.gemspec]
+  gem_files += Dir.glob("lib/**/*.rb")
+  gem_files += Dir.glob("ext/trilogy-ruby/*.c")
+  gem_files += Dir.glob("ext/trilogy-ruby/*.h")
+  gem_files += Dir.glob("ext/trilogy-ruby/src/**/*.c")
+  gem_files += Dir.glob("ext/trilogy-ruby/inc/**/*.h")
+
+  s.files = gem_files
+
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "rake-compiler", "~> 1.0"
+  s.add_development_dependency "minitest", "~> 5.5"
+end

metadata

@@ -0,0 +1,107 @@
+--- !ruby/object:Gem::Specification
+name: trilogy_w_prepared_statements
+version: !ruby/object:Gem::Version
+  version: 2.2.0
+platform: ruby
+authors:
+- GitHub Engineering
+- Brian Lopez
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-12-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.5'
+description:
+email: opensource+trilogy@github.com
+executables: []
+extensions:
+- ext/trilogy-ruby/extconf.rb
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- Rakefile
+- ext/trilogy-ruby/cast.c
+- ext/trilogy-ruby/cext.c
+- ext/trilogy-ruby/extconf.rb
+- ext/trilogy-ruby/inc/trilogy.h
+- ext/trilogy-ruby/inc/trilogy/blocking.h
+- ext/trilogy-ruby/inc/trilogy/buffer.h
+- ext/trilogy-ruby/inc/trilogy/builder.h
+- ext/trilogy-ruby/inc/trilogy/charset.h
+- ext/trilogy-ruby/inc/trilogy/client.h
+- ext/trilogy-ruby/inc/trilogy/error.h
+- ext/trilogy-ruby/inc/trilogy/packet_parser.h
+- ext/trilogy-ruby/inc/trilogy/protocol.h
+- ext/trilogy-ruby/inc/trilogy/reader.h
+- ext/trilogy-ruby/inc/trilogy/socket.h
+- ext/trilogy-ruby/inc/trilogy/vendor/curl_hostcheck.h
+- ext/trilogy-ruby/inc/trilogy/vendor/openssl_hostname_validation.h
+- ext/trilogy-ruby/src/blocking.c
+- ext/trilogy-ruby/src/buffer.c
+- ext/trilogy-ruby/src/builder.c
+- ext/trilogy-ruby/src/charset.c
+- ext/trilogy-ruby/src/client.c
+- ext/trilogy-ruby/src/error.c
+- ext/trilogy-ruby/src/packet_parser.c
+- ext/trilogy-ruby/src/protocol.c
+- ext/trilogy-ruby/src/reader.c
+- ext/trilogy-ruby/src/socket.c
+- ext/trilogy-ruby/src/vendor/curl_hostcheck.c
+- ext/trilogy-ruby/src/vendor/openssl_hostname_validation.c
+- ext/trilogy-ruby/trilogy-ruby.h
+- lib/trilogy.rb
+- lib/trilogy/version.rb
+- trilogy.gemspec
+homepage: https://github.com/lorint/trilogy_w_prepared_statements
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.8
+signing_key:
+specification_version: 4
+summary: A friendly MySQL-compatible library for Ruby, binding to libtrilogy
+test_files: []