2
0

nwlib.c 9.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327
  1. /***************************************************************************
  2. * _ _ ____ _
  3. * Project ___| | | | _ \| |
  4. * / __| | | | |_) | |
  5. * | (__| |_| | _ <| |___
  6. * \___|\___/|_| \_\_____|
  7. *
  8. * Copyright (C) 1998 - 2020, Daniel Stenberg, <daniel@haxx.se>, et al.
  9. *
  10. * This software is licensed as described in the file COPYING, which
  11. * you should have received as part of this distribution. The terms
  12. * are also available at https://curl.se/docs/copyright.html.
  13. *
  14. * You may opt to use, copy, modify, merge, publish, distribute and/or sell
  15. * copies of the Software, and permit persons to whom the Software is
  16. * furnished to do so, under the terms of the COPYING file.
  17. *
  18. * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  19. * KIND, either express or implied.
  20. *
  21. ***************************************************************************/
  22. #include "curl_setup.h"
  23. #ifdef NETWARE /* Novell NetWare */
  24. #ifdef __NOVELL_LIBC__
  25. /* For native LibC-based NLM we need to register as a real lib. */
  26. #include <library.h>
  27. #include <netware.h>
  28. #include <screen.h>
  29. #include <nks/thread.h>
  30. #include <nks/synch.h>
  31. #include "curl_memory.h"
  32. /* The last #include file should be: */
  33. #include "memdebug.h"
  34. struct libthreaddata {
  35. int _errno;
  36. void *twentybytes;
  37. };
  38. struct libdata {
  39. int x;
  40. int y;
  41. int z;
  42. void *tenbytes;
  43. NXKey_t perthreadkey; /* if -1, no key obtained... */
  44. NXMutex_t *lock;
  45. };
  46. int gLibId = -1;
  47. void *gLibHandle = (void *) NULL;
  48. rtag_t gAllocTag = (rtag_t) NULL;
  49. NXMutex_t *gLibLock = (NXMutex_t *) NULL;
  50. /* internal library function prototypes... */
  51. int DisposeLibraryData(void *);
  52. void DisposeThreadData(void *);
  53. int GetOrSetUpData(int id, struct libdata **data,
  54. struct libthreaddata **threaddata);
  55. int _NonAppStart(void *NLMHandle,
  56. void *errorScreen,
  57. const char *cmdLine,
  58. const char *loadDirPath,
  59. size_t uninitializedDataLength,
  60. void *NLMFileHandle,
  61. int (*readRoutineP)(int conn,
  62. void *fileHandle, size_t offset,
  63. size_t nbytes,
  64. size_t *bytesRead,
  65. void *buffer),
  66. size_t customDataOffset,
  67. size_t customDataSize,
  68. int messageCount,
  69. const char **messages)
  70. {
  71. NX_LOCK_INFO_ALLOC(liblock, "Per-Application Data Lock", 0);
  72. #ifndef __GNUC__
  73. #pragma unused(cmdLine)
  74. #pragma unused(loadDirPath)
  75. #pragma unused(uninitializedDataLength)
  76. #pragma unused(NLMFileHandle)
  77. #pragma unused(readRoutineP)
  78. #pragma unused(customDataOffset)
  79. #pragma unused(customDataSize)
  80. #pragma unused(messageCount)
  81. #pragma unused(messages)
  82. #endif
  83. /*
  84. * Here we process our command line, post errors (to the error screen),
  85. * perform initializations and anything else we need to do before being able
  86. * to accept calls into us. If we succeed, we return non-zero and the NetWare
  87. * Loader will leave us up, otherwise we fail to load and get dumped.
  88. */
  89. gAllocTag = AllocateResourceTag(NLMHandle,
  90. "<library-name> memory allocations",
  91. AllocSignature);
  92. if(!gAllocTag) {
  93. OutputToScreen(errorScreen, "Unable to allocate resource tag for "
  94. "library memory allocations.\n");
  95. return -1;
  96. }
  97. gLibId = register_library(DisposeLibraryData);
  98. if(gLibId < -1) {
  99. OutputToScreen(errorScreen, "Unable to register library with kernel.\n");
  100. return -1;
  101. }
  102. gLibHandle = NLMHandle;
  103. gLibLock = NXMutexAlloc(0, 0, &liblock);
  104. if(!gLibLock) {
  105. OutputToScreen(errorScreen, "Unable to allocate library data lock.\n");
  106. return -1;
  107. }
  108. return 0;
  109. }
  110. /*
  111. * Here we clean up any resources we allocated. Resource tags is a big part
  112. * of what we created, but NetWare doesn't ask us to free those.
  113. */
  114. void _NonAppStop(void)
  115. {
  116. (void) unregister_library(gLibId);
  117. NXMutexFree(gLibLock);
  118. }
  119. /*
  120. * This function cannot be the first in the file for if the file is linked
  121. * first, then the check-unload function's offset will be nlmname.nlm+0
  122. * which is how to tell that there isn't one. When the check function is
  123. * first in the linked objects, it is ambiguous. For this reason, we will
  124. * put it inside this file after the stop function.
  125. *
  126. * Here we check to see if it's alright to ourselves to be unloaded. If not,
  127. * we return a non-zero value. Right now, there isn't any reason not to allow
  128. * it.
  129. */
  130. int _NonAppCheckUnload(void)
  131. {
  132. return 0;
  133. }
  134. int GetOrSetUpData(int id, struct libdata **appData,
  135. struct libthreaddata **threadData)
  136. {
  137. int err;
  138. struct libdata *app_data;
  139. struct libthreaddata *thread_data;
  140. NXKey_t key;
  141. NX_LOCK_INFO_ALLOC(liblock, "Application Data Lock", 0);
  142. err = 0;
  143. thread_data = (struct libthreaddata_t *) NULL;
  144. /*
  145. * Attempt to get our data for the application calling us. This is where we
  146. * store whatever application-specific information we need to carry in
  147. * support of calling applications.
  148. */
  149. app_data = (struct libdata *) get_app_data(id);
  150. if(!app_data) {
  151. /*
  152. * This application hasn't called us before; set up application AND
  153. * per-thread data. Of course, just in case a thread from this same
  154. * application is calling us simultaneously, we better lock our application
  155. * data-creation mutex. We also need to recheck for data after we acquire
  156. * the lock because WE might be that other thread that was too late to
  157. * create the data and the first thread in will have created it.
  158. */
  159. NXLock(gLibLock);
  160. app_data = (struct libdata *) get_app_data(id);
  161. if(!app_data) {
  162. app_data = calloc(1, sizeof(struct libdata));
  163. if(app_data) {
  164. app_data->tenbytes = malloc(10);
  165. app_data->lock = NXMutexAlloc(0, 0, &liblock);
  166. if(!app_data->tenbytes || !app_data->lock) {
  167. if(app_data->lock)
  168. NXMutexFree(app_data->lock);
  169. free(app_data->tenbytes);
  170. free(app_data);
  171. app_data = (libdata_t *) NULL;
  172. err = ENOMEM;
  173. }
  174. if(app_data) {
  175. /*
  176. * Here we burn in the application data that we were trying to get
  177. * by calling get_app_data(). Next time we call the first function,
  178. * we'll get this data we're just now setting. We also go on here to
  179. * establish the per-thread data for the calling thread, something
  180. * we'll have to do on each application thread the first time
  181. * it calls us.
  182. */
  183. err = set_app_data(gLibId, app_data);
  184. if(err) {
  185. if(app_data->lock)
  186. NXMutexFree(app_data->lock);
  187. free(app_data->tenbytes);
  188. free(app_data);
  189. app_data = (libdata_t *) NULL;
  190. err = ENOMEM;
  191. }
  192. else {
  193. /* create key for thread-specific data... */
  194. err = NXKeyCreate(DisposeThreadData, (void *) NULL, &key);
  195. if(err) /* (no more keys left?) */
  196. key = -1;
  197. app_data->perthreadkey = key;
  198. }
  199. }
  200. }
  201. }
  202. NXUnlock(gLibLock);
  203. }
  204. if(app_data) {
  205. key = app_data->perthreadkey;
  206. if(key != -1 /* couldn't create a key? no thread data */
  207. && !(err = NXKeyGetValue(key, (void **) &thread_data))
  208. && !thread_data) {
  209. /*
  210. * Allocate the per-thread data for the calling thread. Regardless of
  211. * whether there was already application data or not, this may be the
  212. * first call by a new thread. The fact that we allocation 20 bytes on
  213. * a pointer is not very important, this just helps to demonstrate that
  214. * we can have arbitrarily complex per-thread data.
  215. */
  216. thread_data = malloc(sizeof(struct libthreaddata));
  217. if(thread_data) {
  218. thread_data->_errno = 0;
  219. thread_data->twentybytes = malloc(20);
  220. if(!thread_data->twentybytes) {
  221. free(thread_data);
  222. thread_data = (struct libthreaddata *) NULL;
  223. err = ENOMEM;
  224. }
  225. err = NXKeySetValue(key, thread_data);
  226. if(err) {
  227. free(thread_data->twentybytes);
  228. free(thread_data);
  229. thread_data = (struct libthreaddata *) NULL;
  230. }
  231. }
  232. }
  233. }
  234. if(appData)
  235. *appData = app_data;
  236. if(threadData)
  237. *threadData = thread_data;
  238. return err;
  239. }
  240. int DisposeLibraryData(void *data)
  241. {
  242. if(data) {
  243. void *tenbytes = ((libdata_t *) data)->tenbytes;
  244. free(tenbytes);
  245. free(data);
  246. }
  247. return 0;
  248. }
  249. void DisposeThreadData(void *data)
  250. {
  251. if(data) {
  252. void *twentybytes = ((struct libthreaddata *) data)->twentybytes;
  253. free(twentybytes);
  254. free(data);
  255. }
  256. }
  257. #else /* __NOVELL_LIBC__ */
  258. /* For native CLib-based NLM seems we can do a bit more simple. */
  259. #include <nwthread.h>
  260. int main(void)
  261. {
  262. /* initialize any globals here... */
  263. /* do this if any global initializing was done
  264. SynchronizeStart();
  265. */
  266. ExitThread(TSR_THREAD, 0);
  267. return 0;
  268. }
  269. #endif /* __NOVELL_LIBC__ */
  270. #else /* NETWARE */
  271. #ifdef __POCC__
  272. # pragma warn(disable:2024) /* Disable warning #2024: Empty input file */
  273. #endif
  274. #endif /* NETWARE */