guid: cover VARBINARY wire, fix its varying-prefix crash, drop dead arms

Test coverage:
- BindGuidToVarcharOctets16 — binds SQL_C_GUID to VARCHAR(16) CHARACTER
  SET OCTETS (the wire form of native FB4+ VARBINARY(16)).  The existing
  BindGuidToCharOctets16 only covered the fixed CHAR(16) (SQL_TEXT) slot;
  this exercises the SQL_VARYING (length-prefixed) binary wire, which was
  previously untested.

Bug the new test exposed (and fixes):
- For a SQL_VARYING binary wire, convGuidToBinary wrote 16 raw bytes at
  offset 0 with no 2-byte length prefix.  Firebird then read the first
  GUID bytes as a VARYING length and over-read the buffer — a hard
  SEGFAULT on the FB6 snapshot (silently tolerated on FB5).  The dispatch
  now calls setTypeText() for the OCTETS subtype-1/len-16 branch, mirroring
  the text branch: the varying wire becomes fixed SQL_TEXT (OCTETS charset
  preserved) so the offset-0 write is correct.  A fixed CHAR(16) wire is
  already SQL_TEXT, so this is a no-op there.
- The new test is SKIP_ON_FIREBIRD6-guarded: even with the prefix fix, the
  current FB6 master snapshot aborts this parameterized OCTETS-VARYING
  insert with a server-side "Stack overflow" — the same parameterized-query
  incompatibility already guarded across the suite.  Exercised on FB 3/4/5.

Dead-code removal:
- Drop the wire-side `to->conciseType == SQL_C_BINARY` arm.  Native FB4+
  BINARY/VARBINARY reach the dispatch as subtype-1 / sqllen-16 OCTETS
  (caught by the branch above); the only type that yields conciseType
  SQL_C_BINARY is a binary BLOB, not a sane GUID-bind target.
