Source

gd-libgd / netware / nwlibc.c

Full commit
guenter 1fe7985 



guenter a31cbb8 
guenter 1fe7985 











pierrejoye e20413b 


guenter 1fe7985 

pierrejoye e20413b 






guenter 1fe7985 





















pierrejoye e20413b 
guenter 1fe7985 





pierrejoye e20413b 
guenter 1fe7985 












pierrejoye e20413b 







guenter 1fe7985 
pierrejoye e20413b 




guenter 1fe7985 
pierrejoye e20413b 
guenter 1fe7985 
pierrejoye e20413b 



guenter 1fe7985 
pierrejoye e20413b 
guenter 1fe7985 
pierrejoye e20413b 
guenter 1fe7985 
pierrejoye e20413b 



guenter 1fe7985 
pierrejoye e20413b 
guenter 1fe7985 







pierrejoye e20413b 

guenter 1fe7985 














pierrejoye e20413b 
guenter 1fe7985 








pierrejoye e20413b 



















































































































guenter 1fe7985 






pierrejoye e20413b 

guenter 1fe7985 
pierrejoye e20413b 

guenter 1fe7985 
pierrejoye e20413b 

guenter 1fe7985 
pierrejoye e20413b 
guenter 1fe7985 






pierrejoye e20413b 

guenter 1fe7985 
pierrejoye e20413b 

guenter 1fe7985 
pierrejoye e20413b 

guenter 1fe7985 

/*********************************************************************
 * Universal NetWare library stub.                                   *
 * written by Ulrich Neuman and given to OpenSource copyright-free.  *
 * version: 1.0                                                      *
 * $Id$
 *********************************************************************/

#include <errno.h>
#include <string.h>
#include <stdlib.h>
#include <library.h>
#include <netware.h>
#include <screen.h>
#include <nks/thread.h>
#include <nks/synch.h>


typedef struct {
	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;
} libdata_t;

int         gLibId      = -1;
void        *gLibHandle = (void *) NULL;
rtag_t      gAllocTag   = (rtag_t) NULL;
NXMutex_t   *gLibLock   = (NXMutex_t *) NULL;

/* internal library function prototypes... */
int     DisposeLibraryData ( void * );
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
)
{
	NX_LOCK_INFO_ALLOC(liblock, "Per-Application Data Lock", 0);

#ifndef __GNUC__
#pragma unused(cmdLine)
#pragma unused(loadDirPath)
#pragma unused(uninitializedDataLength)
#pragma unused(NLMFileHandle)
#pragma unused(readRoutineP)
#pragma unused(customDataOffset)
#pragma unused(customDataSize)
#pragma unused(messageCount)
#pragma unused(messages)
#endif

	/*
	** Here we process our command line, post errors (to the error screen),
	** perform initializations and anything else we need to do before being able
	** 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);

	if (!gAllocTag) {
		OutputToScreen(errorScreen, "Unable to allocate resource tag for "
		               "library memory allocations.\n");
		return -1;
	}

	gLibId = register_library(DisposeLibraryData);

	if (gLibId < -1) {
		OutputToScreen(errorScreen, "Unable to register library with kernel.\n");
		return -1;
	}

	gLibHandle = NLMHandle;

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

	if (!gLibLock) {
		OutputToScreen(errorScreen, "Unable to allocate library data lock.\n");
		return -1;
	}

	return 0;
}

/*
** Here we clean up any resources we allocated. Resource tags is a big part
** of what we created, but NetWare doesn't ask us to free those.
*/
void _NonAppStop( void )
{
	(void) unregister_library(gLibId);
	NXMutexFree(gLibLock);
}

/*
** This function cannot be the first in the file for if the file is linked
** first, then the check-unload function's offset will be nlmname.nlm+0
** which is how to tell that there isn't one. When the check function is
** first in the linked objects, it is ambiguous. For this reason, we will
** put it inside this file after the stop function.
**
** Here we check to see if it's alright to ourselves to be unloaded. If not,
** we return a non-zero value. Right now, there isn't any reason not to allow
** it.
*/
int  _NonAppCheckUnload( void )
{
	return 0;
}

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);

	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);

	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
		** us simultaneously, we better lock our application data-creation mutex. We
		** also need to recheck for data after we acquire the lock because WE might be
		** 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) {
					/*
					** 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
					** we're just now setting. We also go on here to establish the per-thread data
					** 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;
					}
				}
			}
		}

		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
			** a new thread. The fact that we allocation 20 bytes on a pointer is not very
			** 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;
				}
			}
		}
	}

	if (appData)
		*appData = app_data;

	if (threadData)
		*threadData = thread_data;

	return err;
}

int DisposeLibraryData
(
    void    *data
)
{
	if (data) {
		void    *tenbytes = ((libdata_t *) data)->tenbytes;

		if (tenbytes)
			free(tenbytes);

		free(data);
	}

	return 0;
}

void DisposeThreadData
(
    void    *data
)
{
	if (data) {
		void    *twentybytes = ((libthreaddata_t *) data)->twentybytes;

		if (twentybytes)
			free(twentybytes);

		free(data);
	}
}