1 /**
2 *** dlopen(), dlclose() dlsym(), dlerror() emulation for OS/400.
3 ***
4 *** See Copyright for the status of this software.
5 ***
6 *** Author: Patrick Monnerat <pm@datasphere.ch>, DATASPHERE S.A.
7 **/
8
9 #include <stdarg.h>
10 #include <stdio.h>
11 #include <ctype.h>
12 #include <errno.h>
13 #include <stdlib.h>
14 #include <unistd.h>
15 #include <string.h>
16 #include <dirent.h>
17 #include <pthread.h>
18
19 #include <sys/types.h>
20 #include <sys/stat.h>
21
22 #include <except.h> /* AS400 exceptions. */
23 #include <miptrnam.h> /* MI pointers support. */
24 #include <qusec.h> /* Error structures. */
25 #include <qp0lstdi.h> /* Path to QSYS object name. */
26 #include <qp0z1170.h> /* For Qp0zInitEnv(). */
27 #include <qleawi.h> /* For QleActBndPgmLong() definitions. */
28 #include <qsy.h> /* Qualified name structure. */
29 #include <qmhrtvm.h> /* Retrieve message from message file. */
30
31 #include <mih/rinzstat.h>
32 #include <mih/matactex.h>
33
34 #include "libxml/hash.h"
35 #include "dlfcn.h"
36
37
38 /**
39 *** Maximum internal path length.
40 **/
41
42 #define MAXPATHLEN 5120
43
44
45 /**
46 *** Maximum error string length.
47 **/
48
49 #define MAX_ERR_STR 511
50
51
52 /**
53 *** Field address macro.
54 **/
55
56 #define offset_by(t, b, o) ((t *) ((char *) (b) + (unsigned int) (o)))
57
58
59 /**
60 *** Global flags.
61 **/
62
63 #define INITED 000001 /* Package has been initialized. */
64 #define THREADS 000002 /* Multithreaded job. */
65 #define MULTIBUF 000004 /* One error buffer per thread. */
66
67
68 /**
69 *** DLL handle private structure.
70 **/
71
72 typedef struct {
73 Qle_ABP_Info_Long_t actinfo; /* Activation information. */
74 _SYSPTR pointer; /* Pointer to DLL object. */
75 unsigned int actcount; /* Activation count. */
76 } dlinfo;
77
78
79 /**
80 *** Per-thread structure.
81 **/
82
83 typedef struct {
84 unsigned int lockcount; /* Mutex lock count. */
85 unsigned int iserror; /* Flag error present. */
86 char str[MAX_ERR_STR + 1]; /* Error string buffer. */
87 } dlts_t;
88
89
90 static pthread_mutex_t dlmutex = PTHREAD_MUTEX_INITIALIZER;
91 static xmlHashTablePtr dldir = (xmlHashTablePtr) NULL; /* DLL directory. */
92 static unsigned int dlflags = 0; /* Package flags. */
93 static pthread_key_t dlkey;
94 static dlts_t static_buf; /* Static error buffer. */
95
96
97
98 static void
99 dlthreadterm(void * mem)
100
101 {
102 free(mem);
103 pthread_setspecific(dlkey, NULL);
104 }
105
106
107 static void
108 dlterm(void)
109
110 {
111 void * p;
112
113 if (dlflags & MULTIBUF) {
114 p = pthread_getspecific(dlkey);
115
116 if (p)
117 dlthreadterm(p);
118 }
119
120 if (dlflags & THREADS)
121 pthread_mutex_lock(&dlmutex);
122
123 if (dldir) {
124 xmlHashFree(dldir, (xmlHashDeallocator) NULL);
125 dldir = NULL;
126 }
127
128 if (dlflags & MULTIBUF)
129 pthread_key_delete(dlkey);
130
131 dlflags |= ~(INITED | MULTIBUF);
132 pthread_mutex_unlock(&dlmutex);
133 pthread_mutex_destroy(&dlmutex);
134 }
135
136
137 static void
138 dlinit(void)
139
140 {
141 int locked;
142
143 /**
144 *** Initialize the package.
145 *** Should be call once per process.
146 **/
147
148 locked = !pthread_mutex_lock(&dlmutex);
149
150 if (!(dlflags & INITED)) {
151 dlflags &= ~THREADS;
152
153 if (locked)
154 dlflags |= THREADS;
155
156 Qp0zInitEnv();
157 dldir = xmlHashCreate(16);
158 dlflags &= ~MULTIBUF;
159
160 if (dlflags & THREADS)
161 if (!pthread_key_create(&dlkey, dlthreadterm))
162 dlflags |= MULTIBUF;
163
164 atexit(dlterm);
165 dlflags |= INITED;
166 }
167
168 if (locked)
169 pthread_mutex_unlock(&dlmutex);
170 }
171
172
173 static void
174 dlthreadinit(void)
175
176 {
177 dlts_t * p;
178
179 if (!(dlflags & INITED))
180 dlinit();
181
182 if (dlflags & MULTIBUF) {
183 p = pthread_getspecific(dlkey);
184
185 if (!p) {
186 p = (dlts_t *) malloc(sizeof *p);
187
188 if (p) {
189 p->lockcount = 0;
190 p->iserror = 0;
191
192 if (pthread_setspecific(dlkey, p))
193 free(p);
194 }
195 }
196 }
197 }
198
199
200 static void
201 dllock(void)
202
203 {
204 dlts_t * p;
205
206 if (!(dlflags & THREADS))
207 return;
208
209 if (dlflags & MULTIBUF) {
210 p = pthread_getspecific(dlkey);
211
212 if (p && p->lockcount) {
213 p->lockcount++;
214 return;
215 }
216 }
217 else
218 p = (dlts_t *) NULL;
219
220 if (pthread_mutex_lock(&dlmutex))
221 return;
222
223 if (p)
224 p->lockcount++;
225 }
226
227
228 static void
229 dlunlock(void)
230
231 {
232 dlts_t * p;
233
234 if (!(dlflags & THREADS))
235 return;
236
237 if (dlflags & MULTIBUF) {
238 p = pthread_getspecific(dlkey);
239
240 if (p && p->lockcount > 1) {
241 p->lockcount--;
242 return;
243 }
244 }
245 else
246 p = (dlts_t *) NULL;
247
248 if (pthread_mutex_unlock(&dlmutex))
249 return;
250
251 if (p)
252 p->lockcount--;
253 }
254
255
256 const char *
257 dlerror(void)
258
259 {
260 dlts_t * p;
261
262 dlthreadinit();
263
264 if (!(dlflags & MULTIBUF))
265 p = &static_buf;
266 else if (!(p = (dlts_t *) pthread_getspecific(dlkey)))
267 p = &static_buf;
268
269 if (!p->iserror)
270 return (const char *) NULL;
271
272 p->iserror = 0;
273 return p->str;
274 }
275
276
277 static void
278 dlseterror_from_errno(unsigned int err_no)
279
280 {
281 dlts_t * p;
282
283 if (!(dlflags & MULTIBUF))
284 p = &static_buf;
285 else if (!(p = (dlts_t *) pthread_getspecific(dlkey)))
286 p = &static_buf;
287
288 strcpy(p->str, strerror(err_no));
289 p->iserror = 1;
290 }
291
292
293 static void
294 dlseterror_from_exception(volatile _INTRPT_Hndlr_Parms_T * excp)
295
296 {
297 int i;
298 Qmh_Rtvm_RTVM0300_t * imp;
299 char * cp;
300 _INTRPT_Hndlr_Parms_T * p;
301 dlts_t * q;
302 char rtvmbuf[30000];
303 Qus_EC_t errinfo;
304
305 p = (_INTRPT_Hndlr_Parms_T *) excp;
306 errinfo.Bytes_Provided = 0; /* Exception on error. */
307 QMHRTVM(rtvmbuf, sizeof rtvmbuf, "RTVM0300", p->Msg_Id,
308 "QCPFMSG QSYS ", p->Ex_Data, p->Msg_Data_Len,
309 "*YES ", "*NO ", &errinfo);
310 imp = offset_by(Qmh_Rtvm_RTVM0300_t, rtvmbuf, 0);
311
312 if (!(dlflags & MULTIBUF))
313 q = &static_buf;
314 else if (!(q = (dlts_t *) pthread_getspecific(dlkey)))
315 q = &static_buf;
316
317 if (i = imp->Length_Message_Returned)
318 cp = offset_by(char, imp, imp->Offset_Message_Returned);
319 else if (i = imp->Length_Help_Returned)
320 cp = offset_by(char, imp, imp->Offset_Help_Returned);
321 else {
322 q->iserror = 0;
323 return;
324 }
325
326 q->iserror = 1;
327
328 if (i > sizeof q->str - 1)
329 i = sizeof q->str - 1;
330
331 memcpy(q->str, cp, i);
332 q->str[i] = '\0';
333 }
334
335
336 static int
337 dlparentpath(const char * path, size_t len)
338
339 {
340 if (len <= 1)
341 return len;
342
343 while (path[--len] != '/')
344 ;
345
346 return len? len: 1;
347 }
348
349
350 static int
351 dlmakepath(char * path, size_t pathlen, const char * tail, size_t taillen)
352
353 {
354 int i;
355
356 if (taillen && tail[0] == '/')
357 pathlen = 0;
358
359 for (;;) {
360 while (taillen && *tail == '/') {
361 tail++;
362 taillen--;
363 }
364
365 if (!taillen)
366 break;
367
368 for (i = 0; i < taillen; i++)
369 if (tail[i] == '/')
370 break;
371
372 if (*tail == '.')
373 switch (i) {
374
375 case 2:
376 if (tail[1] != '.')
377 break;
378
379 pathlen = dlparentpath(path, pathlen);
380
381 case 1:
382 tail += i;
383 taillen -= i;
384 continue;
385 }
386
387 if (pathlen + i + 1 >= MAXPATHLEN) {
388 errno = ENAMETOOLONG;
389 return -1;
390 }
391
392 path[pathlen++] = '/';
393 memcpy(path + pathlen, tail, i);
394 pathlen += i;
395 }
396
397 if (!pathlen)
398 path[pathlen++] = '/';
399
400 path[pathlen] = '\0';
401 return pathlen;
402 }
403
404
405 static int
406 dlresolveLink(const char * path, char * buf, size_t bufsiz)
407
408 {
409 int n;
410 int l1;
411 int l2;
412 struct stat sbuf;
413 char buf1[MAXPATHLEN + 1];
414 char buf2[MAXPATHLEN + 1];
415
416 /**
417 *** Resolve symbolic link to IFS object name.
418 **/
419
420 if (!buf) {
421 errno = EFAULT;
422 return -1;
423 }
424
425 if (!path || !*path || !bufsiz) {
426 errno = EINVAL;
427 return -1;
428 }
429
430 if (*path != '/') {
431 if (!getcwd(buf1, sizeof buf1))
432 return -1;
433
434 l1 = strlen(buf1);
435 }
436 else
437 l1 = 0;
438
439 l1 = dlmakepath(buf1, l1, path, strlen(path));
440 n = 0;
441
442 for (;;) {
443 if (l1 < 0)
444 return -1;
445
446 if (n++ >= 256) {
447 errno = ELOOP;
448 return -1;
449 }
450
451 if (lstat(buf1, &sbuf)) {
452 if (errno == ENOENT)
453 break;
454
455 return -1;
456 }
457
458 if (!S_ISLNK(sbuf.st_mode))
459 break;
460
461 if (sbuf.st_size > MAXPATHLEN) {
462 errno = ENAMETOOLONG;
463 return -1;
464 }
465
466 l2 = readlink(buf1, buf2, MAXPATHLEN + 1);
467
468 if (l2 < 0)
469 return -1;
470
471 if (buf2[0] != '/')
472 l1 = dlparentpath(buf1, l1);
473
474 l1 = dlmakepath(buf1, l1, buf2, l2);
475 }
476
477 if (l1 >= bufsiz) {
478 errno = ENAMETOOLONG;
479 return -1;
480 }
481
482 memcpy(buf, buf1, l1 + 1);
483 return l1;
484 }
485
486
487 static int
488 dlGetObjectName(Qp0l_QSYS_Info_t * qsysinfo, const char * dir,
489 int dirlen, const char * link)
490
491 {
492 int n;
493 char * namebuf;
494 Qlg_Path_Name_T * qptp;
495 char pathbuf[sizeof(Qlg_Path_Name_T) + _QP0L_DIR_NAME_LG + 4];
496 Qus_EC_t errinfo;
497 struct stat sbuf;
498
499 /**
500 *** Get QSYS object library/name/member and type corresponding to
501 *** the symbolic `link' in directory `dir'.
502 **/
503
504 if (!qsysinfo) {
505 errno = EFAULT;
506 return -1;
507 }
508
509 if (!dir && !link) {
510 errno = EINVAL;
511 return -1;
512 }
513
514 qptp = (Qlg_Path_Name_T *) pathbuf;
515 namebuf = pathbuf + sizeof(Qlg_Path_Name_T);
516 n = 0;
517
518 /**
519 *** Build full path.
520 **/
521
522 if (dir) {
523 if (dirlen < 0 || dirlen > _QP0L_DIR_NAME_LG + 4)
524 dirlen = _QP0L_DIR_NAME_LG + 4;
525
526 while (*dir && n < dirlen)
527 namebuf[n++] = *dir++;
528 }
529
530 if (n && namebuf[n - 1] == '/')
531 n--;
532
533 if (link) {
534 if (*link && *link != '/' && n < _QP0L_DIR_NAME_LG + 4)
535 namebuf[n++] = '/';
536
537 while (*link && n < _QP0L_DIR_NAME_LG + 4)
538 namebuf[n++] = *link++;
539 }
540
541 if (!n || n > _QP0L_DIR_NAME_LG) {
542 errno = ENAMETOOLONG;
543 return -1;
544 }
545
546 namebuf[n] = '\0';
547 n = dlresolveLink(namebuf, namebuf, _QP0L_DIR_NAME_LG + 1);
548
549 if (n == -1)
550 return -1;
551
552 if (stat(namebuf, &sbuf))
553 return -1;
554
555 memset((char *) qptp, 0, sizeof *qptp);
556 qptp->Path_Length = n;
557 qptp->Path_Name_Delimiter[0] = '/';
558 errinfo.Bytes_Provided = sizeof errinfo;
559 Qp0lCvtPathToQSYSObjName(qptp, qsysinfo, "QSYS0100", sizeof *qsysinfo,
560 0, &errinfo);
561 return errinfo.Bytes_Available? -1: 0;
562 }
563
564
565 static const char *
566 getcomponent(char * dst, const char * src)
567
568 {
569 int i;
570
571 /**
572 *** Get a path component of at most 10 characters and
573 *** map it to upper case.
574 *** Return the address of the next delimiter in source.
575 **/
576
577 for (i = 0;; src++) {
578 if (!*src || *src == ' ' || *src == '/') {
579 *dst = '\0';
580 return src;
581 }
582
583 if (i < 10) {
584 *dst++ = toupper(*src);
585 i++;
586 }
587 }
588 }
589
590
591 static int
592 dlpath2QSYS(Qp0l_QSYS_Info_t * qsysinfo, const char * path, const char * dftlib)
593
594 {
595 unsigned int flags;
596 char * cp;
597
598 /**
599 *** Convert the given path to a QSYS object name.
600 *** Syntax rules for paths are:
601 ***
602 *** '/'+ [ <library> [ '/'+ <file> [ '/'+ <member> ] ] '/'* ]
603 *** <library> '/'+ <file> [ '/'+ <member> ] '/'*
604 *** <file> '/'*
605 ***
606 *** If default library is not given, *LIBL is assumed.
607 *** Components may no contain spaces. They are translated to
608 *** uppercase. Only the first 10 characters are significant.
609 *** There is no check for the validity of the given components and
610 *** for the object existence.
611 *** Component types are not in the path, but generated internally.
612 *** CCSID is not processed.
613 ***
614 *** Return 0 upon success, else -1.
615 **/
616
617 if (!qsysinfo || !path) {
618 errno = EFAULT;
619 return -1;
620 }
621
622 /**
623 *** Strip leading spaces.
624 **/
625
626 while (*path == ' ')
627 path++;
628
629 /**
630 *** Check for null path.
631 **/
632
633 if (!*path) {
634 errno = EINVAL;
635 return -1;
636 }
637
638 /**
639 *** Preset the result structure.
640 **/
641
642 memset((char *) qsysinfo, 0, sizeof *qsysinfo);
643
644 /**
645 *** Determine the format.
646 **/
647
648 if (*path == '/') {
649 /**
650 *** Library component present.
651 **/
652
653 while (*++path == '/')
654 ;
655
656 if (!*path || *path == ' ')
657 strcpy(qsysinfo->Lib_Name, "QSYS");
658 else
659 path = getcomponent(qsysinfo->Lib_Name, path);
660
661 /**
662 *** Check for file component and get it.
663 **/
664
665 if (*path == '/') {
666 while (*++path == '/')
667 ;
668
669 if (*path && *path != ' ')
670 path = getcomponent(qsysinfo->Obj_Name, path);
671 }
672 }
673 else {
674 /**
675 *** The mandatory component is the <file>.
676 **/
677
678 path = getcomponent(qsysinfo->Obj_Name, path);
679
680 while (*path == '/')
681 path++;
682
683 /**
684 *** If there is a second component, move the first to
685 *** the library name and parse the file name.
686 **/
687
688 if (*path && *path != ' ') {
689 strcpy(qsysinfo->Lib_Name, qsysinfo->Obj_Name);
690 memset(qsysinfo->Obj_Name, 0,
691 sizeof qsysinfo->Obj_Name);
692 path = getcomponent(qsysinfo->Obj_Name, path);
693 }
694 else
695 strcpy(qsysinfo->Lib_Name, dftlib? dftlib: "*LIBL");
696 }
697
698 /**
699 *** Check and set-up member.
700 **/
701
702 while (*path == '/')
703 path++;
704
705 if (*path && *path != ' ') {
706 path = getcomponent(qsysinfo->Mbr_Name, path);
707 strcpy(qsysinfo->Mbr_Type, "*MBR");
708
709 while (*path == '/')
710 path++;
711 }
712
713 strcpy(qsysinfo->Lib_Type, "*LIB");
714
715 if (qsysinfo->Obj_Name[0])
716 strcpy(qsysinfo->Obj_Type, "*FILE");
717
718 qsysinfo->Bytes_Returned = sizeof *qsysinfo;
719 qsysinfo->Bytes_Available = sizeof *qsysinfo;
720
721 /**
722 *** Strip trailing spaces.
723 **/
724
725 while (*path == ' ')
726 path++;
727
728 if (*path) {
729 errno = EINVAL;
730 return -1;
731 }
732
733 return 0;
734 }
735
736
737 static int
738 dl_ifs_link(Qp0l_QSYS_Info_t * qsysinfo, const char * pathname)
739
740 {
741 /**
742 *** If `pathname' is a link found in IFS, set `qsysinfo' to its
743 *** DB2 name.
744 *** Return 0 if OK, else -1.
745 **/
746
747 return dlGetObjectName(qsysinfo, (const char *) NULL, 0, pathname);
748 }
749
750
751 static int
752 dl_path_link(Qp0l_QSYS_Info_t * qsysinfo, const char * pathvar,
753 const char * filename, int (* testproc)(const Qp0l_QSYS_Info_t *))
754
755 {
756 const char * p;
757 const char * q;
758 unsigned int i;
759 const char * path;
760
761 /**
762 *** If `filename' is not a path and is a link found in one of the
763 *** colon-separated paths in environment variable `pathvar',
764 *** set `qsysinfo' to its DB2 name.
765 *** Return 0 if OK, else -1.
766 **/
767
768 i = _QP0L_DIR_NAME_LG;
769
770 for (p = filename; *p; p++)
771 if (*p == '/' || !--i)
772 return -1; /* Too long or a path. */
773
774 /**
775 *** Make sure we have the LD_LIBRARY_PATH environment
776 *** variable value.
777 **/
778
779 path = getenv(pathvar);
780
781 if (!path)
782 return -1; /* No path list. */
783
784 /**
785 *** Try in each path listed.
786 **/
787
788 q = path;
789
790 if (!*q)
791 return -1; /* No path list. */
792
793 for (;;) {
794 for (p = q; *p && *p != ':'; p++)
795 ;
796
797 if (p > q) /* Ignore null path. */
798 if (!dlGetObjectName(qsysinfo, q, p - q, filename))
799 if (!testproc || (*testproc)(qsysinfo))
800 return 0; /* Found: return. */
801
802 if (!*p)
803 break;
804
805 q = p + 1;
806 }
807
808 errno = ENOENT;
809 return -1;
810 }
811
812
813 static int
814 dl_DB2_path(Qp0l_QSYS_Info_t * qsysinfo, const char * pathname)
815
816 {
817 if (dlpath2QSYS(qsysinfo, pathname, (const char *) NULL))
818 return -1;
819
820 if (qsysinfo->Mbr_Type[0])
821 return -1; /* Service program may not have members. */
822
823 if (!qsysinfo->Obj_Type[0])
824 return -1; /* Object must be specified. */
825
826 strcpy(qsysinfo->Obj_Type, "*SRVPGM"); /* Set our object type. */
827 return 0;
828 }
829
830
831 static int
832 dl_DB2_name(char * dst, const char * name)
833
834 {
835 int i;
836
837 for (i = 0; i < 10; i++) {
838 switch (*name) {
839
840 default:
841 if (!islower(*name))
842 break;
843
844 case '\0':
845 case '/':
846 case ' ':
847 return -1;
848 }
849
850 *dst++ = *name++;
851 }
852
853 if (!i)
854 return -1;
855
856 *dst = '\0';
857 return 0;
858 }
859
860
861 static int
862 dl_qualified_object(Qp0l_QSYS_Info_t * qsysinfo, const char * pathname)
863
864 {
865 memset((char *) qsysinfo, 0, sizeof *qsysinfo);
866
867 if (dl_DB2_name(qsysinfo->Obj_Name, pathname) ||
868 dl_DB2_name(qsysinfo->Lib_Name, pathname + 10))
869 return -1;
870
871 strcpy(qsysinfo->Lib_Type, "*LIB");
872 strcpy(qsysinfo->Obj_Type, "*SRVPGM");
873 return 0;
874 }
875
876
877 static int
878 dl_lib_object(Qp0l_QSYS_Info_t * qsysinfo,
879 const char * libname, const char * pathname)
880
881 {
882 int i;
883 char * cp;
884
885 strcpy(qsysinfo->Lib_Name, libname);
886 strcpy(qsysinfo->Lib_Type, "*LIB");
887 strcpy(qsysinfo->Obj_Type, "*SRVPGM");
888 cp = qsysinfo->Obj_Name;
889
890 while (*pathname == ' ')
891 pathname++;
892
893 for (i = 0;; pathname++) {
894 switch (*pathname) {
895
896 case '\0':
897 case ' ':
898 break;
899
900 case '/':
901 return -1;
902
903 default:
904 if (i < 10)
905 *cp++ = toupper(*pathname);
906
907 i++;
908 continue;
909 }
910
911 break;
912 }
913
914 while (*pathname == ' ')
915 pathname++;
916
917 if (!i || *pathname)
918 return -1;
919
920 *cp = '\0';
921 return 0;
922 }
923
924
925 static int
926 dl_is_srvpgm(const Qp0l_QSYS_Info_t * qsysinfo)
927
928 {
929 struct stat sbuf;
930 char namebuf[100];
931
932 if (!qsysinfo->Lib_Name[0] || strcmp(qsysinfo->Lib_Type, "*LIB") ||
933 !qsysinfo->Obj_Name[0] || strcmp(qsysinfo->Obj_Type, "*SRVPGM") ||
934 qsysinfo->Mbr_Name[0] || qsysinfo->Mbr_Type[0])
935 return 0;
936
937 /**
938 *** Build the IFS path name for the DB2 object.
939 **/
940
941 sprintf(namebuf, "%s/%s.LIB/%s.SRVPGM",
942 strcmp(qsysinfo->Lib_Name, "QSYS")? "/QSYS.LIB": "",
943 qsysinfo->Lib_Name, qsysinfo->Obj_Name);
944
945 return stat(namebuf, &sbuf) == 0;
946 }
947
948
949 static int
950 dlreinit(dlinfo * dlip)
951
952 {
953 RINZ_TEMPL_T t;
954 RINZ_TEMPL_T * p;
955 volatile _INTRPT_Hndlr_Parms_T excbuf;
956
957 if (dlip->actinfo.Flags & QLE_ABP_WAS_ACTIVE)
958 return 0;
959
960 /**
961 *** Attempt to reinitialize the service program that was loaded.
962 *** The service program must be created to allow re-initialization:
963 *** ALWRINZ(*YES) for this to work. The default is
964 *** ALWRINZ(*NO).
965 **/
966
967 #pragma exception_handler(err, excbuf, 0, _C2_MH_ESCAPE, _CTLA_HANDLE_NO_MSG)
968 p = &t;
969 t.rinz_pgm = dlip->pointer;
970 t.rinz_agpmk = dlip->actinfo.Act_Grp_Mark;
971 _RINZSTAT(p);
972 #pragma disable_handler
973
974 return 0;
975
976 err:
977 if (!memcmp((char *) excbuf.Msg_Id, "MCH4421", 7))
978 return 0; /* Program cannot be reinitialized. */
979
980 dlseterror_from_exception(&excbuf);
981 return -1;
982 }
983
984
985 void *
986 dlsym(void * handle, const char * symbol)
987
988 {
989 dlinfo * dlip;
990 void * p;
991 int export_type;
992 Qus_EC_t errinfo;
993 volatile _INTRPT_Hndlr_Parms_T excbuf;
994 static int zero = 0;
995
996 dlthreadinit();
997
998 if (!handle || !symbol) {
999 dlseterror_from_errno(EFAULT);
1000 return (void *) NULL;
1001 }
1002
1003 dlip = (dlinfo *) handle;
1004
1005 #pragma exception_handler(error, excbuf, 0, _C2_MH_ESCAPE, _CTLA_HANDLE_NO_MSG)
1006 errinfo.Bytes_Provided = 0;
1007 QleGetExpLong(&dlip->actinfo.Act_Mark, &zero, &zero,
1008 (char *) symbol, &p, &export_type, &errinfo);
1009 return p;
1010 #pragma disable_handler
1011
1012 error:
1013 dlseterror_from_exception(&excbuf);
1014 return (void *) NULL;
1015 }
1016
1017
1018 int
1019 dlclose(void * handle)
1020
1021 {
1022 dlinfo * dlip;
1023 void (* _fini)(void);
1024
1025 dlthreadinit();
1026
1027 if (!handle) {
1028 dlseterror_from_errno(EFAULT);
1029 return -1;
1030 }
1031
1032 dlip = (dlinfo *) handle;
1033
1034 if (dlip->actcount) {
1035 if (--(dlip->actcount))
1036 return 0;
1037
1038 if (_fini = dlsym(handle, "_fini"))
1039 (*_fini)();
1040 }
1041
1042 return dlreinit(dlip);
1043 }
1044
1045
1046 static void *
1047 dlopenqsys(const Qp0l_QSYS_Info_t * dllinfo)
1048
1049 {
1050 dlinfo * dlip;
1051 dlinfo * dlip2;
1052 void (* _init)(void);
1053 unsigned int i;
1054 _SYSPTR pgmptr;
1055 unsigned long long actmark;
1056 Qus_EC_t errinfo;
1057 char actmarkstr[2 * sizeof actmark + 1];
1058 static int actinfo_size = sizeof dlip->actinfo;
1059 volatile _INTRPT_Hndlr_Parms_T excbuf;
1060
1061 /**
1062 *** Capture any type of error and if any occurs,
1063 *** return not found.
1064 **/
1065
1066 #pragma exception_handler(error1, excbuf, 0, _C2_MH_ESCAPE, _CTLA_HANDLE_NO_MSG)
1067 pgmptr = rslvsp(WLI_SRVPGM, (char *) dllinfo->Obj_Name,
1068 (char *) dllinfo->Lib_Name ,_AUTH_NONE);
1069
1070 if (!pgmptr) {
1071 errno = ENOENT;
1072 return (void *) NULL;
1073 }
1074
1075 /**
1076 *** Create a new DLL info block.
1077 **/
1078
1079 dlip = (dlinfo *) malloc(sizeof *dlip);
1080
1081 if (!dlip)
1082 return (void *) NULL; /* Cannot create block. */
1083 #pragma disable_handler
1084
1085 dllock();
1086
1087 #pragma exception_handler(error2, excbuf, 0, _C2_MH_ESCAPE, _CTLA_HANDLE_NO_MSG)
1088 memset((char *) dlip, 0, sizeof *dlip);
1089 dlip->pointer = pgmptr;
1090
1091 /**
1092 *** Activate the DLL.
1093 **/
1094
1095 errinfo.Bytes_Provided = 0;
1096 QleActBndPgmLong(&pgmptr, &actmark,
1097 &dlip->actinfo, &actinfo_size, &errinfo);
1098 dlip->actinfo.Act_Mark = actmark;
1099
1100 /**
1101 *** Dummy string encoding activation mark to use as hash table key.
1102 **/
1103
1104 for (i = 0; actmark; actmark >>= 6)
1105 actmarkstr[i++] = 0x40 + (actmark & 0x3F);
1106
1107 actmarkstr[i] = '\0';
1108
1109 /**
1110 *** Check if already activated.
1111 **/
1112
1113 dlip2 = (dlinfo *) xmlHashLookup(dldir, actmarkstr);
1114
1115 if (dlip2) {
1116 free((char *) dlip);
1117 dlip = dlip2;
1118 }
1119 else if (xmlHashAddEntry(dldir, (const xmlChar *) actmarkstr, dlip)) {
1120 dlreinit(dlip);
1121 free((char *) dlip);
1122 dlunlock();
1123 return (void *) NULL;
1124 }
1125 #pragma disable_handler
1126
1127 #pragma exception_handler(error2, excbuf, 0, _C2_MH_ESCAPE, _CTLA_HANDLE_NO_MSG)
1128
1129 /**
1130 *** Bump activation counter.
1131 **/
1132
1133 if (!(dlip->actcount++) && (_init = dlsym(dlip, "_init")))
1134 (*_init)();
1135
1136 dlunlock();
1137
1138 /**
1139 *** Return the handle.
1140 **/
1141
1142 return (void *) dlip;
1143 #pragma disable_handler
1144
1145 error2:
1146 free((char *) dlip);
1147 dlunlock();
1148
1149 error1:
1150 dlseterror_from_exception(&excbuf);
1151 return (void *) NULL;
1152 }
1153
1154
1155 void *
1156 dlopen(const char * filename, int flag)
1157
1158 {
1159 void * dlhandle;
1160 int sverrno;
1161 Qp0l_QSYS_Info_t dllinfo;
1162
1163 sverrno = errno;
1164 errno = 0;
1165
1166 dlthreadinit();
1167
1168 if (!filename) {
1169 dlseterror_from_errno(EFAULT);
1170 errno = sverrno;
1171 return NULL;
1172 }
1173
1174 /**
1175 *** Try to locate the object in the following order:
1176 *** _ `filename' is an IFS path.
1177 *** _ `filename' is not a path and resides in one of
1178 *** LD_LIBRARY_PATH colon-separated paths.
1179 *** _ `filename' is not a path and resides in one of
1180 *** PATH colon-separated paths.
1181 *** _ `filename' is a DB2 path (as /library/object).
1182 *** _ `filename' is a qualified object name.
1183 *** _ `filename' is an object in *CURLIB.
1184 *** _ `filename' is an object in *LIBL.
1185 **/
1186
1187 if (!dl_ifs_link(&dllinfo, filename) && dl_is_srvpgm(&dllinfo))
1188 dlhandle = dlopenqsys(&dllinfo);
1189 else if (!dl_path_link(&dllinfo,
1190 "LD_LIBRARY_PATH", filename, dl_is_srvpgm))
1191 dlhandle = dlopenqsys(&dllinfo);
1192 else if (!dl_path_link(&dllinfo, "PATH", filename, dl_is_srvpgm))
1193 dlhandle = dlopenqsys(&dllinfo);
1194 else if (!dl_DB2_path(&dllinfo, filename) && dl_is_srvpgm(&dllinfo))
1195 dlhandle = dlopenqsys(&dllinfo);
1196 else if (!dl_qualified_object(&dllinfo, filename) &&
1197 dl_is_srvpgm(&dllinfo))
1198 dlhandle = dlopenqsys(&dllinfo);
1199 else if (!dl_lib_object(&dllinfo, "*CURLIB", filename) &&
1200 dl_is_srvpgm(&dllinfo))
1201 dlhandle = dlopenqsys(&dllinfo);
1202 else if (!dl_lib_object(&dllinfo, "*LIBL", filename) &&
1203 dl_is_srvpgm(&dllinfo))
1204 dlhandle = dlopenqsys(&dllinfo);
1205 else
1206 dlhandle = NULL;
1207
1208 if (!dlhandle && errno)
1209 dlseterror_from_errno(errno);
1210
1211 errno = sverrno;
1212 return dlhandle;
1213 }