grpc/service_config: Handle deserialization edge cases (#2899)

## Motivation

There are a couple of cases where the expected behavior doesn't match
the actual behavior:

### GrpcDuration (The "timeout" field)
| Input | Expected per Protobuf JSON spec | Actual (current) result |
| :--- | :--- | :--- |
| `"+1s"` | `Err` (leading `+` is not valid) | `Ok(1s)` |
| `"1.+5s"` | `Err` (`+` is not valid in fractional seconds) |
`Ok(1.05s)` |
| `"315576000001s"` | `Err` (exceeds Protobuf max of `315_576_000_000s`)
| `Ok(315576000001s)` |

### SerdeU32 (e.g. "maxRequestMessageBytes" field)
| Input | Expected per Protobuf JSON spec  | Actual (current) result  |
| :--- | :--- | :--- |
| `"+5"` | `Err` (leading `+` is not valid in a `uint32` string) |
`Ok(5)` |
| `1024.0` | `Ok(1024)` (integer-valued floats for int fields allowed) |
`Err("invalid type: floating point \`1024.0\`...")` |
| `1e3` | `Ok(1000)` (exp. notation for int fields allowed) |
`Err("invalid type: floating point \`1000.0\`...")` |

<!--
Explain the context and why you're making that change. What is the
problem
you're trying to solve? If a new feature is being added, describe the
intended
use case that feature fulfills.
-->

## Solution

Small fixes to the parsing, update the test cases to cover this.

Author: nathanielford

grpc/src/client/service_config/duration.rs

@@ -65,11 +65,13 @@ impl<'de> Deserialize<'de> for GrpcDuration {
     }
 }
 
+const MAX_DURATION_SECONDS: u64 = 315_576_000_000;
+
 // Parsing logic, isolated for testing and to reduce serde monomorphization
 // footprint.
 fn parse_duration(s: &str) -> Result<Duration, String> {
-    if !s.ends_with('s') {
-        return Err("duration string must end with 's'".to_string());
+    if !s.ends_with('s') || s.contains('+') {
+        return Err("invalid duration string".to_string());
     }
     let s = &s[..s.len() - 1]; // strip 's'.
     let mut parts = s.splitn(2, '.');
@@ -79,6 +81,9 @@ fn parse_duration(s: &str) -> Result<Duration, String> {
     let secs: u64 = secs_str
         .parse()
         .map_err(|e| format!("failed to parse seconds: {e}"))?;
+    if secs > MAX_DURATION_SECONDS {
+        return Err(format!("duration exceeds max of {MAX_DURATION_SECONDS}s"));
+    }
 
     let nanos = if let Some(fraction_str) = parts.next() {
         if fraction_str.is_empty() {
@@ -109,6 +114,10 @@ mod test {
     fn test_parse_duration() {
         assert_eq!(parse_duration("1s").unwrap(), Duration::from_secs(1));
         assert_eq!(parse_duration("0s").unwrap(), Duration::from_secs(0));
+        assert_eq!(
+            parse_duration("315576000000s").unwrap(),
+            Duration::from_secs(315_576_000_000)
+        );
         assert_eq!(
             parse_duration("1.5s").unwrap(),
             Duration::new(1, 500_000_000)
@@ -126,6 +135,9 @@ mod test {
         assert!(parse_duration("1.0000000001s").is_err());
         assert!(parse_duration("as").is_err());
         assert!(parse_duration(".5s").is_err());
+        assert!(parse_duration("+1s").is_err());
+        assert!(parse_duration("1.+5s").is_err());
+        assert!(parse_duration("315576000001s").is_err());
     }
 
     #[test]

grpc/src/client/service_config/serde_bindings.rs

@@ -205,10 +205,25 @@ impl<'de> Deserialize<'de> for SerdeU32 {
                 v.try_into().map(SerdeU32).map_err(serde::de::Error::custom)
             }
 
+            #[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
+            fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                if v.is_sign_positive() && v.fract() == 0.0 && v <= f64::from(u32::MAX) {
+                    Ok(SerdeU32(v as u32))
+                } else {
+                    Err(E::custom(format!("invalid u32 value: {v}")))
+                }
+            }
+
             fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
             where
                 E: serde::de::Error,
             {
+                if v.starts_with('+') {
+                    return Err(E::custom("leading '+' is not allowed"));
+                }
                 v.parse().map(SerdeU32).map_err(serde::de::Error::custom)
             }
         }
@@ -315,11 +330,26 @@ mod test {
         let val: TestStruct = serde_json::from_value(json!({})).unwrap();
         assert_eq!(val.val, None);
 
+        let val: TestStruct = serde_json::from_value(json!({ "val": 1024.0 })).unwrap();
+        assert_eq!(val.val, Some(SerdeU32(1024)));
+
+        let val: TestStruct = serde_json::from_str(r#"{"val": 1e3}"#).unwrap();
+        assert_eq!(val.val, Some(SerdeU32(1000)));
+
         let res: Result<TestStruct, _> = serde_json::from_value(json!({ "val": "invalid" }));
         assert!(res.is_err());
 
+        let res: Result<TestStruct, _> = serde_json::from_value(json!({ "val": "+5" }));
+        assert!(res.is_err());
+
+        let res: Result<TestStruct, _> = serde_json::from_value(json!({ "val": 1.5 }));
+        assert!(res.is_err());
+
         let res: Result<TestStruct, _> = serde_json::from_value(json!({ "val": -1 }));
         assert!(res.is_err());
+
+        let res: Result<TestStruct, _> = serde_json::from_str(r#"{"val": -0}"#);
+        assert!(res.is_err());
     }
 
     #[test]