curl_global_init_mem() allows the memory functions to be replaced.

memory.h is included everywhere for this.

1 files changed, 152 insertions, 178 deletions

diff --git a/lib/nwlib.c b/lib/nwlib.c
index d54f4ac96..2dd0f4fa5 100644
--- a/lib/nwlib.c
+++ b/lib/nwlib.c
@@ -30,21 +30,23 @@
 #include <nks/thread.h>

 #include <nks/synch.h>

 

+#include "memory.h"

+#include "memdebug.h"

 

 typedef struct

 {

-    int     _errno;

-    void    *twentybytes;

+  int     _errno;

+  void    *twentybytes;

 } libthreaddata_t;

 

 typedef struct

 {

-    int         x;

-    int         y;

-    int         z;

-    void        *tenbytes;

-    NXKey_t     perthreadkey;   /* if -1, no key obtained... */

-    NXMutex_t   *lock;

+  int         x;

+  int         y;

+  int         z;

+  void        *tenbytes;

+  NXKey_t     perthreadkey;   /* if -1, no key obtained... */

+  NXMutex_t   *lock;

 } libdata_t;

 

 int         gLibId      = -1;

@@ -58,24 +60,24 @@ void    DisposeThreadData ( void * );
 int     GetOrSetUpData ( int id, libdata_t **data, libthreaddata_t **threaddata );

 

 

-int _NonAppStart

-(

-    void        *NLMHandle,

-    void        *errorScreen,

-    const char  *cmdLine,

-    const char  *loadDirPath,

-    size_t      uninitializedDataLength,

-    void        *NLMFileHandle,

-    int         (*readRoutineP)( int conn, void *fileHandle, size_t offset,

-                                size_t nbytes, size_t *bytesRead, void *buffer ),

-    size_t      customDataOffset,

-    size_t      customDataSize,

-    int         messageCount,

-    const char  **messages

-)

+int _NonAppStart( void        *NLMHandle,

+                  void        *errorScreen,

+                  const char  *cmdLine,

+                  const char  *loadDirPath,

+                  size_t      uninitializedDataLength,

+                  void        *NLMFileHandle,

+                  int         (*readRoutineP)( int conn,

+                                               void *fileHandle, size_t offset,

+                                               size_t nbytes,

+                                               size_t *bytesRead,

+                                               void *buffer ),

+                  size_t      customDataOffset,

+                  size_t      customDataSize,

+                  int         messageCount,

+                  const char  **messages )

 {

-    NX_LOCK_INFO_ALLOC(liblock, "Per-Application Data Lock", 0);

-

+  NX_LOCK_INFO_ALLOC(liblock, "Per-Application Data Lock", 0);

+  

 #ifndef __GNUC__

 #pragma unused(cmdLine)

 #pragma unused(loadDirPath)

@@ -94,35 +96,33 @@ int _NonAppStart
 ** to accept calls into us. If we succeed, we return non-zero and the NetWare

 ** Loader will leave us up, otherwise we fail to load and get dumped.

 */

-    gAllocTag = AllocateResourceTag(NLMHandle,

-                                "<library-name> memory allocations", AllocSignature);

+  gAllocTag = AllocateResourceTag(NLMHandle,

+                                  "<library-name> memory allocations",

+                                  AllocSignature);

 

-    if (!gAllocTag)

-    {

-        OutputToScreen(errorScreen, "Unable to allocate resource tag for "

-                                            "library memory allocations.\n");

-        return -1;

-    }

+  if (!gAllocTag) {

+    OutputToScreen(errorScreen, "Unable to allocate resource tag for "

+                   "library memory allocations.\n");

+    return -1;

+  }

 

-    gLibId = register_library(DisposeLibraryData);

+  gLibId = register_library(DisposeLibraryData);

 

-    if (gLibId < -1)

-    {

-        OutputToScreen(errorScreen, "Unable to register library with kernel.\n");

-        return -1;

-    }

+  if (gLibId < -1) {

+    OutputToScreen(errorScreen, "Unable to register library with kernel.\n");

+    return -1;

+  }

 

-    gLibHandle = NLMHandle;

+  gLibHandle = NLMHandle;

 

-    gLibLock = NXMutexAlloc(0, 0, &liblock);

-

-    if (!gLibLock)

-    {

-        OutputToScreen(errorScreen, "Unable to allocate library data lock.\n");

-        return -1;

-    }

+  gLibLock = NXMutexAlloc(0, 0, &liblock);

+  

+  if (!gLibLock) {

+    OutputToScreen(errorScreen, "Unable to allocate library data lock.\n");

+    return -1;

+  }

 

-    return 0;

+  return 0;

 }

 

 /*

@@ -131,8 +131,8 @@ int _NonAppStart
 */

 void _NonAppStop( void )

 {

-    (void) unregister_library(gLibId);

-    NXMutexFree(gLibLock);

+  (void) unregister_library(gLibId);

+  NXMutexFree(gLibLock);

 }

 

 /*

@@ -151,31 +151,26 @@ int  _NonAppCheckUnload( void )
     return 0;

 }

 

-int GetOrSetUpData

-(

-    int                 id,

-    libdata_t           **appData,

-    libthreaddata_t **threadData

-)

+int GetOrSetUpData(int id, libdata_t **appData,

+                   libthreaddata_t **threadData )

 {

-    int                 err;

-    libdata_t           *app_data;

-    libthreaddata_t *thread_data;

-    NXKey_t             key;

-    NX_LOCK_INFO_ALLOC(liblock, "Application Data Lock", 0);

+  int                 err;

+  libdata_t           *app_data;

+  libthreaddata_t *thread_data;

+  NXKey_t             key;

+  NX_LOCK_INFO_ALLOC(liblock, "Application Data Lock", 0);

 

-    err         = 0;

-    thread_data = (libthreaddata_t *) NULL;

+  err         = 0;

+  thread_data = (libthreaddata_t *) NULL;

 

 /*

 ** Attempt to get our data for the application calling us. This is where we

 ** store whatever application-specific information we need to carry in support

 ** of calling applications.

 */

