# Lib/ctype support for cdll interface to dlopen() for AIX
# Author: M Felt, aixtools.net, May 2016
#
# dlopen() is an interface to AIX initAndLoad() - these are documented at:
# https://www.ibm.com/support/knowledgecenter/ssw_aix_53/com.ibm.aix.basetechref/doc/basetrf1/dlopen.htm?lang=en
# https://www.ibm.com/support/knowledgecenter/ssw_aix_53/com.ibm.aix.basetechref/doc/basetrf1/load.htm?lang=en
#
# Some basics
# when given an argument such as -lFOO to the AIX loader and a symbol must be resolved
# the AIX ld searches LIBPATH for an archive named libFOO.a. When found, it then searches archive members
# for a member that resolves the symbol.
# When an archive (.a) is not found, the search starts again, but looking for a file named libFOO.so
#
# when a full or partial path information is given dlopen() does not search LIBPATH - only the path specified
#
# ctypes._aixutil.find_library() searches archives for members
# if a member is not found it looks for "name.so" in the same directory paths
#
# find_library("libFOO.so") is not an intended usage (looks for libFOO.so.a(libFOO.so.so) or libFOO.so.so)
# That may be suitable for CDLL(), but not for find_library()
# Much code is written as: CDLL(find_library("libFOO"))
# or                     : CDLL((find_library("FOO"))
#
# examples:
#   aix.find_library("libiconv")    => libiconv.a(shr4_64.o) || libiconv.a(shr4.o) (64 or 32 bit modes)
#   aix.find_library("libintl")     => libintl.a(libintl.so.1) or libintl.a(libintl.so.8) depending on the 
# version of GNU gettext installed

# when packaging python - a packager (for AIX) may want to include "export LDFLAGS=-L${prefix}/lib"
# so that dlopen() will look in ${prefix}/lib as well /usr/lib, etc..

# 
# NOTE: RTLD_NOW is AIX default, regardless (as of March 2016) (set above!)
# NOTE: RTLD_MEMBER is needed by dlopen to open a shared object from within an archive
#
# find_library() returns the archive(member) string needed by dlopen() to open a member whenever possible
# only returning a file - when available - if the archive search fails
# directory path is returned only when directory path information was supplied
#

import re, os, sys

# tell machine size to find the correct member in an archive
def aixABI():
    if (sys.maxsize < 2**32):
        return 32
    else:
        return 64

# execute and pre-scan output of /usr/bin/dump ... -H ...
def get_dumpH(_exe_so_or_a, p=None, lines=None):
    import subprocess as _subprocess
    p = _subprocess.Popen(["/usr/bin/dump",
        "-X%s"%aixABI(), "-H", _exe_so_or_a],
        universal_newlines=True,
        stdout=_subprocess.PIPE)
    lines=[line.strip() for line in p.stdout.readlines() if line.strip()]
    p.stdout.close()
    p.wait()
    return lines

# process dumpH output and return only members with loader sections
def get_shared(input, list=None, cpy=None, idx=0):
    cpy=input
    list=[]
    for line in input:
        idx = idx + 1
        if line.startswith("/"):
            next = cpy.pop(idx)
            if not "not" in next:
                list.append(line[line.find("["):line.rfind(":")])
    return(list)

# find the singular match, if more - undefined, and None is None
def get_match(expr, lines, line=None, member=None):
    matches = [m.group(0) for line in lines for m in [re.search(expr, line)] if m]
    if len(matches) == 1:
        match=matches[0]
        member = match[match.find("[")+1:match.find("]")]
        return member
    else:
        return None

# sometimes a generic name gets 64 appended to it, and AIX 64-bit
# archive members have different legacy names than 32-bit ones
def get_member64(name, members):
    # Recall that member names are in square brackets []
    # an old convention - insert _64 between libFOO and .so
    for expr in [
        '\[%s_*64\.so\]' % name,
        '\[%s.so.[0-9]+.*\]' % name,
        '\[%s_*64\.o\]' % name,
        '\[shr4_64.o\]',
        '\[shr4*_*64.o\]']:
            member = get_match(expr, members)
            if member:
                return member
    return None

