[client/common] fixes for issues detected through static analysis.

client/displayservers/Wayland/window.c

@@ -57,6 +57,12 @@ void waylandWindowUpdateScale(void)
 static void wlSurfaceEnterHandler(void * data, struct wl_surface * surface, struct wl_output * output)
 {
   struct SurfaceOutput * node = malloc(sizeof(*node));
+  if (!node)
+  {
+    DEBUG_ERROR("out of memory");
+    return;
+  }
+
   node->output = output;
   wl_list_insert(&wlWm.surfaceOutputs, &node->link);
   waylandWindowUpdateScale();

client/displayservers/X11/clipboard.c

@@ -152,6 +152,12 @@ static void x11CBReplyFn(void * opaque, LG_ClipboardData type,
 static void x11CBSelectionRequest(const XSelectionRequestEvent e)
 {
   XEvent * s = malloc(sizeof(*s));
+  if (!s)
+  {
+    DEBUG_ERROR("out of memory");
+    return;
+  }
+
   s->xselection.type      = SelectionNotify;
   s->xselection.requestor = e.requestor;
   s->xselection.selection = e.selection;

client/renderers/EGL/egl.c

@@ -793,7 +793,7 @@ static bool egl_renderStartup(LG_Renderer * renderer, bool useDMA)
   else if (debug)
     DEBUG_WARN("Cannot create debug contexts before EGL 1.5 without EGL_KHR_create_context");
 
-  ctxattr[ctxidx++] = EGL_NONE;
+  ctxattr[ctxidx] = EGL_NONE;
 
   this->context = eglCreateContext(this->display, this->configs, EGL_NO_CONTEXT, ctxattr);
   if (this->context == EGL_NO_CONTEXT)

client/renderers/EGL/model.c

@@ -124,10 +124,31 @@ void egl_modelSetDefault(EGL_Model * model, bool flipped)
 void egl_modelAddVerts(EGL_Model * model, const GLfloat * verticies, const GLfloat * uvs, const size_t count)
 {
   struct FloatList * fl = malloc(sizeof(*fl));
+  if (!fl)
+  {
+    DEBUG_ERROR("out of memory");
+    return;
+  }
 
   fl->count = count;
-  fl->v     = malloc(sizeof(GLfloat) * count * 3);
+
-  fl->u     = malloc(sizeof(GLfloat) * count * 2);
+  fl->v = malloc(sizeof(GLfloat) * count * 3);
+  if (!fl->v)
+  {
+    DEBUG_ERROR("out of memory");
+    free(fl);
+    return;
+  }
+
+  fl->u = malloc(sizeof(GLfloat) * count * 2);
+  if (!fl->u)
+  {
+    DEBUG_ERROR("out of memory");
+    free(fl->v);
+    free(fl);
+    return;
+  }
+
   memcpy(fl->v, verticies, sizeof(GLfloat) * count * 3);
 
   if (uvs)

client/renderers/EGL/shader.c

@@ -119,10 +119,15 @@ bool egl_shaderCompile(EGL_Shader * this, const char * vertex_code,
     if (logLength > 0)
     {
       char *log = malloc(logLength + 1);
-      glGetShaderInfoLog(vertexShader, logLength, NULL, log);
+      if (!log)
-      log[logLength] = 0;
+        DEBUG_ERROR("out of memory");
-      DEBUG_ERROR("%s", log);
+      else
-      free(log);
+      {
+        glGetShaderInfoLog(vertexShader, logLength, NULL, log);
+        log[logLength] = 0;
+        DEBUG_ERROR("%s", log);
+        free(log);
+      }
     }
 
     glDeleteShader(vertexShader);
@@ -145,10 +150,15 @@ bool egl_shaderCompile(EGL_Shader * this, const char * vertex_code,
     if (logLength > 0)
     {
       char *log = malloc(logLength + 1);
-      glGetShaderInfoLog(fragmentShader, logLength, NULL, log);
+      if (!log)
-      log[logLength] = 0;
+        DEBUG_ERROR("out of memory");
-      DEBUG_ERROR("%s", log);
+      else
-      free(log);
+      {
+        glGetShaderInfoLog(fragmentShader, logLength, NULL, log);
+        log[logLength] = 0;
+        DEBUG_ERROR("%s", log);
+        free(log);
+      }
     }
 
     glDeleteShader(fragmentShader);
@@ -201,6 +211,12 @@ void egl_shaderSetUniforms(EGL_Shader * this, EGL_Uniform * uniforms, int count)
   {
     free(this->uniforms);
     this->uniforms = malloc(sizeof(*this->uniforms) * count);
+    if (!this->uniforms)
+    {
+      DEBUG_ERROR("out of memory");
+      return;
+    }
+
     this->uniformCount = count;
   }
 

client/renderers/OpenGL/opengl.c

@@ -327,7 +327,14 @@ bool opengl_onMouseShape(LG_Renderer * renderer, const LG_RendererCursor cursor,
   {
     if (this->mouseData)
       free(this->mouseData);
-    this->mouseData     = malloc(size);
+
+    this->mouseData = malloc(size);
+    if (!this->mouseData)
+    {
+      DEBUG_ERROR("out of memory");
+      return false;
+    }
+
     this->mouseDataSize = size;
   }
 

client/src/app.c

@@ -230,6 +230,11 @@ void app_clipboardRequest(const LG_ClipboardReplyFn replyFn, void * opaque)
     return;
 
   struct CBRequest * cbr = malloc(sizeof(*cbr));
+  if (!cbr)
+  {
+    DEBUG_ERROR("out of memory");
+    return;
+  }
 
   cbr->type    = g_state.cbType;
   cbr->replyFn = replyFn;
@@ -666,6 +671,12 @@ KeybindHandle app_registerKeybind(int sc, KeybindFn callback, void * opaque, con
   }
 
   KeybindHandle handle = malloc(sizeof(*handle));
+  if (!handle)
+  {
+    DEBUG_ERROR("out of memory");
+    return NULL;
+  }
+
   handle->sc       = sc;
   handle->callback = callback;
   handle->opaque   = opaque;
@@ -716,6 +727,12 @@ void app_registerOverlay(const struct LG_OverlayOps * ops, const void * params)
   ASSERT_LG_OVERLAY_VALID(ops);
 
   struct Overlay * overlay = malloc(sizeof(*overlay));
+  if (!overlay)
+  {
+    DEBUG_ERROR("out of ram");
+    return;
+  }
+
   overlay->ops           = ops;
   overlay->params        = params;
   overlay->udata         = NULL;
@@ -732,6 +749,7 @@ void app_initOverlays(void)
   ll_lock(g_state.overlays);
   ll_forEachNL(g_state.overlays, item, overlay)
   {
+    DEBUG_ASSERT(overlay->ops);
     if (!overlay->ops->init(&overlay->udata, overlay->params))
     {
       DEBUG_ERROR("Overlay `%s` failed to initialize", overlay->ops->name);

client/src/config.c

@@ -505,22 +505,38 @@ bool config_load(int argc, char * argv[])
 
   // load config from user's home directory
   struct passwd * pw = getpwuid(getuid());
-  char * localFile;
+  if (!pw)
-  alloc_sprintf(&localFile, "%s/.looking-glass-client.ini", pw->pw_dir);
+    DEBUG_WARN("getpwuid failed, unable to load user configuration");
-  if (stat(localFile, &st) >= 0 && S_ISREG(st.st_mode))
+  else
   {
-    DEBUG_INFO("Loading config from: %s", localFile);
+    char * localFile;
-    if (!option_load(localFile))
+    alloc_sprintf(&localFile, "%s/.looking-glass-client.ini", pw->pw_dir);
+    if (!localFile)
     {
-      free(localFile);
+      DEBUG_ERROR("out of memory");
       return false;
     }
+
+    if (stat(localFile, &st) >= 0 && S_ISREG(st.st_mode))
+    {
+      DEBUG_INFO("Loading config from: %s", localFile);
+      if (!option_load(localFile))
+      {
+        free(localFile);
+        return false;
+      }
+    }
+    free(localFile);
   }
-  free(localFile);
 
   // load config from XDG_CONFIG_HOME
   char * xdgFile;
   alloc_sprintf(&xdgFile, "%s/client.ini", lgConfigDir());
+  if (!xdgFile)
+  {
+    DEBUG_ERROR("out of memory");
+    return false;
+  }
 
   if (xdgFile && stat(xdgFile, &st) >= 0 && S_ISREG(st.st_mode))
   {
@@ -714,6 +730,8 @@ static bool optRendererParse(struct Option * opt, const char * str)
 static StringList optRendererValues(struct Option * opt)
 {
   StringList sl = stringlist_new(false);
+  if (!sl)
+    return NULL;
 
   // this typecast is safe as the stringlist doesn't own the values
   for(unsigned int i = 0; i < LG_RENDERER_COUNT; ++i)
@@ -756,6 +774,9 @@ static bool optPosParse(struct Option * opt, const char * str)
 static StringList optPosValues(struct Option * opt)
 {
   StringList sl = stringlist_new(false);
+  if (!sl)
+    return NULL;
+
   stringlist_push(sl, "center");
   stringlist_push(sl, "<left>x<top>, e.g. 100x100");
   return sl;
@@ -768,6 +789,11 @@ static char * optPosToString(struct Option * opt)
 
   int len = snprintf(NULL, 0, "%dx%d", g_params.x, g_params.y);
   char * str = malloc(len + 1);
+  if (!str)
+  {
+    DEBUG_ERROR("out of memory");
+    return NULL;
+  }
   sprintf(str, "%dx%d", g_params.x, g_params.y);
 
   return str;
@@ -791,6 +817,9 @@ static bool optSizeParse(struct Option * opt, const char * str)
 static StringList optSizeValues(struct Option * opt)
 {
   StringList sl = stringlist_new(false);
+  if (!sl)
+    return NULL;
+
   stringlist_push(sl, "<left>x<top>, e.g. 100x100");
   return sl;
 }
@@ -799,6 +828,11 @@ static char * optSizeToString(struct Option * opt)
 {
   int len = snprintf(NULL, 0, "%ux%u", g_params.w, g_params.h);
   char * str = malloc(len + 1);
+  if (!str)
+  {
+    DEBUG_ERROR("out of memory");
+    return NULL;
+  }
   sprintf(str, "%ux%u", g_params.w, g_params.h);
 
   return str;

client/src/main.c

@@ -641,6 +641,11 @@ int main_frameThread(void * unused)
         case FRAME_ROT_90 : lgrFormat.rotate = LG_ROTATE_90 ; break;
         case FRAME_ROT_180: lgrFormat.rotate = LG_ROTATE_180; break;
         case FRAME_ROT_270: lgrFormat.rotate = LG_ROTATE_270; break;
+
+        default:
+          DEBUG_ERROR("Unsupported/invalid frame rotation");
+          lgrFormat.rotate = LG_ROTATE_0;
+          break;
       }
       g_state.rotate = lgrFormat.rotate;
 
@@ -1113,7 +1118,7 @@ static int lg_run(void)
   }
 
   // select and init a renderer
-  bool needsOpenGL;
+  bool needsOpenGL = false;
   LG_RendererParams lgrParams;
   lgrParams.quickSplash = g_params.quickSplash;
 

client/src/overlay/graphs.c

@@ -216,6 +216,12 @@ GraphHandle overlayGraph_register(const char * name, RingBuffer buffer,
     float min, float max, GraphFormatFn formatFn)
 {
   struct OverlayGraph * graph = malloc(sizeof(*graph));
+  if (!graph)
+  {
+    DEBUG_ERROR("out of memory");
+    return NULL;
+  }
+
   graph->name     = name;
   graph->buffer   = buffer;
   graph->enabled  = true;

client/src/overlay/msg.c

@@ -152,6 +152,12 @@ MsgBoxHandle overlayMsg_show(
     const char * caption, const char * fmt, va_list args)
 {
   struct Msg * msg = malloc(sizeof(*msg));
+  if (!msg)
+  {
+    DEBUG_ERROR("out of memory");
+    return NULL;
+  }
+
   msg->caption = strdup(caption);
   msg->lines   = stringlist_new(false);
   valloc_sprintf(&msg->message, fmt, args);

common/src/ll.c

@@ -26,6 +26,12 @@
 struct ll * ll_new(void)
 {
   struct ll * list = malloc(sizeof(*list));
+  if (!list)
+  {
+    DEBUG_ERROR("out of memory");
+    return NULL;
+  }
+
   list->head  = NULL;
   list->tail  = NULL;
   list->count = 0;
@@ -45,6 +51,12 @@ void ll_free(struct ll * list)
 void ll_push(struct ll * list, void * data)
 {
   struct ll_item * item = malloc(sizeof(*item));
+  if (!item)
+  {
+    DEBUG_ERROR("out of memory");
+    return;
+  }
+
   item->data = data;
   item->next = NULL;
 

common/src/option.c

@@ -88,6 +88,12 @@ static char * int_toString(struct Option * opt)
 {
   int len = snprintf(NULL, 0, "%d", opt->value.x_int);
   char * ret = malloc(len + 1);
+  if (!ret)
+  {
+    DEBUG_ERROR("out of memory");
+    return NULL;
+  }
+
   sprintf(ret, "%d", opt->value.x_int);
   return ret;
 }
@@ -101,6 +107,12 @@ static char * float_toString(struct Option * opt)
 {
   int len = snprintf(NULL, 0, "%f", opt->value.x_float);
   char * ret = malloc(len + 1);
+  if (!ret)
+  {
+    DEBUG_ERROR("out of memory");
+    return NULL;
+  }
+
   sprintf(ret, "%f", opt->value.x_float);
   return ret;
 }
@@ -124,10 +136,22 @@ bool option_register(struct Option options[])
     sizeof(*state.options) * (state.oCount + new)
   );
 
+  if (!state.options)
+  {
+    DEBUG_ERROR("out of memory");
+    return false;
+  }
+
   for(int i = 0; options[i].type != OPTION_TYPE_NONE; ++i)
   {
-    state.options[state.oCount + i] = malloc(sizeof(**state.options));
+    struct Option * o =
-    struct Option * o = state.options[state.oCount + i];
+      state.options[state.oCount + i] = malloc(sizeof(**state.options));
+    if (!o)
+    {
+      DEBUG_ERROR("out of memory");
+      return false;
+    }
+
     memcpy(o, &options[i], sizeof(*o));
 
     if (!o->parser)
@@ -186,7 +210,14 @@ bool option_register(struct Option options[])
     if (o->type == OPTION_TYPE_STRING)
     {
       if (o->value.x_string)
+      {
         o->value.x_string = strdup(o->value.x_string);
+        if (!o->value.x_string)
+        {
+          DEBUG_ERROR("out of memory");
+          return false;
+        }
+      }
     }
 
     // add the option to the correct group for help printout
@@ -202,6 +233,11 @@ bool option_register(struct Option options[])
         group->options,
         sizeof(*group->options) * (group->count + 1)
       );
+      if (!group->options)
+      {
+        DEBUG_ERROR("out of memory");
+        return false;
+      }
       group->options[group->count] = o;
 
       int len = strlen(o->name);
@@ -218,6 +254,11 @@ bool option_register(struct Option options[])
         state.groups,
         sizeof(*state.groups) * (state.gCount + 1)
       );
+      if (!state.groups)
+      {
+        DEBUG_ERROR("out of memory");
+        return false;
+      }
 
       struct OptionGroup * group = &state.groups[state.gCount];
       ++state.gCount;
@@ -239,7 +280,7 @@ void option_free(void)
   for(int i = 0; i < state.oCount; ++i)
   {
     struct Option * o = state.options[i];
-    if (o->type == OPTION_TYPE_STRING)
+    if (o->type == OPTION_TYPE_STRING && o->value.x_string)
       free(o->value.x_string);
     free(o);
   }

common/src/platform/linux/ivshmem.c

@@ -120,7 +120,7 @@ bool ivshmemOpenDev(struct IVSHMEM * dev, const char * shmDevice)
   DEBUG_ASSERT(dev);
 
   unsigned int devSize;
-  int devFd = -1;
+  int devFd;
   bool hasDMA;
 
   dev->opaque = NULL;

common/src/platform/linux/thread.c

@@ -44,6 +44,12 @@ static void * threadWrapper(void * opaque)
 bool lgCreateThread(const char * name, LGThreadFunction function, void * opaque, LGThread ** handle)
 {
   *handle = malloc(sizeof(**handle));
+  if (!*handle)
+  {
+    DEBUG_ERROR("out of memory");
+    return false;
+  }
+
   (*handle)->name     = name;
   (*handle)->function = function;
   (*handle)->opaque   = opaque;

common/src/ringbuffer.c

@@ -42,6 +42,12 @@ RingBuffer ringbuffer_newInternal(int length, size_t valueSize,
   DEBUG_ASSERT(valueSize > 0 && valueSize < UINT32_MAX);
 
   struct RingBuffer * rb = calloc(1, sizeof(*rb) + valueSize * length);
+  if (!rb)
+  {
+    DEBUG_ERROR("out of memory");
+    return NULL;
+  }
+
   rb->length    = length;
   rb->valueSize = valueSize;
   atomic_store(&rb->readPos , 0);

common/src/runningavg.c

@@ -19,6 +19,7 @@
  */
 
 #include "common/runningavg.h"
+#include "common/debug.h"
 
 #include <stdlib.h>
 
@@ -33,6 +34,12 @@ struct RunningAvg
 RunningAvg runningavg_new(int length)
 {
   struct RunningAvg * ra = calloc(1, sizeof(*ra) + sizeof(*ra->values) * length);
+  if (!ra)
+  {
+    DEBUG_ERROR("out of memory");
+    return NULL;
+  }
+
   ra->length = length;
   return ra;
 }

common/src/stringlist.c

@@ -20,6 +20,7 @@
 
 #include "common/stringlist.h"
 #include "common/vector.h"
+#include "common/debug.h"
 
 #include <stdlib.h>
 
@@ -32,6 +33,12 @@ struct StringList
 StringList stringlist_new(bool owns_strings)
 {
   StringList sl = malloc(sizeof(*sl));
+  if (!sl)
+  {
+    DEBUG_ERROR("out of memory");
+    return NULL;
+  }
+
   sl->owns_strings = owns_strings;
 
   if (!vector_create(&sl->vector, sizeof(char *), 32))