#926 Fix using native client, password is limited to 255 bytes

(backport of #925)

Author: mrotteveel

src/docs/asciidoc/release_notes.adoc

@@ -53,6 +53,7 @@ This results in two minor breaking changes:
 ** Presence of the NUL character (U+0000) in an identifier passed to `enquoteIdentifier` will result in a `SQLSyntaxErrorException`
 * Fixed: JDBC escapes should not be parsed inside dialect 3 delimited identifiers or dialect 1 string literals (https://github.com/FirebirdSQL/jaybird/issues/922[#922])
 * Fixed: `IndexOutOfBoundsException` in `FBCachedBlob.getBytes(long, int)` for position or length beyond end of data (https://github.com/FirebirdSQL/jaybird/issues/924[#924])
+* Fixed: Using native client, password is limited to 255 bytes (https://github.com/FirebirdSQL/jaybird/issues/926[#926])
 
 [#jaybird-5-0-11-changelog]
 === Jaybird 5.0.11

src/main/org/firebirdsql/gds/impl/DatabaseParameterBufferImp.java

@@ -50,7 +50,17 @@ public ParameterTagMapping getTagMapping() {
     }
 
     public enum DpbMetaData implements ParameterBufferMetaData {
-        DPB_VERSION_1(ISCConstants.isc_dpb_version1, ArgumentType.TraditionalDpb),
+        DPB_VERSION_1(ISCConstants.isc_dpb_version1, ArgumentType.TraditionalDpb) {
+            @Override
+            public boolean isUpgradable() {
+                return true;
+            }
+
+            @Override
+            public ParameterBufferMetaData upgradeMetaData() {
+                return DPB_VERSION_2;
+            }
+        },
         DPB_VERSION_2(ISCConstants.isc_dpb_version2, ArgumentType.Wide);
 
         private final int dpbVersion;

src/main/org/firebirdsql/gds/impl/ParameterBufferBase.java

@@ -34,6 +34,8 @@
 import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
 
 /**
  * Base class for parameter buffers
@@ -45,7 +47,7 @@ public abstract class ParameterBufferBase implements ParameterBuffer, Serializab
     private final List<Argument> arguments = new ArrayList<>();
 
     private final String defaultEncodingName;
-    private final ParameterBufferMetaData parameterBufferMetaData;
+    private ParameterBufferMetaData parameterBufferMetaData;
     private transient Encoding defaultEncoding;
 
     /**
@@ -94,7 +96,21 @@ public final void addArgument(int argumentType, String value) {
 
     @Override
     public final void addArgument(int argumentType, String value, Encoding encoding) {
-        getArgumentsList().add(new StringArgument(argumentType, parameterBufferMetaData.getStringArgumentType(argumentType), value, encoding));
+        getArgumentsList().add(createStringArgument(argumentType, value, encoding));
+    }
+
+    private StringArgument createStringArgument(int argumentType, String value, Encoding encoding) {
+        try {
+            return new StringArgument(
+                    argumentType, parameterBufferMetaData.getStringArgumentType(argumentType), value, encoding);
+        } catch (LengthOverflowException e) {
+            if (tryUpgradeMetaData()) {
+                // Do not inline parameterBufferMetaData or argument type; they might be different here than in the try
+                return new StringArgument(
+                        argumentType, parameterBufferMetaData.getStringArgumentType(argumentType), value, encoding);
+            }
+            throw e;
+        }
     }
 
     @Override
@@ -119,7 +135,19 @@ public final void addArgument(int argumentType) {
 
     @Override
     public final void addArgument(int type, byte[] content) {
-        getArgumentsList().add(new ByteArrayArgument(type, parameterBufferMetaData.getByteArrayArgumentType(type), content));
+        getArgumentsList().add(createByteArrayArgument(type, content));
+    }
+
+    private ByteArrayArgument createByteArrayArgument(int type, byte[] content) {
+        try {
+            return new ByteArrayArgument(type, parameterBufferMetaData.getByteArrayArgumentType(type), content);
+        } catch (LengthOverflowException e) {
+            if (tryUpgradeMetaData()) {
+                // Do not inline parameterBufferMetaData or argument type; they might be different here than in the try
+                return new ByteArrayArgument(type, parameterBufferMetaData.getByteArrayArgumentType(type), content);
+            }
+            throw e;
+        }
     }
 
     @Override
@@ -153,6 +181,10 @@ public final boolean hasArgument(int type) {
         return false;
     }
 
+    protected Optional<Argument> findFirst(int type) {
+        return arguments.stream().filter(argument -> argument.getType() == type).findFirst();
+    }
+
     @Override
     public final void removeArgument(int type) {
         final List<Argument> argumentsList = getArgumentsList();
@@ -227,6 +259,22 @@ public final boolean isEmpty() {
         return arguments.isEmpty();
     }
 
+    private boolean tryUpgradeMetaData() {
+        if (!parameterBufferMetaData.isUpgradable()) return false;
+        try {
+            ParameterBufferMetaData newParameterBufferMetaData = parameterBufferMetaData.upgradeMetaData();
+            List<Argument> newArguments = arguments.stream()
+                    .map(argument -> argument.transformTo(newParameterBufferMetaData))
+                    .collect(Collectors.toList());
+            arguments.clear();
+            arguments.addAll(newArguments);
+            parameterBufferMetaData = newParameterBufferMetaData;
+            return true;
+        } catch (IllegalArgumentException e) {
+            return false;
+        }
+    }
+
     @Override
     public final boolean equals(Object other) {
         if (other == null || !(this.getClass().isAssignableFrom(other.getClass())))

src/main/org/firebirdsql/gds/impl/ParameterBufferMetaData.java

@@ -106,4 +106,31 @@ default ArgumentType getByteArgumentType(int tag) {
         return getIntegerArgumentType(tag);
     }
 
+    /**
+     * Returns if this metadata type is upgradable.
+     * <p>
+     * The default implementation always returns {@code false}.
+     * </p>
+     *
+     * @return {@code true} if this type is upgradable
+     * @see #upgradeMetaData()
+     * @since 5.0.12
+     */
+    default boolean isUpgradable() {
+        return false;
+    }
+
+    /**
+     * The parameter buffer metadata that can be upgraded to.
+     * <p>
+     * The default implementation always returns {@code this}.
+     * </p>
+     *
+     * @return the upgrade buffer metadata, returns this instance if {@link #isUpgradable()} returns {@code false}
+     * @since 5.0.12
+     */
+    default ParameterBufferMetaData upgradeMetaData() {
+        return this;
+    }
+
 }

src/main/org/firebirdsql/gds/impl/ServiceParameterBufferImp.java

@@ -74,6 +74,16 @@ public ArgumentType getSingleArgumentType(int tag) {
                 }
                 return ArgumentType.TraditionalDpb;
             }
+
+            @Override
+            public boolean isUpgradable() {
+                return true;
+            }
+
+            @Override
+            public ParameterBufferMetaData upgradeMetaData() {
+                return SPB_VERSION_3_ATTACH;
+            }
         },
         // Technically this has nothing to do with SPB version 2/3
         SPB_VERSION_2(ISCConstants.isc_spb_current_version) {

src/main/org/firebirdsql/gds/impl/argument/Argument.java

@@ -19,6 +19,7 @@
 package org.firebirdsql.gds.impl.argument;
 
 import org.firebirdsql.gds.Parameter;
+import org.firebirdsql.gds.impl.ParameterBufferMetaData;
 
 import java.io.IOException;
 import java.io.OutputStream;
@@ -85,4 +86,17 @@ public long getValueAsLong() {
      */
     public abstract int getLength();
 
+    /**
+     * If needed, returns a new argument to transform to a suitable argument type, otherwise returns this instance.
+     *
+     * @param parameterBufferMetaData
+     *         parameter buffer metadata (used to determine the needed argument type)
+     * @return either a new argument if transformation is needed, or this instance
+     * @throws IllegalArgumentException
+     *         if transformation is needed, but the creation of the new instance fails (e.g. downgrading from
+     *         {@link ArgumentType#Wide} to {@link ArgumentType#TraditionalDpb}, and the value is too long)
+     * @since 5.0.12
+     */
+    public abstract Argument transformTo(ParameterBufferMetaData parameterBufferMetaData);
+
 }

src/main/org/firebirdsql/gds/impl/argument/BigIntArgument.java

@@ -21,6 +21,7 @@
 import org.firebirdsql.encodings.Encoding;
 import org.firebirdsql.gds.ParameterBuffer;
 import org.firebirdsql.gds.VaxEncoding;
+import org.firebirdsql.gds.impl.ParameterBufferMetaData;
 
 import java.io.IOException;
 import java.io.OutputStream;
@@ -81,6 +82,13 @@ public void copyTo(ParameterBuffer buffer, Encoding encoding) {
         buffer.addArgument(getType(), value);
     }
 
+    @Override
+    public BigIntArgument transformTo(ParameterBufferMetaData parameterBufferMetaData) {
+        ArgumentType newArgumentType = parameterBufferMetaData.getIntegerArgumentType(getType());
+        if (newArgumentType == argumentType) return this;
+        return new BigIntArgument(getType(), newArgumentType, value);
+    }
+
     @Override
     public boolean equals(Object other) {
         if (!(other instanceof BigIntArgument)) {

src/main/org/firebirdsql/gds/impl/argument/ByteArgument.java

@@ -20,6 +20,7 @@
 
 import org.firebirdsql.encodings.Encoding;
 import org.firebirdsql.gds.ParameterBuffer;
+import org.firebirdsql.gds.impl.ParameterBufferMetaData;
 
 import java.io.IOException;
 import java.io.OutputStream;
@@ -76,6 +77,13 @@ public void copyTo(ParameterBuffer buffer, Encoding encoding) {
         buffer.addArgument(getType(), value);
     }
 
+    @Override
+    public ByteArgument transformTo(ParameterBufferMetaData parameterBufferMetaData) {
+        ArgumentType newArgumentType = parameterBufferMetaData.getByteArgumentType(getType());
+        if (newArgumentType == argumentType) return this;
+        return new ByteArgument(getType(), newArgumentType, value);
+    }
+
     @Override
     public boolean equals(Object other) {
         if (!(other instanceof ByteArgument)) {

src/main/org/firebirdsql/gds/impl/argument/ByteArrayArgument.java

@@ -20,6 +20,7 @@
 
 import org.firebirdsql.encodings.Encoding;
 import org.firebirdsql.gds.ParameterBuffer;
+import org.firebirdsql.gds.impl.ParameterBufferMetaData;
 
 import java.io.IOException;
 import java.io.OutputStream;
@@ -38,12 +39,18 @@ public final class ByteArrayArgument extends TypedArgument {
     private final byte[] value;
 
     /**
-     * Initializes an instance of ByteArrayArgument.
+     * Initialises an instance of ByteArrayArgument.
      *
      * @param type
-     *        Parameter type
+     *         parameter type
+     * @param argumentType
+     *         argument type
      * @param value
-     *        Byte array with a maximum length defined by {@code argumentType}.
+     *         byte array
+     * @throws IllegalArgumentException
+     *         if {@code type} is not valid for byte arrays, or if {@code value} is {@code null}
+     * @throws LengthOverflowException
+     *         if the length of {@code value} exceeds {@link ArgumentType#getMaxLength()}
      */
     public ByteArrayArgument(int type, ArgumentType argumentType, byte[] value) {
         super(type, argumentType);
@@ -56,7 +63,7 @@ public ByteArrayArgument(int type, ArgumentType argumentType, byte[] value) {
             throw new IllegalArgumentException("byte array value should not be null");
         }
         if (value.length > argumentType.getMaxLength()) {
-            throw new IllegalArgumentException(
+            throw new LengthOverflowException(
                     String.format("byte array value should not be longer than %d bytes, length was %d",
                             argumentType.getMaxLength(), value.length));
         }
@@ -84,11 +91,23 @@ public int getValueAsInt() {
         }
     }
 
+    // primarily intended for testing purposes
+    public byte[] getValueAsBytes() {
+        return value.clone();
+    }
+
     @Override
     public void copyTo(ParameterBuffer buffer, Encoding encoding) {
         buffer.addArgument(getType(), value.clone());
     }
 
+    @Override
+    public ByteArrayArgument transformTo(ParameterBufferMetaData parameterBufferMetaData) {
+        ArgumentType newArgumentType = parameterBufferMetaData.getByteArrayArgumentType(getType());
+        if (newArgumentType == argumentType) return this;
+        return new ByteArrayArgument(getType(), newArgumentType, value);
+    }
+
     @Override
     public boolean equals(Object other) {
         if (!(other instanceof ByteArrayArgument)) {

src/main/org/firebirdsql/gds/impl/argument/LengthOverflowException.java

@@ -0,0 +1,19 @@
+// SPDX-FileCopyrightText: Copyright 2026 Mark Rotteveel
+// SPDX-License-Identifier: LGPL-2.1-or-later
+package org.firebirdsql.gds.impl.argument;
+
+/**
+ * Thrown by {@link StringArgument} and {@link ByteArrayArgument} if a value's length exceeds that of their
+ * {@link ArgumentType}.
+ *
+ * @since 5.0.12
+ */
+public class LengthOverflowException extends IllegalArgumentException {
+
+    private static final long serialVersionUID = 5735116134576091931L;
+
+    LengthOverflowException(String message) {
+        super(message);
+    }
+
+}