This is an automated email from the ASF dual-hosted git repository.

xiaoxiang781216 pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/nuttx.git

commit 6f5f7f4ab013c79f36a737d02876dc23fe9d3f29
Author: wangmingrong1 <[email protected]>
AuthorDate: Mon Nov 2 19:00:14 2026 +0800

    arch: check the allocation result before use
    
    sim_deviceimage, nrf52/nrf53 usbd and sam_adc used a possibly NULL
    buffer.
    
    Signed-off-by: wangmingrong1 <[email protected]>
---
 arch/arm/src/nrf52/nrf52_usbd.c    |   4 +
 arch/arm/src/nrf53/nrf53_usbd.c    | 412 +++++++++++++++++++------------------
 arch/arm/src/samd2l2/sam_adc.c     |  13 ++
 arch/sim/src/sim/sim_deviceimage.c |  17 +-
 4 files changed, 239 insertions(+), 207 deletions(-)

diff --git a/arch/arm/src/nrf52/nrf52_usbd.c b/arch/arm/src/nrf52/nrf52_usbd.c
index 7f1c203cd78..8fa8ef35a33 100644
--- a/arch/arm/src/nrf52/nrf52_usbd.c
+++ b/arch/arm/src/nrf52/nrf52_usbd.c
@@ -2259,6 +2259,10 @@ static int nrf52_epout_configure(struct nrf52_ep_s 
*privep, uint8_t eptype,
   /* Allocate buffer for EPOUT */
 
   privep->rxbuff = kmm_malloc(maxpacket);
+  if (privep->rxbuff == NULL)
+    {
+      return -ENOMEM;
+    }
 
   /* Enable the interrupt for this endpoint */
 
diff --git a/arch/arm/src/nrf53/nrf53_usbd.c b/arch/arm/src/nrf53/nrf53_usbd.c
index b4b99d00990..ecc956c45b7 100644
--- a/arch/arm/src/nrf53/nrf53_usbd.c
+++ b/arch/arm/src/nrf53/nrf53_usbd.c
@@ -718,241 +718,245 @@ nrf53_ep0out_stdrequest(struct nrf53_usbdev_s *priv,
 
   switch (ctrlreq->req)
     {
-    case USB_REQ_GETSTATUS:
-      {
-        /* type:  device-to-host; recipient = device, interface, endpoint
-         * value: 0
-         * index: zero interface endpoint
-         * len:   2; data = status
-         */
+      case USB_REQ_GETSTATUS:
+        {
+          /* type:  device-to-host; recipient = device, interface, endpoint
+           * value: 0
+           * index: zero interface endpoint
+           * len:   2; data = status
+           */
 
-        usbtrace(TRACE_INTDECODE(NRF53_TRACEINTID_GETSTATUS), 0);
-        if (!priv->addressed || ctrlreq->len != 2 ||
-            USB_REQ_ISOUT(ctrlreq->type) || ctrlreq->value != 0)
-          {
-            priv->stalled = true;
-          }
-        else
-          {
-            switch (ctrlreq->type & USB_REQ_RECIPIENT_MASK)
-              {
-              case USB_REQ_RECIPIENT_ENDPOINT:
+          usbtrace(TRACE_INTDECODE(NRF53_TRACEINTID_GETSTATUS), 0);
+          if (!priv->addressed || ctrlreq->len != 2 ||
+              USB_REQ_ISOUT(ctrlreq->type) || ctrlreq->value != 0)
+            {
+              priv->stalled = true;
+            }
+          else
+            {
+              switch (ctrlreq->type & USB_REQ_RECIPIENT_MASK)
                 {
-                  usbtrace(TRACE_INTDECODE(NRF53_TRACEINTID_EPGETSTATUS), 0);
-                  privep = nrf53_ep_findbyaddr(priv, ctrlreq->index);
-                  if (!privep)
+                  case USB_REQ_RECIPIENT_ENDPOINT:
                     {
-                      usbtrace(
-                        TRACE_DEVERROR(NRF53_TRACEERR_BADEPGETSTATUS), 0);
-                      priv->stalled = true;
+                      usbtrace(TRACE_INTDECODE(
+                                 NRF53_TRACEINTID_EPGETSTATUS), 0);
+                      privep = nrf53_ep_findbyaddr(priv, ctrlreq->index);
+                      if (!privep)
+                        {
+                          usbtrace(TRACE_DEVERROR(
+                                     NRF53_TRACEERR_BADEPGETSTATUS), 0);
+                          priv->stalled = true;
+                        }
+                      break;
                     }
-                  break;
-                }
 
-              case USB_REQ_RECIPIENT_DEVICE:
-              case USB_REQ_RECIPIENT_INTERFACE:
-                {
-                  if (ctrlreq->index == 0)
+                  case USB_REQ_RECIPIENT_DEVICE:
+                  case USB_REQ_RECIPIENT_INTERFACE:
                     {
-                      usbtrace(TRACE_INTDECODE(
-                                 NRF53_TRACEINTID_DEVGETSTATUS), 0);
+                      if (ctrlreq->index == 0)
+                        {
+                          usbtrace(TRACE_INTDECODE(
+                                     NRF53_TRACEINTID_DEVGETSTATUS), 0);
+                        }
+                      else
+                        {
+                          usbtrace(TRACE_DEVERROR(
+                                   NRF53_TRACEERR_BADDEVGETSTATUS), 0);
+                          priv->stalled = true;
+                        }
+                      break;
                     }
-                  else
+
+                  default:
                     {
                       usbtrace(TRACE_DEVERROR(
-                               NRF53_TRACEERR_BADDEVGETSTATUS), 0);
+                                 NRF53_TRACEERR_BADGETSTATUS), 0);
                       priv->stalled = true;
+                      break;
                     }
-                  break;
                 }
+            }
+          break;
+        }
 
-              default:
+      case USB_REQ_CLEARFEATURE:
+        {
+          /* type:  host-to-device; recipient = device, interface or endpoint
+           * value: feature selector
+           * index: zero interface endpoint;
+           * len:   zero, data = none
+           */
+
+          usbtrace(TRACE_INTDECODE(NRF53_TRACEINTID_CLEARFEATURE), 0);
+          if (priv->addressed != 0 && ctrlreq->len == 0)
+            {
+              recipient = ctrlreq->type & USB_REQ_RECIPIENT_MASK;
+              if (recipient == USB_REQ_RECIPIENT_ENDPOINT &&
+                  ctrlreq->value == USB_FEATURE_ENDPOINTHALT &&
+                  (privep = nrf53_ep_findbyaddr(
+                     priv, ctrlreq->index)) != NULL)
                 {
-                  usbtrace(TRACE_DEVERROR(NRF53_TRACEERR_BADGETSTATUS), 0);
-                  priv->stalled = true;
-                  break;
+                  nrf53_ep_clrstall(privep);
                 }
-              }
-          }
-        break;
-      }
-
-    case USB_REQ_CLEARFEATURE:
-      {
-        /* type:  host-to-device; recipient = device, interface or endpoint
-         * value: feature selector
-         * index: zero interface endpoint;
-         * len:   zero, data = none
-         */
+              else if (recipient == USB_REQ_RECIPIENT_DEVICE &&
+                       ctrlreq->value == USB_FEATURE_REMOTEWAKEUP)
+                {
+                  priv->wakeup = false;
+                }
+              else
+                {
+                  nrf53_req_dispatch(priv, &priv->ctrlreq);
+                }
+            }
+          else
+            {
+              usbtrace(TRACE_DEVERROR(NRF53_TRACEERR_BADCLEARFEATURE), 0);
+              priv->stalled = true;
+            }
+          break;
+        }
 
-        usbtrace(TRACE_INTDECODE(NRF53_TRACEINTID_CLEARFEATURE), 0);
-        if (priv->addressed != 0 && ctrlreq->len == 0)
-          {
-            recipient = ctrlreq->type & USB_REQ_RECIPIENT_MASK;
-            if (recipient == USB_REQ_RECIPIENT_ENDPOINT &&
-                ctrlreq->value == USB_FEATURE_ENDPOINTHALT &&
-                (privep = nrf53_ep_findbyaddr(priv, ctrlreq->index)) != NULL)
-              {
-                nrf53_ep_clrstall(privep);
-              }
-            else if (recipient == USB_REQ_RECIPIENT_DEVICE &&
-                     ctrlreq->value == USB_FEATURE_REMOTEWAKEUP)
-              {
-                priv->wakeup = false;
-              }
-            else
-              {
-                nrf53_req_dispatch(priv, &priv->ctrlreq);
-              }
-          }
-        else
-          {
-            usbtrace(TRACE_DEVERROR(NRF53_TRACEERR_BADCLEARFEATURE), 0);
-            priv->stalled = true;
-          }
-        break;
-      }
+      case USB_REQ_SETFEATURE:
+        {
+          /* type:  host-to-device; recipient = device, interface, endpoint
+           * value: feature selector
+           * index: zero interface endpoint;
+           * len:   0; data = none
+           */
 
-    case USB_REQ_SETFEATURE:
-      {
-        /* type:  host-to-device; recipient = device, interface, endpoint
-         * value: feature selector
-         * index: zero interface endpoint;
-         * len:   0; data = none
-         */
+          usbtrace(TRACE_INTDECODE(NRF53_TRACEINTID_SETFEATURE), 0);
+          if (priv->addressed != 0 && ctrlreq->len == 0)
+            {
+              recipient = ctrlreq->type & USB_REQ_RECIPIENT_MASK;
+              if (recipient == USB_REQ_RECIPIENT_ENDPOINT &&
+                  ctrlreq->value == USB_FEATURE_ENDPOINTHALT &&
+                  (privep = nrf53_ep_findbyaddr(
+                     priv, ctrlreq->index)) != NULL)
+                {
+                  nrf53_ep_setstall(privep);
+                }
+              else if (recipient == USB_REQ_RECIPIENT_DEVICE &&
+                       ctrlreq->value == USB_FEATURE_REMOTEWAKEUP)
+                {
+                  priv->wakeup = true;
+                }
+              else if (recipient == USB_REQ_RECIPIENT_DEVICE &&
+                       ctrlreq->value == USB_FEATURE_TESTMODE &&
+                       ((ctrlreq->index & 0xff) == 0))
+                {
+                  usbtrace(TRACE_INTDECODE(NRF53_TRACEINTID_TESTMODE), 0);
+                }
+              else
+                {
+                  usbtrace(TRACE_DEVERROR(NRF53_TRACEERR_BADSETFEATURE), 0);
+                  priv->stalled = true;
+                }
+            }
+          else
+            {
+              usbtrace(TRACE_DEVERROR(NRF53_TRACEERR_BADSETFEATURE), 0);
+              priv->stalled = true;
+            }
+          break;
+        }
 
-        usbtrace(TRACE_INTDECODE(NRF53_TRACEINTID_SETFEATURE), 0);
-        if (priv->addressed != 0 && ctrlreq->len == 0)
-          {
-            recipient = ctrlreq->type & USB_REQ_RECIPIENT_MASK;
-            if (recipient == USB_REQ_RECIPIENT_ENDPOINT &&
-                ctrlreq->value == USB_FEATURE_ENDPOINTHALT &&
-                (privep = nrf53_ep_findbyaddr(priv, ctrlreq->index)) != NULL)
-              {
-                nrf53_ep_setstall(privep);
-              }
-            else if (recipient == USB_REQ_RECIPIENT_DEVICE &&
-                     ctrlreq->value == USB_FEATURE_REMOTEWAKEUP)
-              {
-                priv->wakeup = true;
-              }
-            else if (recipient == USB_REQ_RECIPIENT_DEVICE &&
-                     ctrlreq->value == USB_FEATURE_TESTMODE &&
-                     ((ctrlreq->index & 0xff) == 0))
-              {
-                usbtrace(TRACE_INTDECODE(NRF53_TRACEINTID_TESTMODE), 0);
-              }
-            else
-              {
-                usbtrace(TRACE_DEVERROR(NRF53_TRACEERR_BADSETFEATURE), 0);
-                priv->stalled = true;
-              }
-          }
-        else
-          {
-            usbtrace(TRACE_DEVERROR(NRF53_TRACEERR_BADSETFEATURE), 0);
-            priv->stalled = true;
-          }
-        break;
-      }
+      case USB_REQ_SETADDRESS:
+        {
+          /* type:  host-to-device; recipient = device
+           * value: device address
+           * index: 0
+           * len:   0; data = none
+           */
 
-    case USB_REQ_SETADDRESS:
-      {
-        /* type:  host-to-device; recipient = device
-         * value: device address
-         * index: 0
-         * len:   0; data = none
-         */
+          usbtrace(TRACE_INTDECODE(NRF53_TRACEINTID_SETADDRESS),
+                    ctrlreq->value);
+          nrf53_setaddress(priv, (uint16_t)priv->ctrlreq.value[0]);
 
-        usbtrace(TRACE_INTDECODE(NRF53_TRACEINTID_SETADDRESS),
-                  ctrlreq->value);
-        nrf53_setaddress(priv, (uint16_t)priv->ctrlreq.value[0]);
+          /* NOTE: The USBD peripheral handles the SetAddress
+           * transfer by itself.
+           *
+           * REVISTI: Documentation states that we shall not handle this
+           *          command in the software at all, but if we don't
+           *          send EP0STATUS response then enumeration fails.
+           */
 
-        /* NOTE: The USBD peripheral handles the SetAddress
-         * transfer by itself.
-         *
-         * REVISTI: Documentation states that we shall not handle this
-         *          command in the software at all, but if we don't
-         *          send EP0STATUS response then enumeration fails.
-         */
+          break;
+        }
 
-        break;
-      }
+      case USB_REQ_GETDESCRIPTOR:
+        /* type:  device-to-host; recipient = device
+         * value: descriptor type and index
+         * index: 0 or language ID;
+         * len:   descriptor len; data = descriptor
+         */
 
-    case USB_REQ_GETDESCRIPTOR:
-      /* type:  device-to-host; recipient = device
-       * value: descriptor type and index
-       * index: 0 or language ID;
-       * len:   descriptor len; data = descriptor
-       */
+      case USB_REQ_SETDESCRIPTOR:
+        /* type:  host-to-device; recipient = device
+         * value: descriptor type and index
+         * index: 0 or language ID;
+         * len:   descriptor len; data = descriptor
+         */
 
-    case USB_REQ_SETDESCRIPTOR:
-      /* type:  host-to-device; recipient = device
-       * value: descriptor type and index
-       * index: 0 or language ID;
-       * len:   descriptor len; data = descriptor
-       */
+        {
+          usbtrace(TRACE_INTDECODE(NRF53_TRACEINTID_GETSETDESC),
+                   priv->ctrlreq.req);
+          nrf53_req_dispatch(priv, &priv->ctrlreq);
+          break;
+        }
 
-      {
-        usbtrace(TRACE_INTDECODE(NRF53_TRACEINTID_GETSETDESC),
-                 priv->ctrlreq.req);
-        nrf53_req_dispatch(priv, &priv->ctrlreq);
-        break;
-      }
+      case USB_REQ_GETCONFIGURATION:
+        /* type:  device-to-host; recipient = device
+         * value: 0;
+         * index: 0;
+         * len:   1; data = configuration value
+         */
 
-    case USB_REQ_GETCONFIGURATION:
-      /* type:  device-to-host; recipient = device
-       * value: 0;
-       * index: 0;
-       * len:   1; data = configuration value
-       */
+      case USB_REQ_SETCONFIGURATION:
+        /* type:  host-to-device; recipient = device
+         * value: configuration value
+         * index: 0;
+         * len:   0; data = none
+         */
 
-    case USB_REQ_SETCONFIGURATION:
-      /* type:  host-to-device; recipient = device
-       * value: configuration value
-       * index: 0;
-       * len:   0; data = none
-       */
+      case USB_REQ_GETINTERFACE:
+        /* type:  device-to-host; recipient = interface
+         * value: 0
+         * index: interface;
+         * len:   1; data = alt interface
+         */
 
-    case USB_REQ_GETINTERFACE:
-      /* type:  device-to-host; recipient = interface
-       * value: 0
-       * index: interface;
-       * len:   1; data = alt interface
-       */
+      case USB_REQ_SETINTERFACE:
+        /* type:  host-to-device; recipient = interface
+         * value: alternate setting
+         * index: interface;
+         * len:   0; data = none
+         */
 
-    case USB_REQ_SETINTERFACE:
-      /* type:  host-to-device; recipient = interface
-       * value: alternate setting
-       * index: interface;
-       * len:   0; data = none
-       */
+        {
+          usbtrace(TRACE_INTDECODE(NRF53_TRACEINTID_GETSETIFCONFIG),
+                   priv->ctrlreq.req);
+          nrf53_req_dispatch(priv, &priv->ctrlreq);
+          break;
+        }
 
-      {
-        usbtrace(TRACE_INTDECODE(NRF53_TRACEINTID_GETSETIFCONFIG),
-                 priv->ctrlreq.req);
-        nrf53_req_dispatch(priv, &priv->ctrlreq);
-        break;
-      }
+      case USB_REQ_SYNCHFRAME:
+        /* type:  device-to-host; recipient = endpoint
+         * value: 0
+         * index: endpoint;
+         * len:   2; data = frame number
+         */
 
-    case USB_REQ_SYNCHFRAME:
-      /* type:  device-to-host; recipient = endpoint
-       * value: 0
-       * index: endpoint;
-       * len:   2; data = frame number
-       */
+        {
+          usbtrace(TRACE_INTDECODE(NRF53_TRACEINTID_SYNCHFRAME), 0);
+          break;
+        }
 
-      {
-        usbtrace(TRACE_INTDECODE(NRF53_TRACEINTID_SYNCHFRAME), 0);
+      default:
+        {
+          usbtrace(TRACE_DEVERROR(NRF53_TRACEERR_INVALIDCTRLREQ), 0);
+          priv->stalled = true;
+        }
         break;
-      }
-
-    default:
-      {
-        usbtrace(TRACE_DEVERROR(NRF53_TRACEERR_INVALIDCTRLREQ), 0);
-        priv->stalled = true;
-      }
-      break;
     }
 }
 