-    app_data = (libdata_t *) get_app_data(id);

+  app_data = (libdata_t *) get_app_data(id);

 

-    if (!app_data)

-    {

+  if (!app_data) {

 /*

 ** This application hasn't called us before; set up application AND per-thread

 ** data. Of course, just in case a thread from this same application is calling

@@ -184,31 +179,27 @@ int GetOrSetUpData
 ** that other thread that was too late to create the data and the first thread

 ** in will have created it.

 */

-        NXLock(gLibLock);

-

-        if (!(app_data = (libdata_t *) get_app_data(id)))

-        {

-            app_data = (libdata_t *) malloc(sizeof(libdata_t));

-

-            if (app_data)

-            {

-                memset(app_data, 0, sizeof(libdata_t));

-

-                app_data->tenbytes = malloc(10);

-                app_data->lock     = NXMutexAlloc(0, 0, &liblock);

-

-                if (!app_data->tenbytes || !app_data->lock)

-                {

-                    if (app_data->lock)

-                        NXMutexFree(app_data->lock);

-

-                    free(app_data);

-                    app_data = (libdata_t *) NULL;

-                    err      = ENOMEM;

-                }

-

-                if (app_data)

-                {

+    NXLock(gLibLock);

+

+    if (!(app_data = (libdata_t *) get_app_data(id))) {

+      app_data = (libdata_t *) malloc(sizeof(libdata_t));

+

+      if (app_data) {

+        memset(app_data, 0, sizeof(libdata_t));

+        

+        app_data->tenbytes = malloc(10);

+        app_data->lock     = NXMutexAlloc(0, 0, &liblock);

+        

+        if (!app_data->tenbytes || !app_data->lock) {

+          if (app_data->lock)

+            NXMutexFree(app_data->lock);

+          

+          free(app_data);

+          app_data = (libdata_t *) NULL;

+          err      = ENOMEM;

+        }

+        

+        if (app_data) {

 /*

 ** Here we burn in the application data that we were trying to get by calling

 ** get_app_data(). Next time we call the first function, we'll get this data

@@ -216,39 +207,35 @@ int GetOrSetUpData
 ** for the calling thread, something we'll have to do on each application

 ** thread the first time it calls us.

 */

-                    err = set_app_data(gLibId, app_data);

-

-                    if (err)

-                    {

-                        free(app_data);

-                        app_data = (libdata_t *) NULL;

-                        err      = ENOMEM;

-                    }

-                    else

-                    {

-                        /* create key for thread-specific data... */

-                        err = NXKeyCreate(DisposeThreadData, (void *) NULL, &key);

-

-                        if (err)                /* (no more keys left?) */

-                            key = -1;

-

-                        app_data->perthreadkey = key;

-                    }

-                }

-            }

+          err = set_app_data(gLibId, app_data);

+          

+          if (err) {

+            free(app_data);

+            app_data = (libdata_t *) NULL;

+            err      = ENOMEM;

+          }

+          else {

+            /* create key for thread-specific data... */

+            err = NXKeyCreate(DisposeThreadData, (void *) NULL, &key);

+            

+            if (err)                /* (no more keys left?) */

+              key = -1;

+            

+            app_data->perthreadkey = key;

+          }

         }

-

-        NXUnlock(gLibLock);

+      }

     }

-

-    if (app_data)

-    {

-        key = app_data->perthreadkey;

-

-        if (     key != -1                  /* couldn't create a key? no thread data */

-            && !(err = NXKeyGetValue(key, (void **) &thread_data))

-            && !thread_data)

-        {

+    

+    NXUnlock(gLibLock);

+  }

+

+  if (app_data) {

+    key = app_data->perthreadkey;

+    

+    if (key != -1 /* couldn't create a key? no thread data */

+        && !(err = NXKeyGetValue(key, (void **) &thread_data))

+        && !thread_data) {

 /*

 ** Allocate the per-thread data for the calling thread. Regardless of whether

 ** there was already application data or not, this may be the first call by a

@@ -256,71 +243,58 @@ int GetOrSetUpData
 ** important, this just helps to demonstrate that we can have arbitrarily

 ** complex per-thread data.

 */

-            thread_data = (libthreaddata_t *) malloc(sizeof(libthreaddata_t));

-

-            if (thread_data)

-            {

-                thread_data->_errno      = 0;

-                thread_data->twentybytes = malloc(20);

-

-                if (!thread_data->twentybytes)

-                {

-                    free(thread_data);

-                    thread_data = (libthreaddata_t *) NULL;

-                    err         = ENOMEM;

-                }

-

-                if ((err = NXKeySetValue(key, thread_data)))

-                {

-                    free(thread_data->twentybytes);

-                    free(thread_data);

-                    thread_data = (libthreaddata_t *) NULL;

-                }

-            }

+      thread_data = (libthreaddata_t *) malloc(sizeof(libthreaddata_t));

+      

+      if (thread_data) {

+        thread_data->_errno      = 0;

+        thread_data->twentybytes = malloc(20);

+          

+        if (!thread_data->twentybytes) {

+          free(thread_data);

+          thread_data = (libthreaddata_t *) NULL;

+          err         = ENOMEM;

+        }

+        

+        if ((err = NXKeySetValue(key, thread_data))) {

+          free(thread_data->twentybytes);

+          free(thread_data);

+          thread_data = (libthreaddata_t *) NULL;

         }

+      }

     }

+  }

 

-    if (appData)

-        *appData = app_data;

+  if (appData)

+    *appData = app_data;

 

-    if (threadData)

-        *threadData = thread_data;

+  if (threadData)

+    *threadData = thread_data;

 

-    return err;

+  return err;

 }

 

-int DisposeLibraryData

-(

-    void    *data

-)

+int DisposeLibraryData( void    *data)

 {

-    if (data)

-    {

-        void    *tenbytes = ((libdata_t *) data)->tenbytes;

-

-        if (tenbytes)

-            free(tenbytes);

-

-        free(data);

-    }

-

-    return 0;

+  if (data) {

+    void    *tenbytes = ((libdata_t *) data)->tenbytes;

+    

+    if (tenbytes)

+      free(tenbytes);

+    

+    free(data);

+  }

+

+  return 0;

 }

 

-void DisposeThreadData

-(

-    void    *data

-)

+void DisposeThreadData(void    *data)

 {

-    if (data)

-    {

-        void    *twentybytes = ((libthreaddata_t *) data)->twentybytes;

-

-        if (twentybytes)

-            free(twentybytes);

-

-        free(data);

-    }

+  if (data) {

+    void    *twentybytes = ((libthreaddata_t *) data)->twentybytes;

+    

+    if (twentybytes)

+      free(twentybytes);

+    

+    free(data);

+  }

 }

-

-