1
2 /* Support for dynamic loading of extension modules */
3
4 #include "Python.h"
5 #include "importdl.h"
6
7 #include <ctype.h> /* for isdigit() */
8 #include <errno.h> /* for global errno */
9 #include <string.h> /* for strerror() */
10 #include <stdlib.h> /* for malloc(), free() */
11 #include <sys/ldr.h>
12
13
14 #ifdef AIX_GENUINE_CPLUSPLUS
15 #include <load.h>
16 #define aix_load loadAndInit
17 #else
18 #define aix_load load
19 #endif
20
21
22 extern char *Py_GetProgramName(void);
23
24 typedef struct Module {
25 struct Module *next;
26 void *entry;
27 } Module, *ModulePtr;
28
29 const struct filedescr _PyImport_DynLoadFiletab[] = {
30 {".so", "rb", C_EXTENSION},
31 {"module.so", "rb", C_EXTENSION},
32 {0, 0}
33 };
34
35 static int
aix_getoldmodules(void ** modlistptr)36 aix_getoldmodules(void **modlistptr)
37 {
38 register ModulePtr modptr, prevmodptr;
39 register struct ld_info *ldiptr;
40 register char *ldibuf;
41 register int errflag, bufsize = 1024;
42 register unsigned int offset;
43 char *progname = Py_GetProgramName();
44
45 /*
46 -- Get the list of loaded modules into ld_info structures.
47 */
48 if ((ldibuf = malloc(bufsize)) == NULL) {
49 PyErr_SetString(PyExc_ImportError, strerror(errno));
50 return -1;
51 }
52 while ((errflag = loadquery(L_GETINFO, ldibuf, bufsize)) == -1
53 && errno == ENOMEM) {
54 free(ldibuf);
55 bufsize += 1024;
56 if ((ldibuf = malloc(bufsize)) == NULL) {
57 PyErr_SetString(PyExc_ImportError, strerror(errno));
58 return -1;
59 }
60 }
61 if (errflag == -1) {
62 PyErr_SetString(PyExc_ImportError, strerror(errno));
63 return -1;
64 }
65 /*
66 -- Make the modules list from the ld_info structures.
67 */
68 ldiptr = (struct ld_info *)ldibuf;
69 prevmodptr = NULL;
70 do {
71 if (strstr(progname, ldiptr->ldinfo_filename) == NULL &&
72 strstr(ldiptr->ldinfo_filename, "python") == NULL) {
73 /*
74 -- Extract only the modules belonging to the main
75 -- executable + those containing "python" as a
76 -- substring (like the "python[version]" binary or
77 -- "libpython[version].a" in case it's a shared lib).
78 */
79 offset = (unsigned int)ldiptr->ldinfo_next;
80 ldiptr = (struct ld_info *)((char*)ldiptr + offset);
81 continue;
82 }
83 if ((modptr = (ModulePtr)malloc(sizeof(Module))) == NULL) {
84 PyErr_SetString(PyExc_ImportError, strerror(errno));
85 while (*modlistptr) {
86 modptr = (ModulePtr)*modlistptr;
87 *modlistptr = (void *)modptr->next;
88 free(modptr);
89 }
90 return -1;
91 }
92 modptr->entry = ldiptr->ldinfo_dataorg;
93 modptr->next = NULL;
94 if (prevmodptr == NULL)
95 *modlistptr = (void *)modptr;
96 else
97 prevmodptr->next = modptr;
98 prevmodptr = modptr;
99 offset = (unsigned int)ldiptr->ldinfo_next;
100 ldiptr = (struct ld_info *)((char*)ldiptr + offset);
101 } while (offset);
102 free(ldibuf);
103 return 0;
104 }
105
106
107 static void
aix_loaderror(const char * pathname)108 aix_loaderror(const char *pathname)
109 {
110
111 char *message[1024], errbuf[1024];
112 register int i,j;
113
114 struct errtab {
115 int errNo;
116 char *errstr;
117 } load_errtab[] = {
118 {L_ERROR_TOOMANY, "too many errors, rest skipped."},
119 {L_ERROR_NOLIB, "can't load library:"},
120 {L_ERROR_UNDEF, "can't find symbol in library:"},
121 {L_ERROR_RLDBAD,
122 "RLD index out of range or bad relocation type:"},
123 {L_ERROR_FORMAT, "not a valid, executable xcoff file:"},
124 {L_ERROR_MEMBER,
125 "file not an archive or does not contain requested member:"},
126 {L_ERROR_TYPE, "symbol table mismatch:"},
127 {L_ERROR_ALIGN, "text alignment in file is wrong."},
128 {L_ERROR_SYSTEM, "System error:"},
129 {L_ERROR_ERRNO, NULL}
130 };
131
132 #define LOAD_ERRTAB_LEN (sizeof(load_errtab)/sizeof(load_errtab[0]))
133 #define ERRBUF_APPEND(s) strncat(errbuf, s, sizeof(errbuf)-strlen(errbuf)-1)
134
135 PyOS_snprintf(errbuf, sizeof(errbuf), "from module %.200s ", pathname);
136
137 if (!loadquery(L_GETMESSAGES, &message[0], sizeof(message))) {
138 ERRBUF_APPEND(strerror(errno));
139 ERRBUF_APPEND("\n");
140 }
141 for(i = 0; message[i] && *message[i]; i++) {
142 int nerr = atoi(message[i]);
143 for (j=0; j<LOAD_ERRTAB_LEN ; j++) {
144 if (nerr == load_errtab[j].errNo && load_errtab[j].errstr)
145 ERRBUF_APPEND(load_errtab[j].errstr);
146 }
147 while (isdigit(Py_CHARMASK(*message[i]))) message[i]++ ;
148 ERRBUF_APPEND(message[i]);
149 ERRBUF_APPEND("\n");
150 }
151 errbuf[strlen(errbuf)-1] = '\0'; /* trim off last newline */
152 PyErr_SetString(PyExc_ImportError, errbuf);
153 return;
154 }
155
156
_PyImport_GetDynLoadFunc(const char * fqname,const char * shortname,const char * pathname,FILE * fp)157 dl_funcptr _PyImport_GetDynLoadFunc(const char *fqname, const char *shortname,
158 const char *pathname, FILE *fp)
159 {
160 dl_funcptr p;
161
162 /*
163 -- Invoke load() with L_NOAUTODEFER leaving the imported symbols
164 -- of the shared module unresolved. Thus we have to resolve them
165 -- explicitly with loadbind. The new module is loaded, then we
166 -- resolve its symbols using the list of already loaded modules
167 -- (only those that belong to the python executable). Get these
168 -- with loadquery(L_GETINFO).
169 */
170
171 static void *staticmodlistptr = NULL;
172
173 if (!staticmodlistptr)
174 if (aix_getoldmodules(&staticmodlistptr) == -1)
175 return NULL;
176 p = (dl_funcptr) aix_load((char *)pathname, L_NOAUTODEFER, 0);
177 if (p == NULL) {
178 aix_loaderror(pathname);
179 return NULL;
180 }
181
182 return p;
183 }
184