# Get the most recent/highest numbered version - if it exists
def get_version(name, members):
    def _num_version(libname):
        # "libxyz.so.CURRENT.REVISION.AGE" => [ CURRENT, REVISION, AGE ]
        parts = libname.split(".")
        nums = []
        try:
            while parts:
                nums.insert(0, int(parts.pop()))
        except ValueError:
            pass
        return nums or [ sys.maxsize ]

    expr = '%s[_64]*.so.[0-9]+[0-9\.]*' % name
    versions = [m.group(0) for line in members for m in [re.search(expr, line)] if m]
    if versions:
        versions.sort(key=_num_version)
        return versions[-1]
    return None

# return an archive member matching name
# (versioned) .so members have priority over legacy AIX member name
#
# member names in in the dumpH output are in square brackets
# These get stripped by get_match() and regular parenthesis are added by the caller
def get_member(name, members):
    # look first for a generic match
    for expr in [
        '\[%s\.so\]' % name]:
            member = get_match(expr, members)
            if member:
                return member
    if member:
        return member
    else:
        member = get_version(name, members)
    if member:
        return member
    elif aixABI() == 64:
        return(get_member64(name, members))
    # 32-bit legacy names - shr4.o and shr.o
    else:
        for expr in [
            '\[shr4.o\]',
            '\[shr.o\]']:
                member = get_match(expr, members)
                if member:
                    return member
    return None

def getExecLibPath_aix(libpaths=None, x=None, lines=None, line=None, skipping=None):
    # if LIBPATH is defined, add it to the paths to search
    # FIXME: maybe LD_LIBRARY_PATH should be checked as well
    libpaths = os.environ.get("LIBPATH")
    lines = get_dumpH(sys.executable)
    skipping = True;
    for line in lines:
        if skipping == False:
            x = line.split()[1]
            if (x.startswith('/') or x.startswith('./') or x.startswith('../')):
                if libpaths is not None:
                    libpaths = "%s:%s" % (libpaths, x)
                else:
                    libpaths = x
        elif line.find("INDEX  PATH") == 0:
            skipping = False;
    return libpaths

# A) exact match (relative/full-path name)
# B) normal dlopen() processing, member in a archive
# C) OLD behavior, "gnu"/"posix" like - find a file in a directory
def find_library(name, _name=None, lines=None, path=None, member=None, shlib=None):
    ##### A) if an argument resolves as a path.filename, use as "paths"
    ##### B) the default AIX behavior is to find a member within a .a archive in directories
    # in the executable search PATH when there is no PATH info in the name
    # FIXME: if name endswith(".so") or contains(".so.") then:
    #    print message to syslog DEBUG
    pathe = name.rfind("/")
    if pathe > 0:
        parts = (name[0:pathe], name[pathe+1:])
        paths =  parts[0]
        name = parts[1]
    else:
        paths = getExecLibPath_aix()
    if name.find("lib") != 0:
        name = "lib%s" % name
    for dir in paths.split(":"):
        # /lib is a symbolic link to /usr/lib, skip it
        if dir == "/lib":
            continue
        # AIX rtl searches .a, by default, if it exists
        _arfile = os.path.join(dir, "%s.a" % name)
        if os.path.exists(_arfile):
            members =  get_shared(get_dumpH(_arfile))
            member = get_member(name, members)
            if member != None:
                shlib = "%s.a(%s)" % (name, member)
                return shlib
    ##### C) look for a .so FILE based on the request
    for dir in paths.split(":"):
        # /lib is a symbolic link to /usr/lib, skip it
        if dir == "/lib":
            continue
        # check for a generic match, note - no libtool versioning search
        shlib = os.path.join(dir, "%s.so" % name)
        if os.path.exists(shlib):
            return shlib
    # if we are here, we have not found anything plausible
    return None