@@ -2242,6 +2246,10 @@ static int nrf53_epout_configure(struct nrf53_ep_s 
*privep, uint8_t eptype,
   /* Allocate buffer for EPOUT */
 
   privep->rxbuff = kmm_malloc(maxpacket);
+  if (privep->rxbuff == NULL)
+    {
+      return -ENOMEM;
+    }
 
   /* Enable the interrupt for this endpoint */
 
diff --git a/arch/arm/src/samd2l2/sam_adc.c b/arch/arm/src/samd2l2/sam_adc.c
index 0a271b23d0d..356b0a1eebb 100644
--- a/arch/arm/src/samd2l2/sam_adc.c
+++ b/arch/arm/src/samd2l2/sam_adc.c
@@ -212,6 +212,7 @@ static int sam_adc_bind(struct adc_dev_s *dev,
                         const struct adc_callback_s *callback)
 {
   struct sam_adc_priv *priv = (struct sam_adc_priv *)dev->ad_priv;
+
   priv->adc_callback = callback;
   return 0;
 }
@@ -465,6 +466,12 @@ struct adc_dev_s *sam_adcinitialize(int genclk)
 
   struct sam_adc_priv *priv = (struct sam_adc_priv *)
                               kmm_malloc(sizeof(struct sam_adc_priv));
+
+  if (priv == NULL)
+    {
+      return NULL;
+    }
+
   priv->genclk = genclk;
 
   g_sam_adc_dev.ad_priv = priv;
@@ -473,6 +480,12 @@ struct adc_dev_s *sam_adcinitialize(int genclk)
   priv->num_channels = BOARD_ADC_NUM_CHANNELS;
   priv->channels = kmm_malloc(priv->num_channels * sizeof(int));
 
+  if (priv->channels == NULL)
+    {
+      kmm_free(priv);
+      return NULL;
+    }
+
 #if BOARD_ADC_REF == ADC_REFCTRL_REFSEL_VREFA
   sam_configport(PORT_ADC_VREFA);
 #elif BOARD_ADC_REF == ADC_REFCTRL_REFSEL_VREFB
diff --git a/arch/sim/src/sim/sim_deviceimage.c 
b/arch/sim/src/sim/sim_deviceimage.c
index 95433dbec7d..e7aac1e3ade 100644
--- a/arch/sim/src/sim/sim_deviceimage.c
+++ b/arch/sim/src/sim/sim_deviceimage.c
@@ -299,6 +299,11 @@ char *sim_deviceimage(void)
    */
 
   pbuffer = kmm_malloc(bufsize);
+  if (pbuffer == NULL)
+    {
+      inflateEnd(&strm);
+      return NULL;
+    }
 
   /* Set up the input buffer */
 
@@ -326,11 +331,11 @@ char *sim_deviceimage(void)
           case Z_DATA_ERROR:
           case Z_MEM_ERROR:
           case Z_STREAM_ERROR:
-              serr("ERROR: inflate FAILED: ret=%d msg=\"%s\"\n",
-                    ret, strm.msg ? strm.msg : "No message");
-              inflateEnd(&strm);
-              kmm_free(pbuffer);
-              return NULL;
+            serr("ERROR: inflate FAILED: ret=%d msg=\"%s\"\n",
+                  ret, strm.msg ? strm.msg : "No message");
+            inflateEnd(&strm);
+            kmm_free(pbuffer);
+            return NULL;
         }
 
       /* If avail_out is zero, then inflate() returned only because it is
@@ -342,6 +347,7 @@ char *sim_deviceimage(void)
         {
           int newbufsize = bufsize + 128 * 1024;
           char *newbuffer = kmm_realloc(pbuffer, newbufsize);
+
           if (!newbuffer)
             {
               kmm_free(pbuffer);
@@ -362,6 +368,7 @@ char *sim_deviceimage(void)
 
           int newbufsize = bufsize - strm.avail_out;
           char *newbuffer = kmm_realloc(pbuffer, newbufsize);
+
           if (!newbuffer)
             {
               kmm_free(pbuffer);

Reply via email to