os400/dlfcn/dlfcn.c

   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 }