- Drop the app-side `case SQL_C_BINARY` arm.  That output direction is
  unreachable until column-side SQL_GUID mapping (T5-5 / #287) lands.

convGuidToBinary stays (still used by the OCTETS wire branch).  Verified:
all 4 GuidParamBindingTest cases pass on FB 5.0.3; on the FB6 snapshot the
3 non-varying cases pass and the VARBINARY case skips; full suite shows no
regressions.

Author: fdcastel

OdbcConvert.cpp

@@ -1001,20 +1001,27 @@ ADRESS_FUNCTION OdbcConvert::getAdressFunction(DescRecord * from, DescRecord * t
 		}
 		break;
 	case SQL_C_GUID:
-		// Wire-side (input parameter binding) — Firebird's IPD describes the slot
-		// as either BINARY(16) / CHAR(16) OCTETS, a text VARCHAR/CHAR, or (FB4+)
-		// genuine BINARY. Route to dedicated wire-only conversions; leave the
-		// pre-existing convGuidToString / convGuidToStringW untouched for the
-		// app-side fetch path below.
+		// Wire-side (input parameter binding) — Firebird's IPD describes the
+		// slot as either (VAR)BINARY(16) / (VAR)CHAR(16) CHARACTER SET OCTETS
+		// (subtype 1, sqllen 16) or a text VARCHAR/CHAR. Route to dedicated
+		// wire-only conversions; leave the pre-existing convGuidToString /
+		// convGuidToStringW untouched for the app-side fetch path below.
 		if ( to->isIndicatorSqlDa )
 		{
-			// BINARY(16) / CHAR(16) CHARACTER SET OCTETS — 16 raw bytes
+			// BINARY(16) / VARBINARY(16) — i.e. (VAR)CHAR(16) CHARACTER SET
+			// OCTETS, which is how Firebird represents native FB4+ BINARY types
+			// on the wire (subtype 1, sqllen 16). Send 16 raw canonical bytes.
+			// setTypeText() converts a SQL_VARYING wire (VARBINARY) to SQL_TEXT
+			// so convGuidToBinary can write at offset 0 with no length prefix;
+			// without it Firebird reads the first GUID bytes as a VARYING length
+			// prefix and over-reads the buffer (SEGFAULT on FB6). A fixed
+			// CHAR(16) wire is already SQL_TEXT, so this is a no-op there.
 			if ( to->headSqlVarPtr->getSqlSubtype() == 1
 				&& to->headSqlVarPtr->getSqlLen() == 16 )
+			{
+				to->headSqlVarPtr->setTypeText();
 				return &OdbcConvert::convGuidToBinary;
-			// FB4+ BINARY/VARBINARY described directly as SQL_C_BINARY
-			if ( to->conciseType == SQL_C_BINARY )
-				return &OdbcConvert::convGuidToBinary;
+			}
 			// Text wire (VARCHAR/CHAR, any charset) — 36-char canonical UUID.
 			// setTypeText() converts SQL_VARYING to SQL_TEXT so convGuidToVarString
 			// can write the bytes without a length prefix.
@@ -1031,8 +1038,6 @@ ADRESS_FUNCTION OdbcConvert::getAdressFunction(DescRecord * from, DescRecord * t
 			return &OdbcConvert::convGuidToString;
 		case SQL_C_WCHAR:
 			return &OdbcConvert::convGuidToStringW;
-		case SQL_C_BINARY:
-			return &OdbcConvert::convGuidToBinary;
 		default:
 			return &OdbcConvert::notYetImplemented;
 		}

tests/test_guid_and_binary.cpp

@@ -608,6 +608,61 @@ TEST_F(GuidParamBindingTest, BindGuidToUuidToCharRoundtrip) {
         << "Got: '" << text << "' — this is the corruption pattern from issue #295.";
 }
 
+// Bind SQL_C_GUID to a VARCHAR(16) CHARACTER SET OCTETS parameter — the
+// wire form of a native FB4+ VARBINARY(16). Unlike CHAR(16) OCTETS (a
+// fixed SQL_TEXT slot, covered by BindGuidToCharOctets16), this is a
+// SQL_VARYING slot, so it exercises convGuidToBinary writing into a
+// length-prefixed wire buffer. The dispatch calls setTypeText() to convert
+// the varying wire to SQL_TEXT before writing 16 raw bytes; without that the
+// first GUID bytes are read as a VARYING length prefix and the buffer is
+// over-read (SEGFAULT on the FB6 snapshot, silent on FB5).
+//
+// Skipped on FB6: even with the fix, the current FB6 master snapshot aborts
+// this parameterized OCTETS-VARYING insert with a server-side "Stack
+// overflow" — the same parameterized-query incompatibility already guarded
+// across the suite (see SKIP_ON_FIREBIRD6 usages). Exercised on FB 3/4/5.
+TEST_F(GuidParamBindingTest, BindGuidToVarcharOctets16) {
+    REQUIRE_FIREBIRD_CONNECTION();
+    SKIP_ON_FIREBIRD6();
+
+    TempTable table(this, "TEST_PB_GUID_VOCT",
+        "ID INTEGER NOT NULL PRIMARY KEY, "
+        "VAL VARCHAR(16) CHARACTER SET OCTETS");
+
+    SQLGUID guid = makeKnownGuid();
+    SQLLEN guidInd = sizeof(guid);
+    SQLINTEGER id = 1;
+    SQLLEN idInd = sizeof(id);
+
+    SQLRETURN ret = SQLBindParameter(hStmt, 1, SQL_PARAM_INPUT,
+        SQL_C_SLONG, SQL_INTEGER, 0, 0, &id, sizeof(id), &idInd);
+    ASSERT_TRUE(SQL_SUCCEEDED(ret));
+    ret = SQLBindParameter(hStmt, 2, SQL_PARAM_INPUT,
+        SQL_C_GUID, SQL_GUID, 16, 0, &guid, sizeof(guid), &guidInd);
+    ASSERT_TRUE(SQL_SUCCEEDED(ret)) << GetOdbcError(SQL_HANDLE_STMT, hStmt);
+
+    ret = SQLExecDirect(hStmt,
+        (SQLCHAR*)"INSERT INTO TEST_PB_GUID_VOCT (ID, VAL) VALUES (?, ?)", SQL_NTS);
+    ASSERT_TRUE(SQL_SUCCEEDED(ret)) << GetOdbcError(SQL_HANDLE_STMT, hStmt);
+    Commit();
+    ReallocStmt();
+
+    ExecDirect("SELECT UUID_TO_CHAR(VAL) FROM TEST_PB_GUID_VOCT WHERE ID = 1");
+    ret = SQLFetch(hStmt);
+    ASSERT_TRUE(SQL_SUCCEEDED(ret)) << GetOdbcError(SQL_HANDLE_STMT, hStmt);
+
+    SQLCHAR buf[64] = {};
+    SQLLEN ind = 0;
+    ret = SQLGetData(hStmt, 1, SQL_C_CHAR, buf, sizeof(buf), &ind);
+    ASSERT_TRUE(SQL_SUCCEEDED(ret));
+
+    std::string text((char*)buf);
+    while (!text.empty() && text.back() == ' ') text.pop_back();
+    EXPECT_EQ(text, kCanonicalText)
+        << "VARBINARY(16) (VARCHAR(16) OCTETS) GUID round-trip failed. "
+        << "Got: '" << text << "'";
+}
+
 // Test: DECFLOAT column insertion and retrieval on Firebird 4+
 TEST_F(Fb4PlusTest, DecfloatInsertAndRetrieve) {
     GTEST_SKIP() << "Requires Phase 8: SQL_GUID type mapping and FB4+ types (not yet merged)";