fix: return erring response if lightpush request is invalid (#2083)

fixes #1641

tests/test_waku_lightpush.nim

@@ -1,6 +1,8 @@
 {.used.}
 
 import
+  std/options,
+  std/strscans,
   testutils/unittests,
   chronicles,
   chronos,
@@ -10,10 +12,11 @@ import
   ../../waku/waku_core,
   ../../waku/waku_lightpush,
   ../../waku/waku_lightpush/client,
+  ../../waku/waku_lightpush/protocol_metrics,
+  ../../waku/waku_lightpush/rpc,
   ./testlib/common,
   ./testlib/wakucore
 
-
 proc newTestWakuLightpushNode(switch: Switch, handler: PushMessageHandler): Future[WakuLightPush] {.async.} =
   let
     peerManager = PeerManager.new(switch)
@@ -115,4 +118,36 @@ suite "Waku Lightpush":
       requestError == error
 
     ## Cleanup
-    await allFutures(clientSwitch.stop(), serverSwitch.stop())
+    await allFutures(clientSwitch.stop(), serverSwitch.stop())
+
+  asyncTest "incorrectly encoded request should return an erring response":
+    ## Setup
+    let
+      serverSwitch = newTestSwitch()
+      handler = proc(peer: PeerId, pubsubTopic: PubsubTopic, message: WakuMessage): Future[WakuLightPushResult[void]] {.async.} =
+        ## this handler will never be called: request must fail earlier
+        return ok()
+      server = await newTestWakuLightpushNode(serverSwitch, handler)
+
+    ## Given
+    let
+      fakeBuffer = @[byte(42)]
+      fakePeerId = PeerId.init(PrivateKey.random(ECDSA, (newRng())[]).tryGet()).tryGet()
+    
+    ## When
+    let
+      pushRpcResponse = await server.handleRequest(fakePeerId, fakeBuffer)
+      requestId = pushRpcResponse.requestId
+    
+    ## Then
+    check:
+      requestId == ""
+      pushRpcResponse.response.isSome()
+    
+    let resp = pushRpcResponse.response.get()
+
+    check:
+      resp.isSuccess == false
+      resp.info.isSome()
+      ## the error message should start with decodeRpcFailure
+      scanf(resp.info.get(), decodeRpcFailure)

waku/waku_lightpush/protocol.nim

@@ -35,47 +35,46 @@ type
     peerManager*: PeerManager
     pushHandler*: PushMessageHandler
 
-proc initProtocolHandler*(wl: WakuLightPush) =
+proc handleRequest*(wl: WakuLightPush, peerId: PeerId, buffer: seq[byte]): Future[PushRPC] {.async.} = 
-  proc handle(conn: Connection, proto: string) {.async, gcsafe, closure.} =
+  let reqDecodeRes = PushRPC.decode(buffer)
-    let buffer = await conn.readLp(MaxRpcSize.int)
+  var
-    let reqDecodeRes = PushRPC.decode(buffer)
+      isSuccess = false
-    if reqDecodeRes.isErr():
+      pushResponseInfo = ""
-      error "failed to decode rpc"
+      requestId = ""
-      waku_lightpush_errors.inc(labelValues = [decodeRpcFailure])
-      return
 
-    let req = reqDecodeRes.get()
+  if reqDecodeRes.isErr():
-    if req.request.isNone():
+    pushResponseInfo = decodeRpcFailure & ": " & $reqDecodeRes.error
-      error "invalid lightpush rpc received", error=emptyRequestBodyFailure
+  elif reqDecodeRes.get().request.isNone():
-      waku_lightpush_errors.inc(labelValues = [emptyRequestBodyFailure])
+    pushResponseInfo = emptyRequestBodyFailure
-      return
+  else:
+    let pushRpcRequest = reqDecodeRes.get();
+
+    requestId = pushRpcRequest.requestId
 
-    waku_lightpush_messages.inc(labelValues = ["PushRequest"])
     let
-      pubSubTopic = req.request.get().pubSubTopic
+      request = pushRpcRequest.request
-      message = req.request.get().message
-    debug "push request", peerId=conn.peerId, requestId=req.requestId, pubsubTopic=pubsubTopic
 
-    var response: PushResponse
+      pubSubTopic = request.get().pubSubTopic
-    var handleRes: WakuLightPushResult[void]
+      message = request.get().message
-    try:
+    waku_lightpush_messages.inc(labelValues = ["PushRequest"])
-      handleRes = await wl.pushHandler(conn.peerId, pubsubTopic, message)
+    debug "push request", peerId=peerId, requestId=requestId, pubsubTopic=pubsubTopic
-    except Exception:
+    
-      response = PushResponse(is_success: false, info: some(getCurrentExceptionMsg()))
+    let handleRes = await wl.pushHandler(peerId, pubsubTopic, message)
-      waku_lightpush_errors.inc(labelValues = [messagePushFailure])
+    isSuccess = handleRes.isOk()
-      error "pushed message handling failed", error= getCurrentExceptionMsg()
+    pushResponseInfo = (if isSuccess: "OK" else: handleRes.error)
 
+  if not isSuccess:
+    waku_lightpush_errors.inc(labelValues = [pushResponseInfo])
+    error "failed to push message", error=pushResponseInfo
+  let response = PushResponse(isSuccess: isSuccess, info: some(pushResponseInfo))
+  let rpc = PushRPC(requestId: requestId, response: some(response))
+  return rpc
 
-    if handleRes.isOk():
+proc initProtocolHandler*(wl: WakuLightPush) =
-      response = PushResponse(is_success: true, info: some("OK"))
+  proc handle(conn: Connection, proto: string) {.async.} =
-    else:
+    let buffer = await conn.readLp(MaxRpcSize.int)
-      response = PushResponse(is_success: false, info: some(handleRes.error))
+    let rpc = await handleRequest(wl, conn.peerId, buffer)
-      waku_lightpush_errors.inc(labelValues = [messagePushFailure])
-      error "pushed message handling failed", error=handleRes.error
-
-    let rpc = PushRPC(requestId: req.requestId, response: some(response))
     await conn.writeLp(rpc.encode().buffer)
-
   wl.handler = handle
   wl.codec = WakuLightPushCodec