Mojo: validate nullability in Java serialization.

mojo/public/java/bindings/src/org/chromium/mojo/bindings/Encoder.java

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package org.chromium.mojo.bindings;
 
 import org.chromium.mojo.bindings.Struct.DataHeader;
 import org.chromium.mojo.system.Core;
 import org.chromium.mojo.system.Handle;
 import org.chromium.mojo.system.MessagePipeHandle;
@@ skipping 191 matching lines @@
     /**
      * Encode a double at the given offset.
      */
     public void encode(double v, int offset) {
         mEncoderState.byteBuffer.putDouble(mBaseOffset + offset, v);
     }
 
     /**
      * Encode a {@link Struct} at the given offset.
      */
-    public void encode(Struct v, int offset) {
+    public void encode(Struct v, int offset, boolean nullable) {
         if (v == null) {
-            encodeNullPointer(offset);
+            encodeNullPointer(offset, nullable);
             return;
         }
         encodePointerToNextUnclaimedData(offset);
         v.encode(this);
     }
 
     /**
      * Encodes a String.
      */
-    public void encode(String v, int offset) {
+    public void encode(String v, int offset, boolean nullable) {
         if (v == null) {
-            encodeNullPointer(offset);
+            encodeNullPointer(offset, nullable);
             return;
         }
-        encode(v.getBytes(
-                Charset.forName("utf8")), offset, BindingsHelper.UNSPECIFIED_ARRAY_LENGTH);
+        final int arrayNullability = nullable ? BindingsHelper.ARRAY_NULLABLE : 0;

[qsr, 2014/09/02 07:41:44]

You have a constant instead of this 0 in BindingsHelper, no?

[ppi, 2014/09/02 16:50:43]

Done.

+        encode(v.getBytes(Charset.forName("utf8")), offset, arrayNullability,
+                BindingsHelper.UNSPECIFIED_ARRAY_LENGTH);
     }
 
     /**
      * Encodes a {@link Handle}.
      */
-    public void encode(Handle v, int offset) {
+    public void encode(Handle v, int offset, boolean nullable) {
         if (v == null || !v.isValid()) {

[ppi, 2014/09/01 19:00:45]

What do we do if the field is not nullable, v != null and !v.isValid() ?

[qsr, 2014/09/02 07:41:44]

Non nullable for a handle means valid, so this case is an exception.

[ppi, 2014/09/02 16:50:43]

Acknowledged.

-            encode(-1, offset);
+            encodeInvalidHandle(offset, nullable);
         } else {
             encode(mEncoderState.handles.size(), offset);
             mEncoderState.handles.add(v);
         }
     }
 
     /**
      * Encode an {@link Interface}.
      */
-    public <T extends Interface> void encode(T v, int offset, Interface.Manager<T, ?> manager) {
+    public <T extends Interface> void encode(T v, int offset, boolean nullable,
+            Interface.Manager<T, ?> manager) {
         if (v == null) {
-            encode(-1, offset);
+            encodeInvalidHandle(offset, nullable);
             return;
         }
         if (mEncoderState.core == null) {
             throw new UnsupportedOperationException(
                     "The encoder has been created without a Core. It can't encode an interface.");
         }
         // If the instance is a proxy, pass the proxy's handle instead of creating a new stub.
         if (v instanceof Interface.AbstractProxy) {
             Interface.AbstractProxy proxy = (Interface.AbstractProxy) v;
             if (proxy.getMessageReceiver() instanceof HandleOwner) {
-                encode(((HandleOwner<?>) proxy.getMessageReceiver()).passHandle(), offset);
+                encode(((HandleOwner<?>) proxy.getMessageReceiver()).passHandle(), offset,
+                        nullable);
                 return;
             }
             // If the proxy is not over a message pipe, the default case applies.
         }
         Pair<MessagePipeHandle, MessagePipeHandle> handles =
                 mEncoderState.core.createMessagePipe(null);
         manager.bind(v, handles.first);
-        encode(handles.second, offset);
+        encode(handles.second, offset, nullable);
     }
 
     /**
      * Encode an {@link InterfaceRequest}.
      */
-    public <I extends Interface> void encode(InterfaceRequest<I> v, int offset) {
+    public <I extends Interface> void encode(InterfaceRequest<I> v, int offset, boolean nullable) {
         if (v == null) {
-            encode(-1, offset);
+            encodeInvalidHandle(offset, nullable);
             return;
         }
         if (mEncoderState.core == null) {
             throw new UnsupportedOperationException(
                     "The encoder has been created without a Core. It can't encode an interface.");
         }
-        encode(v.passHandle(), offset);
+        encode(v.passHandle(), offset, nullable);
     }
 
     /**
      * Returns an {@link Encoder} suitable for encoding an array of pointer of the given length.
      */
     public Encoder encodePointerArray(int length, int offset, int expectedLength) {
         return encoderForArray(BindingsHelper.POINTER_SIZE, length, offset, expectedLength);
     }
 
     /**
      * Encodes an array of booleans.
      */
-    public void encode(boolean[] v, int offset, int expectedLength) {
+    public void encode(boolean[] v, int offset, int arrayNullability, int expectedLength) {
         if (v == null) {
-            encodeNullPointer(offset);
+            encodeNullPointer(offset, BindingsHelper.isArrayNullable(arrayNullability));
             return;
         }
         if (expectedLength != BindingsHelper.UNSPECIFIED_ARRAY_LENGTH &&
                 expectedLength != v.length) {
             throw new SerializationException("Trying to encode a fixed array of incorrect length.");
         }
         byte[] bytes = new byte[(v.length + 7) / BindingsHelper.ALIGNMENT];
         for (int i = 0; i < bytes.length; ++i) {
             for (int j = 0; j < BindingsHelper.ALIGNMENT; ++j) {
                 int booleanIndex = BindingsHelper.ALIGNMENT * i + j;
                 if (booleanIndex < v.length && v[booleanIndex]) {
                     bytes[i] |= (1 << j);
                 }
             }
         }
         encodeByteArray(bytes, v.length, offset);
     }
 
     /**
      * Encodes an array of bytes.
      */
-    public void encode(byte[] v, int offset, int expectedLength) {
+    public void encode(byte[] v, int offset, int arrayNullability, int expectedLength) {
         if (v == null) {
-            encodeNullPointer(offset);
+            encodeNullPointer(offset, BindingsHelper.isArrayNullable(arrayNullability));
             return;
         }
         if (expectedLength != BindingsHelper.UNSPECIFIED_ARRAY_LENGTH &&
                 expectedLength != v.length) {
             throw new SerializationException("Trying to encode a fixed array of incorrect length.");
         }
         encodeByteArray(v, v.length, offset);
     }
 
     /**
      * Encodes an array of shorts.
      */
-    public void encode(short[] v, int offset, int expectedLength) {
+    public void encode(short[] v, int offset, int arrayNullability, int expectedLength) {
         if (v == null) {
-            encodeNullPointer(offset);
+            encodeNullPointer(offset, BindingsHelper.isArrayNullable(arrayNullability));
             return;
         }
         encoderForArray(2, v.length, offset, expectedLength).append(v);
     }
 
     /**
      * Encodes an array of ints.
      */
-    public void encode(int[] v, int offset, int expectedLength) {
+    public void encode(int[] v, int offset, int arrayNullability, int expectedLength) {
         if (v == null) {
-            encodeNullPointer(offset);
+            encodeNullPointer(offset, BindingsHelper.isArrayNullable(arrayNullability));
             return;
         }
         encoderForArray(4, v.length, offset, expectedLength).append(v);
     }
 
     /**
      * Encodes an array of floats.
      */
-    public void encode(float[] v, int offset, int expectedLength) {
+    public void encode(float[] v, int offset, int arrayNullability, int expectedLength) {
         if (v == null) {
-            encodeNullPointer(offset);
+            encodeNullPointer(offset, BindingsHelper.isArrayNullable(arrayNullability));
             return;
         }
         encoderForArray(4, v.length, offset, expectedLength).append(v);
     }
 
     /**
      * Encodes an array of longs.
      */
-    public void encode(long[] v, int offset, int expectedLength) {
+    public void encode(long[] v, int offset, int arrayNullability, int expectedLength) {
         if (v == null) {
-            encodeNullPointer(offset);
+            encodeNullPointer(offset, BindingsHelper.isArrayNullable(arrayNullability));
             return;
         }
         encoderForArray(8, v.length, offset, expectedLength).append(v);
     }
 
     /**
      * Encodes an array of doubles.
      */
-    public void encode(double[] v, int offset, int expectedLength) {
+    public void encode(double[] v, int offset, int arrayNullability, int expectedLength) {
         if (v == null) {
-            encodeNullPointer(offset);
+            encodeNullPointer(offset, BindingsHelper.isArrayNullable(arrayNullability));
             return;
         }
         encoderForArray(8, v.length, offset, expectedLength).append(v);
     }
 
     /**
      * Encodes an array of {@link Handle}.
      */
-    public void encode(Handle[] v, int offset, int expectedLength) {
+    public void encode(Handle[] v, int offset, int arrayNullability, int expectedLength) {
         if (v == null) {
-            encodeNullPointer(offset);
+            encodeNullPointer(offset, BindingsHelper.isArrayNullable(arrayNullability));
             return;
         }
         Encoder e = encoderForArray(
                 BindingsHelper.SERIALIZED_HANDLE_SIZE, v.length, offset, expectedLength);
         for (int i = 0; i < v.length; ++i) {
-            e.encode(v[i], DataHeader.HEADER_SIZE + BindingsHelper.SERIALIZED_HANDLE_SIZE * i);
+            e.encode(v[i], DataHeader.HEADER_SIZE + BindingsHelper.SERIALIZED_HANDLE_SIZE * i,
+                    BindingsHelper.isElementNullable(arrayNullability));
         }
     }
 
     /**
      * Encodes an array of {@link Interface}.
      */
-    public <T extends Interface> void encode(T[] v, int offset, int expectedLength,
-            Interface.Manager<T, ?> manager) {
+    public <T extends Interface> void encode(T[] v, int offset, int arrayNullability,
+            int expectedLength, Interface.Manager<T, ?> manager) {
         if (v == null) {
-            encodeNullPointer(offset);
+            encodeNullPointer(offset, BindingsHelper.isArrayNullable(arrayNullability));
             return;
         }
         Encoder e = encoderForArray(
                 BindingsHelper.SERIALIZED_HANDLE_SIZE, v.length, offset, expectedLength);
         for (int i = 0; i < v.length; ++i) {
             e.encode(v[i], DataHeader.HEADER_SIZE + BindingsHelper.SERIALIZED_HANDLE_SIZE * i,
-                    manager);
+                    BindingsHelper.isElementNullable(arrayNullability), manager);
         }
     }
 
     /**
      * Encodes an array of {@link InterfaceRequest}.
      */
     public <I extends Interface> void encode(InterfaceRequest<I>[] v, int offset,
-            int expectedLength) {
+            int arrayNullability, int expectedLength) {
         if (v == null) {
-            encodeNullPointer(offset);
+            encodeNullPointer(offset, BindingsHelper.isArrayNullable(arrayNullability));
             return;
         }
         Encoder e = encoderForArray(
                 BindingsHelper.SERIALIZED_HANDLE_SIZE, v.length, offset, expectedLength);
         for (int i = 0; i < v.length; ++i) {
-            e.encode(v[i], DataHeader.HEADER_SIZE + BindingsHelper.SERIALIZED_HANDLE_SIZE * i);
+            e.encode(v[i], DataHeader.HEADER_SIZE + BindingsHelper.SERIALIZED_HANDLE_SIZE * i,
+                    BindingsHelper.isElementNullable(arrayNullability));
         }
     }
 
     /**
-     * Encode a <code>null</code> pointer.
+     * Encodes a <code>null</code> pointer iff the object is nullable, raises an exception
+     * otherwise.
      */
-    public void encodeNullPointer(int offset) {
+    public void encodeNullPointer(int offset, boolean nullable) {
+        if (!nullable) {
+            throw new SerializationException(
+                    "Trying to encode a null pointer for a non-nullable type.");
+        }
         mEncoderState.byteBuffer.putLong(mBaseOffset + offset, 0);
     }
 
+    /**
+     * Encodes an invalid handle iff the object is nullable, raises an exception otherwise.
+     */
+    public void encodeInvalidHandle(int offset, boolean nullable) {
+        if (!nullable) {
+            throw new SerializationException(
+                    "Trying to encode an invalid handle for a non-nullable type.");
+        }
+        mEncoderState.byteBuffer.putInt(mBaseOffset + offset, -1);
+    }
+
     private void encodePointerToNextUnclaimedData(int offset) {
         encode((long) mEncoderState.dataEnd - (mBaseOffset + offset), offset);
     }
 
     private Encoder encoderForArray(
             int elementSizeInByte, int length, int offset, int expectedLength) {
         if (expectedLength != BindingsHelper.UNSPECIFIED_ARRAY_LENGTH &&
                 expectedLength != length) {
             throw new SerializationException("Trying to encode a fixed array of incorrect length.");
         }
@@ skipping 34 matching lines @@
         mEncoderState.byteBuffer.position(mBaseOffset + DataHeader.HEADER_SIZE);
         mEncoderState.byteBuffer.asDoubleBuffer().put(v);
     }
 
     private void append(long[] v) {
         mEncoderState.byteBuffer.position(mBaseOffset + DataHeader.HEADER_SIZE);
         mEncoderState.byteBuffer.asLongBuffer().put(v);
     }
 
 }