diff options
author | Christian Grothoff <christian@grothoff.org> | 2007-07-10 09:01:06 +0000 |
---|---|---|
committer | Christian Grothoff <christian@grothoff.org> | 2007-07-10 09:01:06 +0000 |
commit | ce124c66c8aff19abaa695a16127a742050d01b4 (patch) | |
tree | ec813c1b394f5566655fa6ff52cfba45a14847d7 | |
parent | b2f6fe964b05c6995bcb50ebe29cf25f1c185f84 (diff) | |
download | gnunet-gtk-ce124c66c8aff19abaa695a16127a742050d01b4.tar.gz gnunet-gtk-ce124c66c8aff19abaa695a16127a742050d01b4.zip |
indent
41 files changed, 8870 insertions, 9504 deletions
diff --git a/libltdl/ltdl.c b/libltdl/ltdl.c index 60feb043..8ad947dc 100644 --- a/libltdl/ltdl.c +++ b/libltdl/ltdl.c | |||
@@ -131,10 +131,10 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA | |||
131 | #if WITH_DMALLOC | 131 | #if WITH_DMALLOC |
132 | # include <dmalloc.h> | 132 | # include <dmalloc.h> |
133 | #endif | 133 | #endif |
134 | |||
134 | 135 | ||
135 | 136 | ||
136 | 137 | ||
137 | |||
138 | /* --- WINDOWS SUPPORT --- */ | 138 | /* --- WINDOWS SUPPORT --- */ |
139 | 139 | ||
140 | 140 | ||
@@ -162,7 +162,7 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA | |||
162 | struct dirent | 162 | struct dirent |
163 | { | 163 | { |
164 | char d_name[2048]; | 164 | char d_name[2048]; |
165 | int d_namlen; | 165 | int d_namlen; |
166 | }; | 166 | }; |
167 | 167 | ||
168 | typedef struct _DIR | 168 | typedef struct _DIR |
@@ -174,8 +174,8 @@ typedef struct _DIR | |||
174 | } DIR; | 174 | } DIR; |
175 | 175 | ||
176 | #endif /* LT_USE_WINDOWS_DIRENT_EMULATION */ | 176 | #endif /* LT_USE_WINDOWS_DIRENT_EMULATION */ |
177 | |||
178 | 177 | ||
178 | |||
179 | /* --- MANIFEST CONSTANTS --- */ | 179 | /* --- MANIFEST CONSTANTS --- */ |
180 | 180 | ||
181 | 181 | ||
@@ -199,30 +199,32 @@ typedef struct _DIR | |||
199 | /* This accounts for the _LTX_ separator */ | 199 | /* This accounts for the _LTX_ separator */ |
200 | #undef LT_SYMBOL_OVERHEAD | 200 | #undef LT_SYMBOL_OVERHEAD |
201 | #define LT_SYMBOL_OVERHEAD 5 | 201 | #define LT_SYMBOL_OVERHEAD 5 |
202 | |||
202 | 203 | ||
203 | 204 | ||
204 | 205 | ||
205 | |||
206 | /* --- MEMORY HANDLING --- */ | 206 | /* --- MEMORY HANDLING --- */ |
207 | 207 | ||
208 | 208 | ||
209 | /* These are the functions used internally. In addition to making | 209 | /* These are the functions used internally. In addition to making |
210 | use of the associated function pointers above, they also perform | 210 | use of the associated function pointers above, they also perform |
211 | error handling. */ | 211 | error handling. */ |
212 | static char *lt_estrdup LT_PARAMS((const char *str)); | 212 | static char *lt_estrdup LT_PARAMS ((const char *str)); |
213 | static lt_ptr lt_emalloc LT_PARAMS((size_t size)); | 213 | static lt_ptr lt_emalloc LT_PARAMS ((size_t size)); |
214 | static lt_ptr lt_erealloc LT_PARAMS((lt_ptr addr, size_t size)); | 214 | static lt_ptr lt_erealloc LT_PARAMS ((lt_ptr addr, size_t size)); |
215 | 215 | ||
216 | /* static lt_ptr rpl_realloc LT_PARAMS((lt_ptr ptr, size_t size)); */ | 216 | /* static lt_ptr rpl_realloc LT_PARAMS((lt_ptr ptr, size_t size)); */ |
217 | #define rpl_realloc realloc | 217 | #define rpl_realloc realloc |
218 | 218 | ||
219 | /* These are the pointers that can be changed by the caller: */ | 219 | /* These are the pointers that can be changed by the caller: */ |
220 | LT_GLOBAL_DATA lt_ptr (*lt_dlmalloc) LT_PARAMS((size_t size)) | 220 | LT_GLOBAL_DATA |
221 | = (lt_ptr (*) LT_PARAMS((size_t))) malloc; | 221 | lt_ptr (*lt_dlmalloc) |
222 | LT_GLOBAL_DATA lt_ptr (*lt_dlrealloc) LT_PARAMS((lt_ptr ptr, size_t size)) | 222 | LT_PARAMS ((size_t size)) = (lt_ptr (*)LT_PARAMS ((size_t))) malloc; |
223 | = (lt_ptr (*) LT_PARAMS((lt_ptr, size_t))) rpl_realloc; | 223 | LT_GLOBAL_DATA lt_ptr (*lt_dlrealloc) |
224 | LT_GLOBAL_DATA void (*lt_dlfree) LT_PARAMS((lt_ptr ptr)) | 224 | LT_PARAMS ((lt_ptr ptr, size_t size)) = |
225 | = (void (*) LT_PARAMS((lt_ptr))) free; | 225 | (lt_ptr (*)LT_PARAMS ((lt_ptr, size_t))) rpl_realloc; |
226 | LT_GLOBAL_DATA void (*lt_dlfree) LT_PARAMS ((lt_ptr ptr)) = | ||
227 | (void (*)LT_PARAMS ((lt_ptr))) free; | ||
226 | 228 | ||
227 | /* The following macros reduce the amount of typing needed to cast | 229 | /* The following macros reduce the amount of typing needed to cast |
228 | assigned memory. */ | 230 | assigned memory. */ |
@@ -251,29 +253,28 @@ LT_GLOBAL_DATA void (*lt_dlfree) LT_PARAMS((lt_ptr ptr)) | |||
251 | #define LT_DLMEM_REASSIGN(p, q) LT_STMT_START { \ | 253 | #define LT_DLMEM_REASSIGN(p, q) LT_STMT_START { \ |
252 | if ((p) != (q)) { if (p) lt_dlfree (p); (p) = (q); (q) = 0; } \ | 254 | if ((p) != (q)) { if (p) lt_dlfree (p); (p) = (q); (q) = 0; } \ |
253 | } LT_STMT_END | 255 | } LT_STMT_END |
254 | |||
255 | 256 | ||
257 | |||
256 | /* --- REPLACEMENT FUNCTIONS --- */ | 258 | /* --- REPLACEMENT FUNCTIONS --- */ |
257 | 259 | ||
258 | 260 | ||
259 | #undef strdup | 261 | #undef strdup |
260 | #define strdup rpl_strdup | 262 | #define strdup rpl_strdup |
261 | 263 | ||
262 | static char *strdup LT_PARAMS((const char *str)); | 264 | static char *strdup LT_PARAMS ((const char *str)); |
263 | 265 | ||
264 | static char * | 266 | static char *strdup (str) |
265 | strdup(str) | ||
266 | const char *str; | 267 | const char *str; |
267 | { | 268 | { |
268 | char *tmp = 0; | 269 | char *tmp = 0; |
269 | 270 | ||
270 | if (str) | 271 | if (str) |
271 | { | 272 | { |
272 | tmp = LT_DLMALLOC (char, 1+ strlen (str)); | 273 | tmp = LT_DLMALLOC (char, 1 + strlen (str)); |
273 | if (tmp) | 274 | if (tmp) |
274 | { | 275 | { |
275 | strcpy(tmp, str); | 276 | strcpy (tmp, str); |
276 | } | 277 | } |
277 | } | 278 | } |
278 | 279 | ||
279 | return tmp; | 280 | return tmp; |
@@ -285,7 +286,7 @@ strdup(str) | |||
285 | #undef strcmp | 286 | #undef strcmp |
286 | #define strcmp rpl_strcmp | 287 | #define strcmp rpl_strcmp |
287 | 288 | ||
288 | static int strcmp LT_PARAMS((const char *str1, const char *str2)); | 289 | static int strcmp LT_PARAMS ((const char *str1, const char *str2)); |
289 | 290 | ||
290 | static int | 291 | static int |
291 | strcmp (str1, str2) | 292 | strcmp (str1, str2) |
@@ -299,13 +300,13 @@ strcmp (str1, str2) | |||
299 | if (str2 == 0) | 300 | if (str2 == 0) |
300 | return 1; | 301 | return 1; |
301 | 302 | ||
302 | for (;*str1 && *str2; ++str1, ++str2) | 303 | for (; *str1 && *str2; ++str1, ++str2) |
303 | { | 304 | { |
304 | if (*str1 != *str2) | 305 | if (*str1 != *str2) |
305 | break; | 306 | break; |
306 | } | 307 | } |
307 | 308 | ||
308 | return (int)(*str1 - *str2); | 309 | return (int) (*str1 - *str2); |
309 | } | 310 | } |
310 | #endif | 311 | #endif |
311 | 312 | ||
@@ -317,19 +318,19 @@ strcmp (str1, str2) | |||
317 | # else | 318 | # else |
318 | # define strchr rpl_strchr | 319 | # define strchr rpl_strchr |
319 | 320 | ||
320 | static const char *strchr LT_PARAMS((const char *str, int ch)); | 321 | static const char *strchr LT_PARAMS ((const char *str, int ch)); |
321 | 322 | ||
322 | static const char* | 323 | static const char * |
323 | strchr(str, ch) | 324 | strchr (str, ch) |
324 | const char *str; | 325 | const char *str; |
325 | int ch; | 326 | int ch; |
326 | { | 327 | { |
327 | const char *p; | 328 | const char *p; |
328 | 329 | ||
329 | for (p = str; *p != (char)ch && *p != LT_EOS_CHAR; ++p) | 330 | for (p = str; *p != (char) ch && *p != LT_EOS_CHAR; ++p) |
330 | /*NOWORK*/; | 331 | /*NOWORK*/; |
331 | 332 | ||
332 | return (*p == (char)ch) ? p : 0; | 333 | return (*p == (char) ch) ? p : 0; |
333 | } | 334 | } |
334 | 335 | ||
335 | # endif | 336 | # endif |
@@ -343,10 +344,10 @@ strchr(str, ch) | |||
343 | # else | 344 | # else |
344 | # define strrchr rpl_strrchr | 345 | # define strrchr rpl_strrchr |
345 | 346 | ||
346 | static const char *strrchr LT_PARAMS((const char *str, int ch)); | 347 | static const char *strrchr LT_PARAMS ((const char *str, int ch)); |
347 | 348 | ||
348 | static const char* | 349 | static const char * |
349 | strrchr(str, ch) | 350 | strrchr (str, ch) |
350 | const char *str; | 351 | const char *str; |
351 | int ch; | 352 | int ch; |
352 | { | 353 | { |
@@ -355,9 +356,9 @@ strrchr(str, ch) | |||
355 | for (p = str; *p != LT_EOS_CHAR; ++p) | 356 | for (p = str; *p != LT_EOS_CHAR; ++p) |
356 | { | 357 | { |
357 | if (*p == (char) ch) | 358 | if (*p == (char) ch) |
358 | { | 359 | { |
359 | q = p; | 360 | q = p; |
360 | } | 361 | } |
361 | } | 362 | } |
362 | 363 | ||
363 | return q; | 364 | return q; |
@@ -377,7 +378,7 @@ strrchr(str, ch) | |||
377 | # else | 378 | # else |
378 | # define memcpy rpl_memcpy | 379 | # define memcpy rpl_memcpy |
379 | 380 | ||
380 | static lt_ptr memcpy LT_PARAMS((lt_ptr dest, const lt_ptr src, size_t size)); | 381 | static lt_ptr memcpy LT_PARAMS ((lt_ptr dest, const lt_ptr src, size_t size)); |
381 | 382 | ||
382 | static lt_ptr | 383 | static lt_ptr |
383 | memcpy (dest, src, size) | 384 | memcpy (dest, src, size) |
@@ -396,12 +397,13 @@ memcpy (dest, src, size) | |||
396 | } | 397 | } |
397 | 398 | ||
398 | # endif /* !HAVE_BCOPY */ | 399 | # endif /* !HAVE_BCOPY */ |
399 | #endif /* !HAVE_MEMCPY */ | 400 | #endif /* !HAVE_MEMCPY */ |
400 | 401 | ||
401 | #if ! HAVE_MEMMOVE | 402 | #if ! HAVE_MEMMOVE |
402 | # define memmove rpl_memmove | 403 | # define memmove rpl_memmove |
403 | 404 | ||
404 | static lt_ptr memmove LT_PARAMS((lt_ptr dest, const lt_ptr src, size_t size)); | 405 | static lt_ptr memmove |
406 | LT_PARAMS ((lt_ptr dest, const lt_ptr src, size_t size)); | ||
405 | 407 | ||
406 | static lt_ptr | 408 | static lt_ptr |
407 | memmove (dest, src, size) | 409 | memmove (dest, src, size) |
@@ -414,12 +416,12 @@ memmove (dest, src, size) | |||
414 | if (dest < src) | 416 | if (dest < src) |
415 | for (i = 0; i < size; ++i) | 417 | for (i = 0; i < size; ++i) |
416 | { | 418 | { |
417 | dest[i] = src[i]; | 419 | dest[i] = src[i]; |
418 | } | 420 | } |
419 | else if (dest > src) | 421 | else if (dest > src) |
420 | for (i = size -1; i >= 0; --i) | 422 | for (i = size - 1; i >= 0; --i) |
421 | { | 423 | { |
422 | dest[i] = src[i]; | 424 | dest[i] = src[i]; |
423 | } | 425 | } |
424 | 426 | ||
425 | return dest; | 427 | return dest; |
@@ -429,71 +431,73 @@ memmove (dest, src, size) | |||
429 | 431 | ||
430 | #ifdef LT_USE_WINDOWS_DIRENT_EMULATION | 432 | #ifdef LT_USE_WINDOWS_DIRENT_EMULATION |
431 | 433 | ||
432 | static void closedir LT_PARAMS((DIR *entry)); | 434 | static void closedir LT_PARAMS ((DIR * entry)); |
433 | 435 | ||
434 | static void | 436 | static void |
435 | closedir(entry) | 437 | closedir (entry) |
436 | DIR *entry; | 438 | DIR *entry; |
437 | { | 439 | { |
438 | assert(entry != (DIR *) NULL); | 440 | assert (entry != (DIR *) NULL); |
439 | FindClose(entry->hSearch); | 441 | FindClose (entry->hSearch); |
440 | lt_dlfree((lt_ptr)entry); | 442 | lt_dlfree ((lt_ptr) entry); |
441 | } | 443 | } |
442 | 444 | ||
443 | 445 | ||
444 | static DIR * opendir LT_PARAMS((const char *path)); | 446 | static DIR *opendir LT_PARAMS ((const char *path)); |
445 | 447 | ||
446 | static DIR* | 448 | static DIR * |
447 | opendir (path) | 449 | opendir (path) |
448 | const char *path; | 450 | const char *path; |
449 | { | 451 | { |
450 | char file_specification[LT_FILENAME_MAX]; | 452 | char file_specification[LT_FILENAME_MAX]; |
451 | DIR *entry; | 453 | DIR *entry; |
452 | 454 | ||
453 | assert(path != (char *) NULL); | 455 | assert (path != (char *) NULL); |
454 | (void) strncpy(file_specification,path,LT_FILENAME_MAX-1); | 456 | (void) strncpy (file_specification, path, LT_FILENAME_MAX - 1); |
455 | (void) strcat(file_specification,"\\"); | 457 | (void) strcat (file_specification, "\\"); |
456 | entry = LT_DLMALLOC (DIR,sizeof(DIR)); | 458 | entry = LT_DLMALLOC (DIR, sizeof (DIR)); |
457 | if (entry != (DIR *) 0) | 459 | if (entry != (DIR *) 0) |
458 | { | 460 | { |
459 | entry->firsttime = TRUE; | 461 | entry->firsttime = TRUE; |
460 | entry->hSearch = FindFirstFile(file_specification,&entry->Win32FindData); | 462 | entry->hSearch = |
463 | FindFirstFile (file_specification, &entry->Win32FindData); | ||
461 | } | 464 | } |
462 | if (entry->hSearch == INVALID_HANDLE_VALUE) | 465 | if (entry->hSearch == INVALID_HANDLE_VALUE) |
463 | { | 466 | { |
464 | (void) strcat(file_specification,"\\*.*"); | 467 | (void) strcat (file_specification, "\\*.*"); |
465 | entry->hSearch = FindFirstFile(file_specification,&entry->Win32FindData); | 468 | entry->hSearch = |
469 | FindFirstFile (file_specification, &entry->Win32FindData); | ||
466 | if (entry->hSearch == INVALID_HANDLE_VALUE) | 470 | if (entry->hSearch == INVALID_HANDLE_VALUE) |
467 | { | 471 | { |
468 | LT_DLFREE (entry); | 472 | LT_DLFREE (entry); |
469 | return (DIR *) 0; | 473 | return (DIR *) 0; |
470 | } | 474 | } |
471 | } | 475 | } |
472 | return(entry); | 476 | return (entry); |
473 | } | 477 | } |
474 | 478 | ||
475 | 479 | ||
476 | static struct dirent *readdir LT_PARAMS((DIR *entry)); | 480 | static struct dirent *readdir LT_PARAMS ((DIR * entry)); |
477 | 481 | ||
478 | static struct dirent *readdir(entry) | 482 | static struct dirent * |
479 | DIR *entry; | 483 | readdir (entry) |
484 | DIR *entry; | ||
480 | { | 485 | { |
481 | int | 486 | int status; |
482 | status; | ||
483 | 487 | ||
484 | if (entry == (DIR *) 0) | 488 | if (entry == (DIR *) 0) |
485 | return((struct dirent *) 0); | 489 | return ((struct dirent *) 0); |
486 | if (!entry->firsttime) | 490 | if (!entry->firsttime) |
487 | { | 491 | { |
488 | status = FindNextFile(entry->hSearch,&entry->Win32FindData); | 492 | status = FindNextFile (entry->hSearch, &entry->Win32FindData); |
489 | if (status == 0) | 493 | if (status == 0) |
490 | return((struct dirent *) 0); | 494 | return ((struct dirent *) 0); |
491 | } | 495 | } |
492 | entry->firsttime = FALSE; | 496 | entry->firsttime = FALSE; |
493 | (void) strncpy(entry->file_info.d_name,entry->Win32FindData.cFileName, | 497 | (void) strncpy (entry->file_info.d_name, entry->Win32FindData.cFileName, |
494 | LT_FILENAME_MAX-1); | 498 | LT_FILENAME_MAX - 1); |
495 | entry->file_info.d_namlen = strlen(entry->file_info.d_name); | 499 | entry->file_info.d_namlen = strlen (entry->file_info.d_name); |
496 | return(&entry->file_info); | 500 | return (&entry->file_info); |
497 | } | 501 | } |
498 | 502 | ||
499 | #endif /* LT_USE_WINDOWS_DIRENT_EMULATION */ | 503 | #endif /* LT_USE_WINDOWS_DIRENT_EMULATION */ |
@@ -524,9 +528,9 @@ realloc (ptr, size) | |||
524 | { | 528 | { |
525 | /* For zero or less bytes, free the original memory */ | 529 | /* For zero or less bytes, free the original memory */ |
526 | if (ptr != 0) | 530 | if (ptr != 0) |
527 | { | 531 | { |
528 | lt_dlfree (ptr); | 532 | lt_dlfree (ptr); |
529 | } | 533 | } |
530 | 534 | ||
531 | return (lt_ptr) 0; | 535 | return (lt_ptr) 0; |
532 | } | 536 | } |
@@ -541,13 +545,13 @@ realloc (ptr, size) | |||
541 | lt_ptr mem = lt_dlmalloc (size); | 545 | lt_ptr mem = lt_dlmalloc (size); |
542 | 546 | ||
543 | if (mem) | 547 | if (mem) |
544 | { | 548 | { |
545 | memcpy (mem, ptr, size); | 549 | memcpy (mem, ptr, size); |
546 | lt_dlfree (ptr); | 550 | lt_dlfree (ptr); |
547 | } | 551 | } |
548 | 552 | ||
549 | /* Note that the contents of PTR are not damaged if there is | 553 | /* Note that the contents of PTR are not damaged if there is |
550 | insufficient memory to realloc. */ | 554 | insufficient memory to realloc. */ |
551 | return mem; | 555 | return mem; |
552 | } | 556 | } |
553 | } | 557 | } |
@@ -557,8 +561,8 @@ realloc (ptr, size) | |||
557 | #if ! HAVE_ARGZ_APPEND | 561 | #if ! HAVE_ARGZ_APPEND |
558 | # define argz_append rpl_argz_append | 562 | # define argz_append rpl_argz_append |
559 | 563 | ||
560 | static error_t argz_append LT_PARAMS((char **pargz, size_t *pargz_len, | 564 | static error_t argz_append LT_PARAMS ((char **pargz, size_t * pargz_len, |
561 | const char *buf, size_t buf_len)); | 565 | const char *buf, size_t buf_len)); |
562 | 566 | ||
563 | static error_t | 567 | static error_t |
564 | argz_append (pargz, pargz_len, buf, buf_len) | 568 | argz_append (pargz, pargz_len, buf, buf_len) |
@@ -568,7 +572,7 @@ argz_append (pargz, pargz_len, buf, buf_len) | |||
568 | size_t buf_len; | 572 | size_t buf_len; |
569 | { | 573 | { |
570 | size_t argz_len; | 574 | size_t argz_len; |
571 | char *argz; | 575 | char *argz; |
572 | 576 | ||
573 | assert (pargz); | 577 | assert (pargz); |
574 | assert (pargz_len); | 578 | assert (pargz_len); |
@@ -599,8 +603,8 @@ argz_append (pargz, pargz_len, buf, buf_len) | |||
599 | #if ! HAVE_ARGZ_CREATE_SEP | 603 | #if ! HAVE_ARGZ_CREATE_SEP |
600 | # define argz_create_sep rpl_argz_create_sep | 604 | # define argz_create_sep rpl_argz_create_sep |
601 | 605 | ||
602 | static error_t argz_create_sep LT_PARAMS((const char *str, int delim, | 606 | static error_t argz_create_sep LT_PARAMS ((const char *str, int delim, |
603 | char **pargz, size_t *pargz_len)); | 607 | char **pargz, size_t * pargz_len)); |
604 | 608 | ||
605 | static error_t | 609 | static error_t |
606 | argz_create_sep (str, delim, pargz, pargz_len) | 610 | argz_create_sep (str, delim, pargz, pargz_len) |
@@ -618,7 +622,7 @@ argz_create_sep (str, delim, pargz, pargz_len) | |||
618 | 622 | ||
619 | /* Make a copy of STR, but replacing each occurence of | 623 | /* Make a copy of STR, but replacing each occurence of |
620 | DELIM with '\0'. */ | 624 | DELIM with '\0'. */ |
621 | argz_len = 1+ LT_STRLEN (str); | 625 | argz_len = 1 + LT_STRLEN (str); |
622 | if (argz_len) | 626 | if (argz_len) |
623 | { | 627 | { |
624 | const char *p; | 628 | const char *p; |
@@ -626,22 +630,22 @@ argz_create_sep (str, delim, pargz, pargz_len) | |||
626 | 630 | ||
627 | argz = LT_DLMALLOC (char, argz_len); | 631 | argz = LT_DLMALLOC (char, argz_len); |
628 | if (!argz) | 632 | if (!argz) |
629 | return ENOMEM; | 633 | return ENOMEM; |
630 | 634 | ||
631 | for (p = str, q = argz; *p != LT_EOS_CHAR; ++p) | 635 | for (p = str, q = argz; *p != LT_EOS_CHAR; ++p) |
632 | { | 636 | { |
633 | if (*p == delim) | 637 | if (*p == delim) |
634 | { | 638 | { |
635 | /* Ignore leading delimiters, and fold consecutive | 639 | /* Ignore leading delimiters, and fold consecutive |
636 | delimiters in STR into a single '\0' in ARGZ. */ | 640 | delimiters in STR into a single '\0' in ARGZ. */ |
637 | if ((q > argz) && (q[-1] != LT_EOS_CHAR)) | 641 | if ((q > argz) && (q[-1] != LT_EOS_CHAR)) |
638 | *q++ = LT_EOS_CHAR; | 642 | *q++ = LT_EOS_CHAR; |
639 | else | 643 | else |
640 | --argz_len; | 644 | --argz_len; |
641 | } | 645 | } |
642 | else | 646 | else |
643 | *q++ = *p; | 647 | *q++ = *p; |
644 | } | 648 | } |
645 | /* Copy terminating LT_EOS_CHAR. */ | 649 | /* Copy terminating LT_EOS_CHAR. */ |
646 | *q = *p; | 650 | *q = *p; |
647 | } | 651 | } |
@@ -662,8 +666,8 @@ argz_create_sep (str, delim, pargz, pargz_len) | |||
662 | #if ! HAVE_ARGZ_INSERT | 666 | #if ! HAVE_ARGZ_INSERT |
663 | # define argz_insert rpl_argz_insert | 667 | # define argz_insert rpl_argz_insert |
664 | 668 | ||
665 | static error_t argz_insert LT_PARAMS((char **pargz, size_t *pargz_len, | 669 | static error_t argz_insert LT_PARAMS ((char **pargz, size_t * pargz_len, |
666 | char *before, const char *entry)); | 670 | char *before, const char *entry)); |
667 | 671 | ||
668 | static error_t | 672 | static error_t |
669 | argz_insert (pargz, pargz_len, before, entry) | 673 | argz_insert (pargz, pargz_len, before, entry) |
@@ -679,7 +683,7 @@ argz_insert (pargz, pargz_len, before, entry) | |||
679 | /* No BEFORE address indicates ENTRY should be inserted after the | 683 | /* No BEFORE address indicates ENTRY should be inserted after the |
680 | current last element. */ | 684 | current last element. */ |
681 | if (!before) | 685 | if (!before) |
682 | return argz_append (pargz, pargz_len, entry, 1+ LT_STRLEN (entry)); | 686 | return argz_append (pargz, pargz_len, entry, 1 + LT_STRLEN (entry)); |
683 | 687 | ||
684 | /* This probably indicates a programmer error, but to preserve | 688 | /* This probably indicates a programmer error, but to preserve |
685 | semantics, scan back to the start of an entry if BEFORE points | 689 | semantics, scan back to the start of an entry if BEFORE points |
@@ -688,10 +692,10 @@ argz_insert (pargz, pargz_len, before, entry) | |||
688 | --before; | 692 | --before; |
689 | 693 | ||
690 | { | 694 | { |
691 | size_t entry_len = 1+ LT_STRLEN (entry); | 695 | size_t entry_len = 1 + LT_STRLEN (entry); |
692 | size_t argz_len = *pargz_len + entry_len; | 696 | size_t argz_len = *pargz_len + entry_len; |
693 | size_t offset = before - *pargz; | 697 | size_t offset = before - *pargz; |
694 | char *argz = LT_DLREALLOC (char, *pargz, argz_len); | 698 | char *argz = LT_DLREALLOC (char, *pargz, argz_len); |
695 | 699 | ||
696 | if (!argz) | 700 | if (!argz) |
697 | return ENOMEM; | 701 | return ENOMEM; |
@@ -704,7 +708,7 @@ argz_insert (pargz, pargz_len, before, entry) | |||
704 | space at the end -- making room to copy ENTRY into the | 708 | space at the end -- making room to copy ENTRY into the |
705 | resulting gap. */ | 709 | resulting gap. */ |
706 | memmove (before + entry_len, before, *pargz_len - offset); | 710 | memmove (before + entry_len, before, *pargz_len - offset); |
707 | memcpy (before, entry, entry_len); | 711 | memcpy (before, entry, entry_len); |
708 | 712 | ||
709 | /* Assign new values. */ | 713 | /* Assign new values. */ |
710 | *pargz = argz; | 714 | *pargz = argz; |
@@ -719,8 +723,8 @@ argz_insert (pargz, pargz_len, before, entry) | |||
719 | #if ! HAVE_ARGZ_NEXT | 723 | #if ! HAVE_ARGZ_NEXT |
720 | # define argz_next rpl_argz_next | 724 | # define argz_next rpl_argz_next |
721 | 725 | ||
722 | static char *argz_next LT_PARAMS((char *argz, size_t argz_len, | 726 | static char *argz_next LT_PARAMS ((char *argz, size_t argz_len, |
723 | const char *entry)); | 727 | const char *entry)); |
724 | 728 | ||
725 | static char * | 729 | static char * |
726 | argz_next (argz, argz_len, entry) | 730 | argz_next (argz, argz_len, entry) |
@@ -733,28 +737,28 @@ argz_next (argz, argz_len, entry) | |||
733 | if (entry) | 737 | if (entry) |
734 | { | 738 | { |
735 | /* Either ARGZ/ARGZ_LEN is empty, or ENTRY points into an address | 739 | /* Either ARGZ/ARGZ_LEN is empty, or ENTRY points into an address |
736 | within the ARGZ vector. */ | 740 | within the ARGZ vector. */ |
737 | assert ((!argz && !argz_len) | 741 | assert ((!argz && !argz_len) |
738 | || ((argz <= entry) && (entry < (argz + argz_len)))); | 742 | || ((argz <= entry) && (entry < (argz + argz_len)))); |
739 | 743 | ||
740 | /* Move to the char immediately after the terminating | 744 | /* Move to the char immediately after the terminating |
741 | '\0' of ENTRY. */ | 745 | '\0' of ENTRY. */ |
742 | entry = 1+ strchr (entry, LT_EOS_CHAR); | 746 | entry = 1 + strchr (entry, LT_EOS_CHAR); |
743 | 747 | ||
744 | /* Return either the new ENTRY, or else NULL if ARGZ is | 748 | /* Return either the new ENTRY, or else NULL if ARGZ is |
745 | exhausted. */ | 749 | exhausted. */ |
746 | return (entry >= argz + argz_len) ? 0 : (char *) entry; | 750 | return (entry >= argz + argz_len) ? 0 : (char *) entry; |
747 | } | 751 | } |
748 | else | 752 | else |
749 | { | 753 | { |
750 | /* This should probably be flagged as a programmer error, | 754 | /* This should probably be flagged as a programmer error, |
751 | since starting an argz_next loop with the iterator set | 755 | since starting an argz_next loop with the iterator set |
752 | to ARGZ is safer. To preserve semantics, handle the NULL | 756 | to ARGZ is safer. To preserve semantics, handle the NULL |
753 | case by returning the start of ARGZ (if any). */ | 757 | case by returning the start of ARGZ (if any). */ |
754 | if (argz_len > 0) | 758 | if (argz_len > 0) |
755 | return argz; | 759 | return argz; |
756 | else | 760 | else |
757 | return 0; | 761 | return 0; |
758 | } | 762 | } |
759 | } | 763 | } |
760 | #endif /* !HAVE_ARGZ_NEXT */ | 764 | #endif /* !HAVE_ARGZ_NEXT */ |
@@ -764,8 +768,7 @@ argz_next (argz, argz_len, entry) | |||
764 | #if ! HAVE_ARGZ_STRINGIFY | 768 | #if ! HAVE_ARGZ_STRINGIFY |
765 | # define argz_stringify rpl_argz_stringify | 769 | # define argz_stringify rpl_argz_stringify |
766 | 770 | ||
767 | static void argz_stringify LT_PARAMS((char *argz, size_t argz_len, | 771 | static void argz_stringify LT_PARAMS ((char *argz, size_t argz_len, int sep)); |
768 | int sep)); | ||
769 | 772 | ||
770 | static void | 773 | static void |
771 | argz_stringify (argz, argz_len, sep) | 774 | argz_stringify (argz, argz_len, sep) |
@@ -777,68 +780,69 @@ argz_stringify (argz, argz_len, sep) | |||
777 | 780 | ||
778 | if (sep) | 781 | if (sep) |
779 | { | 782 | { |
780 | --argz_len; /* don't stringify the terminating EOS */ | 783 | --argz_len; /* don't stringify the terminating EOS */ |
781 | while (--argz_len > 0) | 784 | while (--argz_len > 0) |
782 | { | 785 | { |
783 | if (argz[argz_len] == LT_EOS_CHAR) | 786 | if (argz[argz_len] == LT_EOS_CHAR) |
784 | argz[argz_len] = sep; | 787 | argz[argz_len] = sep; |
785 | } | 788 | } |
786 | } | 789 | } |
787 | } | 790 | } |
788 | #endif /* !HAVE_ARGZ_STRINGIFY */ | 791 | #endif /* !HAVE_ARGZ_STRINGIFY */ |
792 | |||
789 | 793 | ||
790 | 794 | ||
791 | 795 | ||
792 | |||
793 | /* --- TYPE DEFINITIONS -- */ | 796 | /* --- TYPE DEFINITIONS -- */ |
794 | 797 | ||
795 | 798 | ||
796 | /* This type is used for the array of caller data sets in each handler. */ | 799 | /* This type is used for the array of caller data sets in each handler. */ |
797 | typedef struct { | 800 | typedef struct |
798 | lt_dlcaller_id key; | 801 | { |
799 | lt_ptr data; | 802 | lt_dlcaller_id key; |
803 | lt_ptr data; | ||
800 | } lt_caller_data; | 804 | } lt_caller_data; |
805 | |||
801 | 806 | ||
802 | 807 | ||
803 | 808 | ||
804 | |||
805 | /* --- OPAQUE STRUCTURES DECLARED IN LTDL.H --- */ | 809 | /* --- OPAQUE STRUCTURES DECLARED IN LTDL.H --- */ |
806 | 810 | ||
807 | 811 | ||
808 | /* Extract the diagnostic strings from the error table macro in the same | 812 | /* Extract the diagnostic strings from the error table macro in the same |
809 | order as the enumerated indices in ltdl.h. */ | 813 | order as the enumerated indices in ltdl.h. */ |
810 | 814 | ||
811 | static const char *lt_dlerror_strings[] = | 815 | static const char *lt_dlerror_strings[] = { |
812 | { | ||
813 | #define LT_ERROR(name, diagnostic) (diagnostic), | 816 | #define LT_ERROR(name, diagnostic) (diagnostic), |
814 | lt_dlerror_table | 817 | lt_dlerror_table |
815 | #undef LT_ERROR | 818 | #undef LT_ERROR |
816 | 819 | 0 | |
817 | 0 | 820 | }; |
818 | }; | ||
819 | 821 | ||
820 | /* This structure is used for the list of registered loaders. */ | 822 | /* This structure is used for the list of registered loaders. */ |
821 | struct lt_dlloader { | 823 | struct lt_dlloader |
822 | struct lt_dlloader *next; | 824 | { |
823 | const char *loader_name; /* identifying name for each loader */ | 825 | struct lt_dlloader *next; |
824 | const char *sym_prefix; /* prefix for symbols */ | 826 | const char *loader_name; /* identifying name for each loader */ |
825 | lt_module_open *module_open; | 827 | const char *sym_prefix; /* prefix for symbols */ |
826 | lt_module_close *module_close; | 828 | lt_module_open *module_open; |
827 | lt_find_sym *find_sym; | 829 | lt_module_close *module_close; |
828 | lt_dlloader_exit *dlloader_exit; | 830 | lt_find_sym *find_sym; |
829 | lt_user_data dlloader_data; | 831 | lt_dlloader_exit *dlloader_exit; |
832 | lt_user_data dlloader_data; | ||
830 | }; | 833 | }; |
831 | 834 | ||
832 | struct lt_dlhandle_struct { | 835 | struct lt_dlhandle_struct |
833 | struct lt_dlhandle_struct *next; | 836 | { |
834 | lt_dlloader *loader; /* dlopening interface */ | 837 | struct lt_dlhandle_struct *next; |
835 | lt_dlinfo info; | 838 | lt_dlloader *loader; /* dlopening interface */ |
836 | int depcount; /* number of dependencies */ | 839 | lt_dlinfo info; |
837 | lt_dlhandle *deplibs; /* dependencies */ | 840 | int depcount; /* number of dependencies */ |
838 | lt_module module; /* system module handle */ | 841 | lt_dlhandle *deplibs; /* dependencies */ |
839 | lt_ptr system; /* system specific data */ | 842 | lt_module module; /* system module handle */ |
840 | lt_caller_data *caller_data; /* per caller associated data */ | 843 | lt_ptr system; /* system specific data */ |
841 | int flags; /* various boolean stats */ | 844 | lt_caller_data *caller_data; /* per caller associated data */ |
845 | int flags; /* various boolean stats */ | ||
842 | }; | 846 | }; |
843 | 847 | ||
844 | /* Various boolean flags can be stored in the flags field of an | 848 | /* Various boolean flags can be stored in the flags field of an |
@@ -854,18 +858,18 @@ struct lt_dlhandle_struct { | |||
854 | 858 | ||
855 | #define LT_DLSTRERROR(name) lt_dlerror_strings[LT_CONC(LT_ERROR_,name)] | 859 | #define LT_DLSTRERROR(name) lt_dlerror_strings[LT_CONC(LT_ERROR_,name)] |
856 | 860 | ||
857 | static const char objdir[] = LTDL_OBJDIR; | 861 | static const char objdir[] = LTDL_OBJDIR; |
858 | static const char archive_ext[] = LTDL_ARCHIVE_EXT; | 862 | static const char archive_ext[] = LTDL_ARCHIVE_EXT; |
859 | #ifdef LTDL_SHLIB_EXT | 863 | #ifdef LTDL_SHLIB_EXT |
860 | static const char shlib_ext[] = LTDL_SHLIB_EXT; | 864 | static const char shlib_ext[] = LTDL_SHLIB_EXT; |
861 | #endif | 865 | #endif |
862 | #ifdef LTDL_SYSSEARCHPATH | 866 | #ifdef LTDL_SYSSEARCHPATH |
863 | static const char sys_search_path[] = LTDL_SYSSEARCHPATH; | 867 | static const char sys_search_path[] = LTDL_SYSSEARCHPATH; |
864 | #endif | 868 | #endif |
869 | |||
865 | 870 | ||
866 | 871 | ||
867 | 872 | ||
868 | |||
869 | /* --- MUTEX LOCKING --- */ | 873 | /* --- MUTEX LOCKING --- */ |
870 | 874 | ||
871 | 875 | ||
@@ -891,11 +895,11 @@ static const char sys_search_path[] = LTDL_SYSSEARCHPATH; | |||
891 | 895 | ||
892 | /* The mutex functions stored here are global, and are necessarily the | 896 | /* The mutex functions stored here are global, and are necessarily the |
893 | same for all threads that wish to share access to libltdl. */ | 897 | same for all threads that wish to share access to libltdl. */ |
894 | static lt_dlmutex_lock *lt_dlmutex_lock_func = 0; | 898 | static lt_dlmutex_lock *lt_dlmutex_lock_func = 0; |
895 | static lt_dlmutex_unlock *lt_dlmutex_unlock_func = 0; | 899 | static lt_dlmutex_unlock *lt_dlmutex_unlock_func = 0; |
896 | static lt_dlmutex_seterror *lt_dlmutex_seterror_func = 0; | 900 | static lt_dlmutex_seterror *lt_dlmutex_seterror_func = 0; |
897 | static lt_dlmutex_geterror *lt_dlmutex_geterror_func = 0; | 901 | static lt_dlmutex_geterror *lt_dlmutex_geterror_func = 0; |
898 | static const char *lt_dllast_error = 0; | 902 | static const char *lt_dllast_error = 0; |
899 | 903 | ||
900 | 904 | ||
901 | /* Either set or reset the mutex functions. Either all the arguments must | 905 | /* Either set or reset the mutex functions. Either all the arguments must |
@@ -910,7 +914,7 @@ lt_dlmutex_register (lock, unlock, seterror, geterror) | |||
910 | lt_dlmutex_geterror *geterror; | 914 | lt_dlmutex_geterror *geterror; |
911 | { | 915 | { |
912 | lt_dlmutex_unlock *old_unlock = unlock; | 916 | lt_dlmutex_unlock *old_unlock = unlock; |
913 | int errors = 0; | 917 | int errors = 0; |
914 | 918 | ||
915 | /* Lock using the old lock() callback, if any. */ | 919 | /* Lock using the old lock() callback, if any. */ |
916 | LT_DLMUTEX_LOCK (); | 920 | LT_DLMUTEX_LOCK (); |
@@ -918,8 +922,8 @@ lt_dlmutex_register (lock, unlock, seterror, geterror) | |||
918 | if ((lock && unlock && seterror && geterror) | 922 | if ((lock && unlock && seterror && geterror) |
919 | || !(lock || unlock || seterror || geterror)) | 923 | || !(lock || unlock || seterror || geterror)) |
920 | { | 924 | { |
921 | lt_dlmutex_lock_func = lock; | 925 | lt_dlmutex_lock_func = lock; |
922 | lt_dlmutex_unlock_func = unlock; | 926 | lt_dlmutex_unlock_func = unlock; |
923 | lt_dlmutex_geterror_func = geterror; | 927 | lt_dlmutex_geterror_func = geterror; |
924 | } | 928 | } |
925 | else | 929 | else |
@@ -937,23 +941,23 @@ lt_dlmutex_register (lock, unlock, seterror, geterror) | |||
937 | this function. */ | 941 | this function. */ |
938 | return errors; | 942 | return errors; |
939 | } | 943 | } |
944 | |||
940 | 945 | ||
941 | 946 | ||
942 | 947 | ||
943 | |||
944 | /* --- ERROR HANDLING --- */ | 948 | /* --- ERROR HANDLING --- */ |
945 | 949 | ||
946 | 950 | ||
947 | static const char **user_error_strings = 0; | 951 | static const char **user_error_strings = 0; |
948 | static int errorcount = LT_ERROR_MAX; | 952 | static int errorcount = LT_ERROR_MAX; |
949 | 953 | ||
950 | int | 954 | int |
951 | lt_dladderror (diagnostic) | 955 | lt_dladderror (diagnostic) |
952 | const char *diagnostic; | 956 | const char *diagnostic; |
953 | { | 957 | { |
954 | int errindex = 0; | 958 | int errindex = 0; |
955 | int result = -1; | 959 | int result = -1; |
956 | const char **temp = (const char **) 0; | 960 | const char **temp = (const char **) 0; |
957 | 961 | ||
958 | assert (diagnostic); | 962 | assert (diagnostic); |
959 | 963 | ||
@@ -963,9 +967,9 @@ lt_dladderror (diagnostic) | |||
963 | temp = LT_EREALLOC (const char *, user_error_strings, 1 + errindex); | 967 | temp = LT_EREALLOC (const char *, user_error_strings, 1 + errindex); |
964 | if (temp) | 968 | if (temp) |
965 | { | 969 | { |
966 | user_error_strings = temp; | 970 | user_error_strings = temp; |
967 | user_error_strings[errindex] = diagnostic; | 971 | user_error_strings[errindex] = diagnostic; |
968 | result = errorcount++; | 972 | result = errorcount++; |
969 | } | 973 | } |
970 | 974 | ||
971 | LT_DLMUTEX_UNLOCK (); | 975 | LT_DLMUTEX_UNLOCK (); |
@@ -977,7 +981,7 @@ int | |||
977 | lt_dlseterror (errindex) | 981 | lt_dlseterror (errindex) |
978 | int errindex; | 982 | int errindex; |
979 | { | 983 | { |
980 | int errors = 0; | 984 | int errors = 0; |
981 | 985 | ||
982 | LT_DLMUTEX_LOCK (); | 986 | LT_DLMUTEX_LOCK (); |
983 | 987 | ||
@@ -1033,10 +1037,10 @@ lt_estrdup (str) | |||
1033 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (NO_MEMORY)); | 1037 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (NO_MEMORY)); |
1034 | return copy; | 1038 | return copy; |
1035 | } | 1039 | } |
1040 | |||
1036 | 1041 | ||
1037 | 1042 | ||
1038 | 1043 | ||
1039 | |||
1040 | /* --- DLOPEN() INTERFACE LOADER --- */ | 1044 | /* --- DLOPEN() INTERFACE LOADER --- */ |
1041 | 1045 | ||
1042 | 1046 | ||
@@ -1087,7 +1091,7 @@ sys_dl_open (loader_data, filename) | |||
1087 | lt_user_data loader_data; | 1091 | lt_user_data loader_data; |
1088 | const char *filename; | 1092 | const char *filename; |
1089 | { | 1093 | { |
1090 | lt_module module = dlopen (filename, LT_LAZY_OR_NOW); | 1094 | lt_module module = dlopen (filename, LT_LAZY_OR_NOW); |
1091 | 1095 | ||
1092 | if (!module) | 1096 | if (!module) |
1093 | { | 1097 | { |
@@ -1129,20 +1133,20 @@ sys_dl_sym (loader_data, module, symbol) | |||
1129 | return address; | 1133 | return address; |
1130 | } | 1134 | } |
1131 | 1135 | ||
1132 | static struct lt_user_dlloader sys_dl = | 1136 | static struct lt_user_dlloader sys_dl = { |
1133 | { | ||
1134 | # ifdef NEED_USCORE | 1137 | # ifdef NEED_USCORE |
1135 | "_", | 1138 | "_", |
1136 | # else | 1139 | # else |
1137 | 0, | 1140 | 0, |
1138 | # endif | 1141 | # endif |
1139 | sys_dl_open, sys_dl_close, sys_dl_sym, 0, 0 }; | 1142 | sys_dl_open, sys_dl_close, sys_dl_sym, 0, 0 |
1143 | }; | ||
1140 | 1144 | ||
1141 | 1145 | ||
1142 | #endif /* HAVE_LIBDL */ | 1146 | #endif /* HAVE_LIBDL */ |
1147 | |||
1143 | 1148 | ||
1144 | 1149 | ||
1145 | |||
1146 | /* --- SHL_LOAD() INTERFACE LOADER --- */ | 1150 | /* --- SHL_LOAD() INTERFACE LOADER --- */ |
1147 | 1151 | ||
1148 | #if HAVE_SHL_LOAD | 1152 | #if HAVE_SHL_LOAD |
@@ -1220,9 +1224,9 @@ sys_shl_open (loader_data, filename) | |||
1220 | module = shl_load (filename, LT_BIND_FLAGS, 0L); | 1224 | module = shl_load (filename, LT_BIND_FLAGS, 0L); |
1221 | 1225 | ||
1222 | if (!module) | 1226 | if (!module) |
1223 | { | 1227 | { |
1224 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (CANNOT_OPEN)); | 1228 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (CANNOT_OPEN)); |
1225 | } | 1229 | } |
1226 | } | 1230 | } |
1227 | 1231 | ||
1228 | return module; | 1232 | return module; |
@@ -1254,15 +1258,16 @@ sys_shl_sym (loader_data, module, symbol) | |||
1254 | 1258 | ||
1255 | /* sys_shl_open should never return a NULL module handle */ | 1259 | /* sys_shl_open should never return a NULL module handle */ |
1256 | if (module == (lt_module) 0) | 1260 | if (module == (lt_module) 0) |
1257 | { | 1261 | { |
1258 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (INVALID_HANDLE)); | 1262 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (INVALID_HANDLE)); |
1259 | } | 1263 | } |
1260 | else if (!shl_findsym((shl_t*) &module, symbol, TYPE_UNDEFINED, &address)) | 1264 | else |
1265 | if (!shl_findsym ((shl_t *) & module, symbol, TYPE_UNDEFINED, &address)) | ||
1261 | { | 1266 | { |
1262 | if (!address) | 1267 | if (!address) |
1263 | { | 1268 | { |
1264 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (SYMBOL_NOT_FOUND)); | 1269 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (SYMBOL_NOT_FOUND)); |
1265 | } | 1270 | } |
1266 | } | 1271 | } |
1267 | 1272 | ||
1268 | return address; | 1273 | return address; |
@@ -1273,10 +1278,10 @@ static struct lt_user_dlloader sys_shl = { | |||
1273 | }; | 1278 | }; |
1274 | 1279 | ||
1275 | #endif /* HAVE_SHL_LOAD */ | 1280 | #endif /* HAVE_SHL_LOAD */ |
1281 | |||
1276 | 1282 | ||
1277 | 1283 | ||
1278 | 1284 | ||
1279 | |||
1280 | /* --- LOADLIBRARY() INTERFACE LOADER --- */ | 1285 | /* --- LOADLIBRARY() INTERFACE LOADER --- */ |
1281 | 1286 | ||
1282 | #ifdef __WINDOWS__ | 1287 | #ifdef __WINDOWS__ |
@@ -1293,12 +1298,12 @@ sys_wll_open (loader_data, filename) | |||
1293 | lt_user_data loader_data; | 1298 | lt_user_data loader_data; |
1294 | const char *filename; | 1299 | const char *filename; |
1295 | { | 1300 | { |
1296 | lt_dlhandle cur; | 1301 | lt_dlhandle cur; |
1297 | lt_module module = 0; | 1302 | lt_module module = 0; |
1298 | const char *errormsg = 0; | 1303 | const char *errormsg = 0; |
1299 | char *searchname = 0; | 1304 | char *searchname = 0; |
1300 | char *ext; | 1305 | char *ext; |
1301 | char self_name_buf[MAX_PATH]; | 1306 | char self_name_buf[MAX_PATH]; |
1302 | 1307 | ||
1303 | if (!filename) | 1308 | if (!filename) |
1304 | { | 1309 | { |
@@ -1320,10 +1325,10 @@ sys_wll_open (loader_data, filename) | |||
1320 | else | 1325 | else |
1321 | { | 1326 | { |
1322 | /* Append a `.' to stop Windows from adding an | 1327 | /* Append a `.' to stop Windows from adding an |
1323 | implicit `.dll' extension. */ | 1328 | implicit `.dll' extension. */ |
1324 | searchname = LT_EMALLOC (char, 2+ LT_STRLEN (filename)); | 1329 | searchname = LT_EMALLOC (char, 2 + LT_STRLEN (filename)); |
1325 | if (searchname) | 1330 | if (searchname) |
1326 | sprintf (searchname, "%s.", filename); | 1331 | sprintf (searchname, "%s.", filename); |
1327 | } | 1332 | } |
1328 | if (!searchname) | 1333 | if (!searchname) |
1329 | return 0; | 1334 | return 0; |
@@ -1331,8 +1336,8 @@ sys_wll_open (loader_data, filename) | |||
1331 | #if __CYGWIN__ | 1336 | #if __CYGWIN__ |
1332 | { | 1337 | { |
1333 | char wpath[MAX_PATH]; | 1338 | char wpath[MAX_PATH]; |
1334 | cygwin_conv_to_full_win32_path(searchname, wpath); | 1339 | cygwin_conv_to_full_win32_path (searchname, wpath); |
1335 | module = LoadLibrary(wpath); | 1340 | module = LoadLibrary (wpath); |
1336 | } | 1341 | } |
1337 | #else | 1342 | #else |
1338 | module = LoadLibrary (searchname); | 1343 | module = LoadLibrary (searchname); |
@@ -1352,18 +1357,18 @@ sys_wll_open (loader_data, filename) | |||
1352 | while (cur) | 1357 | while (cur) |
1353 | { | 1358 | { |
1354 | if (!cur->module) | 1359 | if (!cur->module) |
1355 | { | 1360 | { |
1356 | cur = 0; | 1361 | cur = 0; |
1357 | break; | 1362 | break; |
1358 | } | 1363 | } |
1359 | 1364 | ||
1360 | if (cur->module == module) | 1365 | if (cur->module == module) |
1361 | { | 1366 | { |
1362 | break; | 1367 | break; |
1363 | } | 1368 | } |
1364 | 1369 | ||
1365 | cur = cur->next; | 1370 | cur = cur->next; |
1366 | } | 1371 | } |
1367 | LT_DLMUTEX_UNLOCK (); | 1372 | LT_DLMUTEX_UNLOCK (); |
1368 | 1373 | ||
1369 | if (cur || !module) | 1374 | if (cur || !module) |
@@ -1380,9 +1385,9 @@ sys_wll_close (loader_data, module) | |||
1380 | lt_user_data loader_data; | 1385 | lt_user_data loader_data; |
1381 | lt_module module; | 1386 | lt_module module; |
1382 | { | 1387 | { |
1383 | int errors = 0; | 1388 | int errors = 0; |
1384 | 1389 | ||
1385 | if (FreeLibrary(module) == 0) | 1390 | if (FreeLibrary (module) == 0) |
1386 | { | 1391 | { |
1387 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (CANNOT_CLOSE)); | 1392 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (CANNOT_CLOSE)); |
1388 | ++errors; | 1393 | ++errors; |
@@ -1397,7 +1402,7 @@ sys_wll_sym (loader_data, module, symbol) | |||
1397 | lt_module module; | 1402 | lt_module module; |
1398 | const char *symbol; | 1403 | const char *symbol; |
1399 | { | 1404 | { |
1400 | lt_ptr address = GetProcAddress (module, symbol); | 1405 | lt_ptr address = GetProcAddress (module, symbol); |
1401 | 1406 | ||
1402 | if (!address) | 1407 | if (!address) |
1403 | { | 1408 | { |
@@ -1412,10 +1417,10 @@ static struct lt_user_dlloader sys_wll = { | |||
1412 | }; | 1417 | }; |
1413 | 1418 | ||
1414 | #endif /* __WINDOWS__ */ | 1419 | #endif /* __WINDOWS__ */ |
1420 | |||
1415 | 1421 | ||
1416 | 1422 | ||
1417 | 1423 | ||
1418 | |||
1419 | /* --- LOAD_ADD_ON() INTERFACE LOADER --- */ | 1424 | /* --- LOAD_ADD_ON() INTERFACE LOADER --- */ |
1420 | 1425 | ||
1421 | 1426 | ||
@@ -1441,7 +1446,7 @@ sys_bedl_open (loader_data, filename) | |||
1441 | image_info info; | 1446 | image_info info; |
1442 | int32 cookie = 0; | 1447 | int32 cookie = 0; |
1443 | if (get_next_image_info (0, &cookie, &info) == B_OK) | 1448 | if (get_next_image_info (0, &cookie, &info) == B_OK) |
1444 | image = load_add_on (info.name); | 1449 | image = load_add_on (info.name); |
1445 | } | 1450 | } |
1446 | 1451 | ||
1447 | if (image <= 0) | 1452 | if (image <= 0) |
@@ -1492,10 +1497,10 @@ static struct lt_user_dlloader sys_bedl = { | |||
1492 | }; | 1497 | }; |
1493 | 1498 | ||
1494 | #endif /* __BEOS__ */ | 1499 | #endif /* __BEOS__ */ |
1500 | |||
1495 | 1501 | ||
1496 | 1502 | ||
1497 | 1503 | ||
1498 | |||
1499 | /* --- DLD_LINK() INTERFACE LOADER --- */ | 1504 | /* --- DLD_LINK() INTERFACE LOADER --- */ |
1500 | 1505 | ||
1501 | 1506 | ||
@@ -1531,7 +1536,7 @@ sys_dld_close (loader_data, module) | |||
1531 | { | 1536 | { |
1532 | int errors = 0; | 1537 | int errors = 0; |
1533 | 1538 | ||
1534 | if (dld_unlink_by_file ((char*)(module), 1) != 0) | 1539 | if (dld_unlink_by_file ((char *) (module), 1) != 0) |
1535 | { | 1540 | { |
1536 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (CANNOT_CLOSE)); | 1541 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (CANNOT_CLOSE)); |
1537 | ++errors; | 1542 | ++errors; |
@@ -1584,10 +1589,11 @@ static struct lt_user_dlloader sys_dld = { | |||
1584 | # define ENUM_DYLD_BOOL | 1589 | # define ENUM_DYLD_BOOL |
1585 | # undef FALSE | 1590 | # undef FALSE |
1586 | # undef TRUE | 1591 | # undef TRUE |
1587 | enum DYLD_BOOL { | 1592 | enum DYLD_BOOL |
1588 | FALSE, | 1593 | { |
1589 | TRUE | 1594 | FALSE, |
1590 | }; | 1595 | TRUE |
1596 | }; | ||
1591 | #endif | 1597 | #endif |
1592 | #ifndef LC_REQ_DYLD | 1598 | #ifndef LC_REQ_DYLD |
1593 | # define LC_REQ_DYLD 0x80000000 | 1599 | # define LC_REQ_DYLD 0x80000000 |
@@ -1595,10 +1601,18 @@ static struct lt_user_dlloader sys_dld = { | |||
1595 | #ifndef LC_LOAD_WEAK_DYLIB | 1601 | #ifndef LC_LOAD_WEAK_DYLIB |
1596 | # define LC_LOAD_WEAK_DYLIB (0x18 | LC_REQ_DYLD) | 1602 | # define LC_LOAD_WEAK_DYLIB (0x18 | LC_REQ_DYLD) |
1597 | #endif | 1603 | #endif |
1598 | static const struct mach_header * (*ltdl_NSAddImage)(const char *image_name, unsigned long options) = 0; | 1604 | static const struct mach_header *(*ltdl_NSAddImage) (const char *image_name, |
1599 | static NSSymbol (*ltdl_NSLookupSymbolInImage)(const struct mach_header *image,const char *symbolName, unsigned long options) = 0; | 1605 | unsigned long options) = |
1600 | static enum DYLD_BOOL (*ltdl_NSIsSymbolNameDefinedInImage)(const struct mach_header *image, const char *symbolName) = 0; | 1606 | 0; |
1601 | static enum DYLD_BOOL (*ltdl_NSMakePrivateModulePublic)(NSModule module) = 0; | 1607 | static NSSymbol (*ltdl_NSLookupSymbolInImage) (const struct mach_header * |
1608 | image, const char *symbolName, | ||
1609 | unsigned long options) = 0; | ||
1610 | static enum DYLD_BOOL (*ltdl_NSIsSymbolNameDefinedInImage) (const struct | ||
1611 | mach_header * | ||
1612 | image, | ||
1613 | const char | ||
1614 | *symbolName) = 0; | ||
1615 | static enum DYLD_BOOL (*ltdl_NSMakePrivateModulePublic) (NSModule module) = 0; | ||
1602 | 1616 | ||
1603 | #ifndef NSADDIMAGE_OPTION_NONE | 1617 | #ifndef NSADDIMAGE_OPTION_NONE |
1604 | #define NSADDIMAGE_OPTION_NONE 0x0 | 1618 | #define NSADDIMAGE_OPTION_NONE 0x0 |
@@ -1630,144 +1644,170 @@ static enum DYLD_BOOL (*ltdl_NSMakePrivateModulePublic)(NSModule module) = 0; | |||
1630 | 1644 | ||
1631 | 1645 | ||
1632 | static const char * | 1646 | static const char * |
1633 | lt_int_dyld_error(othererror) | 1647 | lt_int_dyld_error (othererror) |
1634 | char* othererror; | 1648 | char *othererror; |
1635 | { | 1649 | { |
1636 | /* return the dyld error string, or the passed in error string if none */ | 1650 | /* return the dyld error string, or the passed in error string if none */ |
1637 | NSLinkEditErrors ler; | 1651 | NSLinkEditErrors ler; |
1638 | int lerno; | 1652 | int lerno; |
1639 | const char *errstr; | 1653 | const char *errstr; |
1640 | const char *file; | 1654 | const char *file; |
1641 | NSLinkEditError(&ler,&lerno,&file,&errstr); | 1655 | NSLinkEditError (&ler, &lerno, &file, &errstr); |
1642 | if (!errstr || !strlen(errstr)) errstr = othererror; | 1656 | if (!errstr || !strlen (errstr)) |
1643 | return errstr; | 1657 | errstr = othererror; |
1658 | return errstr; | ||
1644 | } | 1659 | } |
1645 | 1660 | ||
1646 | static const struct mach_header * | 1661 | static const struct mach_header * |
1647 | lt_int_dyld_get_mach_header_from_nsmodule(module) | 1662 | lt_int_dyld_get_mach_header_from_nsmodule (module) |
1648 | NSModule module; | 1663 | NSModule module; |
1649 | { | 1664 | { |
1650 | /* There should probably be an apple dyld api for this */ | 1665 | /* There should probably be an apple dyld api for this */ |
1651 | int i=_dyld_image_count(); | 1666 | int i = _dyld_image_count (); |
1652 | int j; | 1667 | int j; |
1653 | const char *modname=NSNameOfModule(module); | 1668 | const char *modname = NSNameOfModule (module); |
1654 | const struct mach_header *mh=NULL; | 1669 | const struct mach_header *mh = NULL; |
1655 | if (!modname) return NULL; | 1670 | if (!modname) |
1656 | for (j = 0; j < i; j++) | 1671 | return NULL; |
1657 | { | 1672 | for (j = 0; j < i; j++) |
1658 | if (!strcmp(_dyld_get_image_name(j),modname)) | 1673 | { |
1659 | { | 1674 | if (!strcmp (_dyld_get_image_name (j), modname)) |
1660 | mh=_dyld_get_image_header(j); | 1675 | { |
1661 | break; | 1676 | mh = _dyld_get_image_header (j); |
1662 | } | 1677 | break; |
1663 | } | 1678 | } |
1664 | return mh; | 1679 | } |
1680 | return mh; | ||
1665 | } | 1681 | } |
1666 | 1682 | ||
1667 | static const char* lt_int_dyld_lib_install_name(mh) | 1683 | static const char * |
1668 | const struct mach_header *mh; | 1684 | lt_int_dyld_lib_install_name (mh) |
1685 | const struct mach_header *mh; | ||
1669 | { | 1686 | { |
1670 | /* NSAddImage is also used to get the loaded image, but it only works if the lib | 1687 | /* NSAddImage is also used to get the loaded image, but it only works if the lib |
1671 | is installed, for uninstalled libs we need to check the install_names against | 1688 | is installed, for uninstalled libs we need to check the install_names against |
1672 | each other. Note that this is still broken if DYLD_IMAGE_SUFFIX is set and a | 1689 | each other. Note that this is still broken if DYLD_IMAGE_SUFFIX is set and a |
1673 | different lib was loaded as a result | 1690 | different lib was loaded as a result |
1674 | */ | 1691 | */ |
1675 | int j; | 1692 | int j; |
1676 | struct load_command *lc; | 1693 | struct load_command *lc; |
1677 | unsigned long offset = sizeof(struct mach_header); | 1694 | unsigned long offset = sizeof (struct mach_header); |
1678 | const char* retStr=NULL; | 1695 | const char *retStr = NULL; |
1679 | for (j = 0; j < mh->ncmds; j++) | 1696 | for (j = 0; j < mh->ncmds; j++) |
1680 | { | 1697 | { |
1681 | lc = (struct load_command*)(((unsigned long)mh) + offset); | 1698 | lc = (struct load_command *) (((unsigned long) mh) + offset); |
1682 | if (LC_ID_DYLIB == lc->cmd) | 1699 | if (LC_ID_DYLIB == lc->cmd) |
1683 | { | 1700 | { |
1684 | retStr=(char*)(((struct dylib_command*)lc)->dylib.name.offset + | 1701 | retStr = |
1685 | (unsigned long)lc); | 1702 | (char *) (((struct dylib_command *) lc)->dylib.name.offset + |
1686 | } | 1703 | (unsigned long) lc); |
1687 | offset += lc->cmdsize; | 1704 | } |
1688 | } | 1705 | offset += lc->cmdsize; |
1689 | return retStr; | 1706 | } |
1707 | return retStr; | ||
1690 | } | 1708 | } |
1691 | 1709 | ||
1692 | static const struct mach_header * | 1710 | static const struct mach_header * |
1693 | lt_int_dyld_match_loaded_lib_by_install_name(const char *name) | 1711 | lt_int_dyld_match_loaded_lib_by_install_name (const char *name) |
1694 | { | 1712 | { |
1695 | int i=_dyld_image_count(); | 1713 | int i = _dyld_image_count (); |
1696 | int j; | 1714 | int j; |
1697 | const struct mach_header *mh=NULL; | 1715 | const struct mach_header *mh = NULL; |
1698 | const char *id=NULL; | 1716 | const char *id = NULL; |
1699 | for (j = 0; j < i; j++) | 1717 | for (j = 0; j < i; j++) |
1700 | { | 1718 | { |
1701 | id=lt_int_dyld_lib_install_name(_dyld_get_image_header(j)); | 1719 | id = lt_int_dyld_lib_install_name (_dyld_get_image_header (j)); |
1702 | if ((id) && (!strcmp(id,name))) | 1720 | if ((id) && (!strcmp (id, name))) |
1703 | { | 1721 | { |
1704 | mh=_dyld_get_image_header(j); | 1722 | mh = _dyld_get_image_header (j); |
1705 | break; | 1723 | break; |
1706 | } | 1724 | } |
1707 | } | 1725 | } |
1708 | return mh; | 1726 | return mh; |
1709 | } | 1727 | } |
1710 | 1728 | ||
1711 | static NSSymbol | 1729 | static NSSymbol |
1712 | lt_int_dyld_NSlookupSymbolInLinkedLibs(symbol,mh) | 1730 | lt_int_dyld_NSlookupSymbolInLinkedLibs (symbol, mh) |
1713 | const char *symbol; | 1731 | const char *symbol; |
1714 | const struct mach_header *mh; | 1732 | const struct mach_header *mh; |
1715 | { | 1733 | { |
1716 | /* Safe to assume our mh is good */ | 1734 | /* Safe to assume our mh is good */ |
1717 | int j; | 1735 | int j; |
1718 | struct load_command *lc; | 1736 | struct load_command *lc; |
1719 | unsigned long offset = sizeof(struct mach_header); | 1737 | unsigned long offset = sizeof (struct mach_header); |
1720 | NSSymbol retSym = 0; | 1738 | NSSymbol retSym = 0; |
1721 | const struct mach_header *mh1; | 1739 | const struct mach_header *mh1; |
1722 | if ((ltdl_NSLookupSymbolInImage) && NSIsSymbolNameDefined(symbol) ) | 1740 | if ((ltdl_NSLookupSymbolInImage) && NSIsSymbolNameDefined (symbol)) |
1723 | { | 1741 | { |
1724 | for (j = 0; j < mh->ncmds; j++) | 1742 | for (j = 0; j < mh->ncmds; j++) |
1725 | { | 1743 | { |
1726 | lc = (struct load_command*)(((unsigned long)mh) + offset); | 1744 | lc = (struct load_command *) (((unsigned long) mh) + offset); |
1727 | if ((LC_LOAD_DYLIB == lc->cmd) || (LC_LOAD_WEAK_DYLIB == lc->cmd)) | 1745 | if ((LC_LOAD_DYLIB == lc->cmd) || (LC_LOAD_WEAK_DYLIB == lc->cmd)) |
1728 | { | 1746 | { |
1729 | mh1=lt_int_dyld_match_loaded_lib_by_install_name((char*)(((struct dylib_command*)lc)->dylib.name.offset + | 1747 | mh1 = |
1730 | (unsigned long)lc)); | 1748 | lt_int_dyld_match_loaded_lib_by_install_name ((char |
1731 | if (!mh1) | 1749 | *) (((struct |
1732 | { | 1750 | dylib_command |
1733 | /* Maybe NSAddImage can find it */ | 1751 | *) lc)-> |
1734 | mh1=ltdl_NSAddImage((char*)(((struct dylib_command*)lc)->dylib.name.offset + | 1752 | dylib.name. |
1735 | (unsigned long)lc), | 1753 | offset + |
1736 | NSADDIMAGE_OPTION_RETURN_ONLY_IF_LOADED + | 1754 | (unsigned |
1737 | NSADDIMAGE_OPTION_WITH_SEARCHING + | 1755 | long) |
1738 | NSADDIMAGE_OPTION_RETURN_ON_ERROR ); | 1756 | lc)); |
1739 | } | 1757 | if (!mh1) |
1740 | if (mh1) | 1758 | { |
1741 | { | 1759 | /* Maybe NSAddImage can find it */ |
1742 | retSym = ltdl_NSLookupSymbolInImage(mh1, | 1760 | mh1 = |
1743 | symbol, | 1761 | ltdl_NSAddImage ((char *) (((struct dylib_command *) lc)-> |
1744 | NSLOOKUPSYMBOLINIMAGE_OPTION_BIND_NOW | 1762 | dylib.name.offset + |
1745 | | NSLOOKUPSYMBOLINIMAGE_OPTION_RETURN_ON_ERROR | 1763 | (unsigned long) lc), |
1746 | ); | 1764 | NSADDIMAGE_OPTION_RETURN_ONLY_IF_LOADED + |
1747 | if (retSym) break; | 1765 | NSADDIMAGE_OPTION_WITH_SEARCHING + |
1748 | } | 1766 | NSADDIMAGE_OPTION_RETURN_ON_ERROR); |
1749 | } | 1767 | } |
1750 | offset += lc->cmdsize; | 1768 | if (mh1) |
1751 | } | 1769 | { |
1752 | } | 1770 | retSym = ltdl_NSLookupSymbolInImage (mh1, |
1753 | return retSym; | 1771 | symbol, |
1772 | NSLOOKUPSYMBOLINIMAGE_OPTION_BIND_NOW | ||
1773 | | | ||
1774 | NSLOOKUPSYMBOLINIMAGE_OPTION_RETURN_ON_ERROR); | ||
1775 | if (retSym) | ||
1776 | break; | ||
1777 | } | ||
1778 | } | ||
1779 | offset += lc->cmdsize; | ||
1780 | } | ||
1781 | } | ||
1782 | return retSym; | ||
1754 | } | 1783 | } |
1755 | 1784 | ||
1756 | static int | 1785 | static int |
1757 | sys_dyld_init() | 1786 | sys_dyld_init () |
1758 | { | 1787 | { |
1759 | int retCode = 0; | 1788 | int retCode = 0; |
1760 | int err = 0; | 1789 | int err = 0; |
1761 | if (!_dyld_present()) { | 1790 | if (!_dyld_present ()) |
1762 | retCode=1; | 1791 | { |
1763 | } | 1792 | retCode = 1; |
1764 | else { | 1793 | } |
1765 | err = _dyld_func_lookup("__dyld_NSAddImage",(unsigned long*)<dl_NSAddImage); | 1794 | else |
1766 | err = _dyld_func_lookup("__dyld_NSLookupSymbolInImage",(unsigned long*)<dl_NSLookupSymbolInImage); | 1795 | { |
1767 | err = _dyld_func_lookup("__dyld_NSIsSymbolNameDefinedInImage",(unsigned long*)<dl_NSIsSymbolNameDefinedInImage); | 1796 | err = |
1768 | err = _dyld_func_lookup("__dyld_NSMakePrivateModulePublic",(unsigned long*)<dl_NSMakePrivateModulePublic); | 1797 | _dyld_func_lookup ("__dyld_NSAddImage", |
1769 | } | 1798 | (unsigned long *) <dl_NSAddImage); |
1770 | return retCode; | 1799 | err = |
1800 | _dyld_func_lookup ("__dyld_NSLookupSymbolInImage", | ||
1801 | (unsigned long *) <dl_NSLookupSymbolInImage); | ||
1802 | err = | ||
1803 | _dyld_func_lookup ("__dyld_NSIsSymbolNameDefinedInImage", | ||
1804 | (unsigned long *) | ||
1805 | <dl_NSIsSymbolNameDefinedInImage); | ||
1806 | err = | ||
1807 | _dyld_func_lookup ("__dyld_NSMakePrivateModulePublic", | ||
1808 | (unsigned long *) <dl_NSMakePrivateModulePublic); | ||
1809 | } | ||
1810 | return retCode; | ||
1771 | } | 1811 | } |
1772 | 1812 | ||
1773 | static lt_module | 1813 | static lt_module |
@@ -1775,35 +1815,38 @@ sys_dyld_open (loader_data, filename) | |||
1775 | lt_user_data loader_data; | 1815 | lt_user_data loader_data; |
1776 | const char *filename; | 1816 | const char *filename; |
1777 | { | 1817 | { |
1778 | lt_module module = 0; | 1818 | lt_module module = 0; |
1779 | NSObjectFileImage ofi = 0; | 1819 | NSObjectFileImage ofi = 0; |
1780 | NSObjectFileImageReturnCode ofirc; | 1820 | NSObjectFileImageReturnCode ofirc; |
1781 | 1821 | ||
1782 | if (!filename) | 1822 | if (!filename) |
1783 | return (lt_module)-1; | 1823 | return (lt_module) - 1; |
1784 | ofirc = NSCreateObjectFileImageFromFile(filename, &ofi); | 1824 | ofirc = NSCreateObjectFileImageFromFile (filename, &ofi); |
1785 | switch (ofirc) | 1825 | switch (ofirc) |
1786 | { | 1826 | { |
1787 | case NSObjectFileImageSuccess: | 1827 | case NSObjectFileImageSuccess: |
1788 | module = NSLinkModule(ofi, filename, | 1828 | module = NSLinkModule (ofi, filename, |
1789 | NSLINKMODULE_OPTION_RETURN_ON_ERROR | 1829 | NSLINKMODULE_OPTION_RETURN_ON_ERROR |
1790 | | NSLINKMODULE_OPTION_PRIVATE | 1830 | | NSLINKMODULE_OPTION_PRIVATE |
1791 | | NSLINKMODULE_OPTION_BINDNOW); | 1831 | | NSLINKMODULE_OPTION_BINDNOW); |
1792 | NSDestroyObjectFileImage(ofi); | 1832 | NSDestroyObjectFileImage (ofi); |
1793 | if (module) | 1833 | if (module) |
1794 | ltdl_NSMakePrivateModulePublic(module); | 1834 | ltdl_NSMakePrivateModulePublic (module); |
1795 | break; | 1835 | break; |
1796 | case NSObjectFileImageInappropriateFile: | 1836 | case NSObjectFileImageInappropriateFile: |
1797 | if (ltdl_NSIsSymbolNameDefinedInImage && ltdl_NSLookupSymbolInImage) | 1837 | if (ltdl_NSIsSymbolNameDefinedInImage && ltdl_NSLookupSymbolInImage) |
1798 | { | 1838 | { |
1799 | module = (lt_module)ltdl_NSAddImage(filename, NSADDIMAGE_OPTION_RETURN_ON_ERROR); | 1839 | module = |
1800 | break; | 1840 | (lt_module) ltdl_NSAddImage (filename, |
1801 | } | 1841 | NSADDIMAGE_OPTION_RETURN_ON_ERROR); |
1802 | default: | 1842 | break; |
1803 | LT_DLMUTEX_SETERROR (lt_int_dyld_error(LT_DLSTRERROR(CANNOT_OPEN))); | 1843 | } |
1804 | return 0; | 1844 | default: |
1805 | } | 1845 | LT_DLMUTEX_SETERROR (lt_int_dyld_error (LT_DLSTRERROR (CANNOT_OPEN))); |
1806 | if (!module) LT_DLMUTEX_SETERROR (lt_int_dyld_error(LT_DLSTRERROR(CANNOT_OPEN))); | 1846 | return 0; |
1847 | } | ||
1848 | if (!module) | ||
1849 | LT_DLMUTEX_SETERROR (lt_int_dyld_error (LT_DLSTRERROR (CANNOT_OPEN))); | ||
1807 | return module; | 1850 | return module; |
1808 | } | 1851 | } |
1809 | 1852 | ||
@@ -1812,43 +1855,45 @@ sys_dyld_close (loader_data, module) | |||
1812 | lt_user_data loader_data; | 1855 | lt_user_data loader_data; |
1813 | lt_module module; | 1856 | lt_module module; |
1814 | { | 1857 | { |
1815 | int retCode = 0; | 1858 | int retCode = 0; |
1816 | int flags = 0; | 1859 | int flags = 0; |
1817 | if (module == (lt_module)-1) return 0; | 1860 | if (module == (lt_module) - 1) |
1861 | return 0; | ||
1818 | #ifdef __BIG_ENDIAN__ | 1862 | #ifdef __BIG_ENDIAN__ |
1819 | if (((struct mach_header *)module)->magic == MH_MAGIC) | 1863 | if (((struct mach_header *) module)->magic == MH_MAGIC) |
1820 | #else | 1864 | #else |
1821 | if (((struct mach_header *)module)->magic == MH_CIGAM) | 1865 | if (((struct mach_header *) module)->magic == MH_CIGAM) |
1822 | #endif | 1866 | #endif |
1823 | { | 1867 | { |
1824 | LT_DLMUTEX_SETERROR("Can not close a dylib"); | 1868 | LT_DLMUTEX_SETERROR ("Can not close a dylib"); |
1825 | retCode = 1; | 1869 | retCode = 1; |
1826 | } | 1870 | } |
1827 | else | 1871 | else |
1828 | { | 1872 | { |
1829 | #if 1 | 1873 | #if 1 |
1830 | /* Currently, if a module contains c++ static destructors and it is unloaded, we | 1874 | /* Currently, if a module contains c++ static destructors and it is unloaded, we |
1831 | get a segfault in atexit(), due to compiler and dynamic loader differences of | 1875 | get a segfault in atexit(), due to compiler and dynamic loader differences of |
1832 | opinion, this works around that. | 1876 | opinion, this works around that. |
1833 | */ | 1877 | */ |
1834 | if ((const struct section *)NULL != | 1878 | if ((const struct section *) NULL != |
1835 | getsectbynamefromheader(lt_int_dyld_get_mach_header_from_nsmodule(module), | 1879 | getsectbynamefromheader (lt_int_dyld_get_mach_header_from_nsmodule |
1836 | "__DATA","__mod_term_func")) | 1880 | (module), "__DATA", "__mod_term_func")) |
1837 | { | 1881 | { |
1838 | flags += NSUNLINKMODULE_OPTION_KEEP_MEMORY_MAPPED; | 1882 | flags += NSUNLINKMODULE_OPTION_KEEP_MEMORY_MAPPED; |
1839 | } | 1883 | } |
1840 | #endif | 1884 | #endif |
1841 | #ifdef __ppc__ | 1885 | #ifdef __ppc__ |
1842 | flags += NSUNLINKMODULE_OPTION_RESET_LAZY_REFERENCES; | 1886 | flags += NSUNLINKMODULE_OPTION_RESET_LAZY_REFERENCES; |
1843 | #endif | 1887 | #endif |
1844 | if (!NSUnLinkModule(module,flags)) | 1888 | if (!NSUnLinkModule (module, flags)) |
1845 | { | 1889 | { |
1846 | retCode=1; | 1890 | retCode = 1; |
1847 | LT_DLMUTEX_SETERROR (lt_int_dyld_error(LT_DLSTRERROR(CANNOT_CLOSE))); | 1891 | LT_DLMUTEX_SETERROR (lt_int_dyld_error |
1848 | } | 1892 | (LT_DLSTRERROR (CANNOT_CLOSE))); |
1849 | } | 1893 | } |
1850 | 1894 | } | |
1851 | return retCode; | 1895 | |
1896 | return retCode; | ||
1852 | } | 1897 | } |
1853 | 1898 | ||
1854 | static lt_ptr | 1899 | static lt_ptr |
@@ -1857,52 +1902,57 @@ sys_dyld_sym (loader_data, module, symbol) | |||
1857 | lt_module module; | 1902 | lt_module module; |
1858 | const char *symbol; | 1903 | const char *symbol; |
1859 | { | 1904 | { |
1860 | lt_ptr address = 0; | 1905 | lt_ptr address = 0; |
1861 | NSSymbol *nssym = 0; | 1906 | NSSymbol *nssym = 0; |
1862 | void *unused; | 1907 | void *unused; |
1863 | const struct mach_header *mh=NULL; | 1908 | const struct mach_header *mh = NULL; |
1864 | char saveError[256] = "Symbol not found"; | 1909 | char saveError[256] = "Symbol not found"; |
1865 | if (module == (lt_module)-1) | 1910 | if (module == (lt_module) - 1) |
1866 | { | 1911 | { |
1867 | _dyld_lookup_and_bind(symbol,(unsigned long*)&address,&unused); | 1912 | _dyld_lookup_and_bind (symbol, (unsigned long *) &address, &unused); |
1868 | return address; | 1913 | return address; |
1869 | } | 1914 | } |
1870 | #ifdef __BIG_ENDIAN__ | 1915 | #ifdef __BIG_ENDIAN__ |
1871 | if (((struct mach_header *)module)->magic == MH_MAGIC) | 1916 | if (((struct mach_header *) module)->magic == MH_MAGIC) |
1872 | #else | 1917 | #else |
1873 | if (((struct mach_header *)module)->magic == MH_CIGAM) | 1918 | if (((struct mach_header *) module)->magic == MH_CIGAM) |
1874 | #endif | 1919 | #endif |
1875 | { | 1920 | { |
1876 | if (ltdl_NSIsSymbolNameDefinedInImage && ltdl_NSLookupSymbolInImage) | 1921 | if (ltdl_NSIsSymbolNameDefinedInImage && ltdl_NSLookupSymbolInImage) |
1877 | { | 1922 | { |
1878 | mh=module; | 1923 | mh = module; |
1879 | if (ltdl_NSIsSymbolNameDefinedInImage((struct mach_header*)module,symbol)) | 1924 | if (ltdl_NSIsSymbolNameDefinedInImage |
1880 | { | 1925 | ((struct mach_header *) module, symbol)) |
1881 | nssym = ltdl_NSLookupSymbolInImage((struct mach_header*)module, | 1926 | { |
1882 | symbol, | 1927 | nssym = |
1883 | NSLOOKUPSYMBOLINIMAGE_OPTION_BIND_NOW | 1928 | ltdl_NSLookupSymbolInImage ((struct mach_header *) module, |
1884 | | NSLOOKUPSYMBOLINIMAGE_OPTION_RETURN_ON_ERROR | 1929 | symbol, |
1885 | ); | 1930 | NSLOOKUPSYMBOLINIMAGE_OPTION_BIND_NOW |
1886 | } | 1931 | | |
1887 | } | 1932 | NSLOOKUPSYMBOLINIMAGE_OPTION_RETURN_ON_ERROR); |
1888 | 1933 | } | |
1889 | } | 1934 | } |
1890 | else { | 1935 | |
1891 | nssym = NSLookupSymbolInModule(module, symbol); | 1936 | } |
1892 | } | 1937 | else |
1893 | if (!nssym) | 1938 | { |
1894 | { | 1939 | nssym = NSLookupSymbolInModule (module, symbol); |
1895 | strncpy(saveError, lt_int_dyld_error(LT_DLSTRERROR(SYMBOL_NOT_FOUND)), 255); | 1940 | } |
1896 | saveError[255] = 0; | 1941 | if (!nssym) |
1897 | if (!mh) mh=lt_int_dyld_get_mach_header_from_nsmodule(module); | 1942 | { |
1898 | nssym = lt_int_dyld_NSlookupSymbolInLinkedLibs(symbol,mh); | 1943 | strncpy (saveError, |
1899 | } | 1944 | lt_int_dyld_error (LT_DLSTRERROR (SYMBOL_NOT_FOUND)), 255); |
1900 | if (!nssym) | 1945 | saveError[255] = 0; |
1901 | { | 1946 | if (!mh) |
1902 | LT_DLMUTEX_SETERROR (saveError); | 1947 | mh = lt_int_dyld_get_mach_header_from_nsmodule (module); |
1903 | return NULL; | 1948 | nssym = lt_int_dyld_NSlookupSymbolInLinkedLibs (symbol, mh); |
1904 | } | 1949 | } |
1905 | return NSAddressOfSymbol(nssym); | 1950 | if (!nssym) |
1951 | { | ||
1952 | LT_DLMUTEX_SETERROR (saveError); | ||
1953 | return NULL; | ||
1954 | } | ||
1955 | return NSAddressOfSymbol (nssym); | ||
1906 | } | 1956 | } |
1907 | 1957 | ||
1908 | static struct lt_user_dlloader sys_dyld = | 1958 | static struct lt_user_dlloader sys_dyld = |
@@ -1910,8 +1960,8 @@ static struct lt_user_dlloader sys_dyld = | |||
1910 | 1960 | ||
1911 | 1961 | ||
1912 | #endif /* HAVE_DYLD */ | 1962 | #endif /* HAVE_DYLD */ |
1913 | |||
1914 | 1963 | ||
1964 | |||
1915 | /* --- DLPREOPEN() INTERFACE LOADER --- */ | 1965 | /* --- DLPREOPEN() INTERFACE LOADER --- */ |
1916 | 1966 | ||
1917 | 1967 | ||
@@ -1919,12 +1969,12 @@ static struct lt_user_dlloader sys_dyld = | |||
1919 | 1969 | ||
1920 | typedef struct lt_dlsymlists_t | 1970 | typedef struct lt_dlsymlists_t |
1921 | { | 1971 | { |
1922 | struct lt_dlsymlists_t *next; | 1972 | struct lt_dlsymlists_t *next; |
1923 | const lt_dlsymlist *syms; | 1973 | const lt_dlsymlist *syms; |
1924 | } lt_dlsymlists_t; | 1974 | } lt_dlsymlists_t; |
1925 | 1975 | ||
1926 | static const lt_dlsymlist *default_preloaded_symbols = 0; | 1976 | static const lt_dlsymlist *default_preloaded_symbols = 0; |
1927 | static lt_dlsymlists_t *preloaded_symbols = 0; | 1977 | static lt_dlsymlists_t *preloaded_symbols = 0; |
1928 | 1978 | ||
1929 | static int | 1979 | static int |
1930 | presym_init (loader_data) | 1980 | presym_init (loader_data) |
@@ -1955,7 +2005,7 @@ presym_free_symlists () | |||
1955 | lists = preloaded_symbols; | 2005 | lists = preloaded_symbols; |
1956 | while (lists) | 2006 | while (lists) |
1957 | { | 2007 | { |
1958 | lt_dlsymlists_t *tmp = lists; | 2008 | lt_dlsymlists_t *tmp = lists; |
1959 | 2009 | ||
1960 | lists = lists->next; | 2010 | lists = lists->next; |
1961 | LT_DLFREE (tmp); | 2011 | LT_DLFREE (tmp); |
@@ -1981,7 +2031,7 @@ presym_add_symlist (preloaded) | |||
1981 | { | 2031 | { |
1982 | lt_dlsymlists_t *tmp; | 2032 | lt_dlsymlists_t *tmp; |
1983 | lt_dlsymlists_t *lists; | 2033 | lt_dlsymlists_t *lists; |
1984 | int errors = 0; | 2034 | int errors = 0; |
1985 | 2035 | ||
1986 | LT_DLMUTEX_LOCK (); | 2036 | LT_DLMUTEX_LOCK (); |
1987 | 2037 | ||
@@ -1989,16 +2039,16 @@ presym_add_symlist (preloaded) | |||
1989 | while (lists) | 2039 | while (lists) |
1990 | { | 2040 | { |
1991 | if (lists->syms == preloaded) | 2041 | if (lists->syms == preloaded) |
1992 | { | 2042 | { |
1993 | goto done; | 2043 | goto done; |
1994 | } | 2044 | } |
1995 | lists = lists->next; | 2045 | lists = lists->next; |
1996 | } | 2046 | } |
1997 | 2047 | ||
1998 | tmp = LT_EMALLOC (lt_dlsymlists_t, 1); | 2048 | tmp = LT_EMALLOC (lt_dlsymlists_t, 1); |
1999 | if (tmp) | 2049 | if (tmp) |
2000 | { | 2050 | { |
2001 | memset (tmp, 0, sizeof(lt_dlsymlists_t)); | 2051 | memset (tmp, 0, sizeof (lt_dlsymlists_t)); |
2002 | tmp->syms = preloaded; | 2052 | tmp->syms = preloaded; |
2003 | tmp->next = preloaded_symbols; | 2053 | tmp->next = preloaded_symbols; |
2004 | preloaded_symbols = tmp; | 2054 | preloaded_symbols = tmp; |
@@ -2008,7 +2058,7 @@ presym_add_symlist (preloaded) | |||
2008 | ++errors; | 2058 | ++errors; |
2009 | } | 2059 | } |
2010 | 2060 | ||
2011 | done: | 2061 | done: |
2012 | LT_DLMUTEX_UNLOCK (); | 2062 | LT_DLMUTEX_UNLOCK (); |
2013 | return errors; | 2063 | return errors; |
2014 | } | 2064 | } |
@@ -2019,7 +2069,7 @@ presym_open (loader_data, filename) | |||
2019 | const char *filename; | 2069 | const char *filename; |
2020 | { | 2070 | { |
2021 | lt_dlsymlists_t *lists; | 2071 | lt_dlsymlists_t *lists; |
2022 | lt_module module = (lt_module) 0; | 2072 | lt_module module = (lt_module) 0; |
2023 | 2073 | ||
2024 | LT_DLMUTEX_LOCK (); | 2074 | LT_DLMUTEX_LOCK (); |
2025 | lists = preloaded_symbols; | 2075 | lists = preloaded_symbols; |
@@ -2044,21 +2094,21 @@ presym_open (loader_data, filename) | |||
2044 | const lt_dlsymlist *syms = lists->syms; | 2094 | const lt_dlsymlist *syms = lists->syms; |
2045 | 2095 | ||
2046 | while (syms->name) | 2096 | while (syms->name) |
2047 | { | 2097 | { |
2048 | if (!syms->address && strcmp(syms->name, filename) == 0) | 2098 | if (!syms->address && strcmp (syms->name, filename) == 0) |
2049 | { | 2099 | { |
2050 | module = (lt_module) syms; | 2100 | module = (lt_module) syms; |
2051 | goto done; | 2101 | goto done; |
2052 | } | 2102 | } |
2053 | ++syms; | 2103 | ++syms; |
2054 | } | 2104 | } |
2055 | 2105 | ||
2056 | lists = lists->next; | 2106 | lists = lists->next; |
2057 | } | 2107 | } |
2058 | 2108 | ||
2059 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (FILE_NOT_FOUND)); | 2109 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (FILE_NOT_FOUND)); |
2060 | 2110 | ||
2061 | done: | 2111 | done: |
2062 | LT_DLMUTEX_UNLOCK (); | 2112 | LT_DLMUTEX_UNLOCK (); |
2063 | return module; | 2113 | return module; |
2064 | } | 2114 | } |
@@ -2079,18 +2129,18 @@ presym_sym (loader_data, module, symbol) | |||
2079 | lt_module module; | 2129 | lt_module module; |
2080 | const char *symbol; | 2130 | const char *symbol; |
2081 | { | 2131 | { |
2082 | lt_dlsymlist *syms = (lt_dlsymlist*) module; | 2132 | lt_dlsymlist *syms = (lt_dlsymlist *) module; |
2083 | 2133 | ||
2084 | ++syms; | 2134 | ++syms; |
2085 | while (syms->address) | 2135 | while (syms->address) |
2086 | { | 2136 | { |
2087 | if (strcmp(syms->name, symbol) == 0) | 2137 | if (strcmp (syms->name, symbol) == 0) |
2088 | { | 2138 | { |
2089 | return syms->address; | 2139 | return syms->address; |
2090 | } | 2140 | } |
2091 | 2141 | ||
2092 | ++syms; | 2142 | ++syms; |
2093 | } | 2143 | } |
2094 | 2144 | ||
2095 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (SYMBOL_NOT_FOUND)); | 2145 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (SYMBOL_NOT_FOUND)); |
2096 | 2146 | ||
@@ -2100,88 +2150,80 @@ presym_sym (loader_data, module, symbol) | |||
2100 | static struct lt_user_dlloader presym = { | 2150 | static struct lt_user_dlloader presym = { |
2101 | 0, presym_open, presym_close, presym_sym, presym_exit, 0 | 2151 | 0, presym_open, presym_close, presym_sym, presym_exit, 0 |
2102 | }; | 2152 | }; |
2153 | |||
2103 | 2154 | ||
2104 | 2155 | ||
2105 | 2156 | ||
2106 | 2157 | ||
2107 | |||
2108 | /* --- DYNAMIC MODULE LOADING --- */ | 2158 | /* --- DYNAMIC MODULE LOADING --- */ |
2109 | 2159 | ||
2110 | 2160 | ||
2111 | /* The type of a function used at each iteration of foreach_dirinpath(). */ | 2161 | /* The type of a function used at each iteration of foreach_dirinpath(). */ |
2112 | typedef int foreach_callback_func LT_PARAMS((char *filename, lt_ptr data1, | 2162 | typedef int foreach_callback_func LT_PARAMS ((char *filename, lt_ptr data1, |
2113 | lt_ptr data2)); | 2163 | lt_ptr data2)); |
2114 | 2164 | ||
2115 | static int foreach_dirinpath LT_PARAMS((const char *search_path, | 2165 | static int foreach_dirinpath LT_PARAMS ((const char *search_path, |
2116 | const char *base_name, | 2166 | const char *base_name, |
2117 | foreach_callback_func *func, | 2167 | foreach_callback_func * func, |
2118 | lt_ptr data1, lt_ptr data2)); | 2168 | lt_ptr data1, lt_ptr data2)); |
2119 | 2169 | ||
2120 | static int find_file_callback LT_PARAMS((char *filename, lt_ptr data, | 2170 | static int find_file_callback LT_PARAMS ((char *filename, lt_ptr data, |
2121 | lt_ptr ignored)); | 2171 | lt_ptr ignored)); |
2122 | static int find_handle_callback LT_PARAMS((char *filename, lt_ptr data, | 2172 | static int find_handle_callback LT_PARAMS ((char *filename, lt_ptr data, |
2123 | lt_ptr ignored)); | 2173 | lt_ptr ignored)); |
2124 | static int foreachfile_callback LT_PARAMS((char *filename, lt_ptr data1, | 2174 | static int foreachfile_callback LT_PARAMS ((char *filename, lt_ptr data1, |
2125 | lt_ptr data2)); | 2175 | lt_ptr data2)); |
2126 | 2176 | ||
2127 | 2177 | ||
2128 | static int canonicalize_path LT_PARAMS((const char *path, | 2178 | static int canonicalize_path LT_PARAMS ((const char *path, |
2129 | char **pcanonical)); | 2179 | char **pcanonical)); |
2130 | static int argzize_path LT_PARAMS((const char *path, | 2180 | static int argzize_path LT_PARAMS ((const char *path, |
2131 | char **pargz, | 2181 | char **pargz, size_t * pargz_len)); |
2132 | size_t *pargz_len)); | 2182 | static FILE *find_file LT_PARAMS ((const char *search_path, |
2133 | static FILE *find_file LT_PARAMS((const char *search_path, | 2183 | const char *base_name, char **pdir)); |
2134 | const char *base_name, | 2184 | static lt_dlhandle *find_handle LT_PARAMS ((const char *search_path, |
2135 | char **pdir)); | 2185 | const char *base_name, |
2136 | static lt_dlhandle *find_handle LT_PARAMS((const char *search_path, | 2186 | lt_dlhandle * handle)); |
2137 | const char *base_name, | 2187 | static int find_module LT_PARAMS ((lt_dlhandle * handle, |
2138 | lt_dlhandle *handle)); | 2188 | const char *dir, |
2139 | static int find_module LT_PARAMS((lt_dlhandle *handle, | 2189 | const char *libdir, |
2140 | const char *dir, | 2190 | const char *dlname, |
2141 | const char *libdir, | 2191 | const char *old_name, int installed)); |
2142 | const char *dlname, | 2192 | static int free_vars LT_PARAMS ((char *dlname, char *oldname, |
2143 | const char *old_name, | 2193 | char *libdir, char *deplibs)); |
2144 | int installed)); | 2194 | static int load_deplibs LT_PARAMS ((lt_dlhandle handle, char *deplibs)); |
2145 | static int free_vars LT_PARAMS((char *dlname, char *oldname, | 2195 | static int trim LT_PARAMS ((char **dest, const char *str)); |
2146 | char *libdir, char *deplibs)); | 2196 | static int try_dlopen LT_PARAMS ((lt_dlhandle * handle, |
2147 | static int load_deplibs LT_PARAMS((lt_dlhandle handle, | 2197 | const char *filename)); |
2148 | char *deplibs)); | 2198 | static int tryall_dlopen LT_PARAMS ((lt_dlhandle * handle, |
2149 | static int trim LT_PARAMS((char **dest, | 2199 | const char *filename)); |
2150 | const char *str)); | 2200 | static int unload_deplibs LT_PARAMS ((lt_dlhandle handle)); |
2151 | static int try_dlopen LT_PARAMS((lt_dlhandle *handle, | 2201 | static int lt_argz_insert LT_PARAMS ((char **pargz, |
2152 | const char *filename)); | 2202 | size_t * pargz_len, |
2153 | static int tryall_dlopen LT_PARAMS((lt_dlhandle *handle, | 2203 | char *before, const char *entry)); |
2154 | const char *filename)); | 2204 | static int lt_argz_insertinorder LT_PARAMS ((char **pargz, |
2155 | static int unload_deplibs LT_PARAMS((lt_dlhandle handle)); | 2205 | size_t * pargz_len, |
2156 | static int lt_argz_insert LT_PARAMS((char **pargz, | 2206 | const char *entry)); |
2157 | size_t *pargz_len, | 2207 | static int lt_argz_insertdir LT_PARAMS ((char **pargz, |
2158 | char *before, | 2208 | size_t * pargz_len, |
2159 | const char *entry)); | 2209 | const char *dirnam, |
2160 | static int lt_argz_insertinorder LT_PARAMS((char **pargz, | 2210 | struct dirent * dp)); |
2161 | size_t *pargz_len, | 2211 | static int lt_dlpath_insertdir LT_PARAMS ((char **ppath, |
2162 | const char *entry)); | 2212 | char *before, const char *dir)); |
2163 | static int lt_argz_insertdir LT_PARAMS((char **pargz, | 2213 | static int list_files_by_dir LT_PARAMS ((const char *dirnam, |
2164 | size_t *pargz_len, | 2214 | char **pargz, size_t * pargz_len)); |
2165 | const char *dirnam, | 2215 | static int file_not_found LT_PARAMS ((void)); |
2166 | struct dirent *dp)); | 2216 | |
2167 | static int lt_dlpath_insertdir LT_PARAMS((char **ppath, | 2217 | static char *user_search_path = 0; |
2168 | char *before, | 2218 | static lt_dlloader *loaders = 0; |
2169 | const char *dir)); | 2219 | static lt_dlhandle handles = 0; |
2170 | static int list_files_by_dir LT_PARAMS((const char *dirnam, | 2220 | static int initialized = 0; |
2171 | char **pargz, | ||
2172 | size_t *pargz_len)); | ||
2173 | static int file_not_found LT_PARAMS((void)); | ||
2174 | |||
2175 | static char *user_search_path= 0; | ||
2176 | static lt_dlloader *loaders = 0; | ||
2177 | static lt_dlhandle handles = 0; | ||
2178 | static int initialized = 0; | ||
2179 | 2221 | ||
2180 | /* Initialize libltdl. */ | 2222 | /* Initialize libltdl. */ |
2181 | int | 2223 | int |
2182 | lt_dlinit () | 2224 | lt_dlinit () |
2183 | { | 2225 | { |
2184 | int errors = 0; | 2226 | int errors = 0; |
2185 | 2227 | ||
2186 | LT_DLMUTEX_LOCK (); | 2228 | LT_DLMUTEX_LOCK (); |
2187 | 2229 | ||
@@ -2189,7 +2231,7 @@ lt_dlinit () | |||
2189 | if (++initialized == 1) | 2231 | if (++initialized == 1) |
2190 | { | 2232 | { |
2191 | handles = 0; | 2233 | handles = 0; |
2192 | user_search_path = 0; /* empty search path */ | 2234 | user_search_path = 0; /* empty search path */ |
2193 | 2235 | ||
2194 | #if HAVE_LIBDL | 2236 | #if HAVE_LIBDL |
2195 | errors += lt_dlloader_add (lt_dlloader_next (0), &sys_dl, "dlopen"); | 2237 | errors += lt_dlloader_add (lt_dlloader_next (0), &sys_dl, "dlopen"); |
@@ -2207,21 +2249,21 @@ lt_dlinit () | |||
2207 | errors += lt_dlloader_add (lt_dlloader_next (0), &sys_dld, "dld"); | 2249 | errors += lt_dlloader_add (lt_dlloader_next (0), &sys_dld, "dld"); |
2208 | #endif | 2250 | #endif |
2209 | #if HAVE_DYLD | 2251 | #if HAVE_DYLD |
2210 | errors += lt_dlloader_add (lt_dlloader_next (0), &sys_dyld, "dyld"); | 2252 | errors += lt_dlloader_add (lt_dlloader_next (0), &sys_dyld, "dyld"); |
2211 | errors += sys_dyld_init(); | 2253 | errors += sys_dyld_init (); |
2212 | #endif | 2254 | #endif |
2213 | errors += lt_dlloader_add (lt_dlloader_next (0), &presym, "dlpreload"); | 2255 | errors += lt_dlloader_add (lt_dlloader_next (0), &presym, "dlpreload"); |
2214 | 2256 | ||
2215 | if (presym_init (presym.dlloader_data)) | 2257 | if (presym_init (presym.dlloader_data)) |
2216 | { | 2258 | { |
2217 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (INIT_LOADER)); | 2259 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (INIT_LOADER)); |
2218 | ++errors; | 2260 | ++errors; |
2219 | } | 2261 | } |
2220 | else if (errors != 0) | 2262 | else if (errors != 0) |
2221 | { | 2263 | { |
2222 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (DLOPEN_NOT_SUPPORTED)); | 2264 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (DLOPEN_NOT_SUPPORTED)); |
2223 | ++errors; | 2265 | ++errors; |
2224 | } | 2266 | } |
2225 | } | 2267 | } |
2226 | 2268 | ||
2227 | LT_DLMUTEX_UNLOCK (); | 2269 | LT_DLMUTEX_UNLOCK (); |
@@ -2241,13 +2283,13 @@ lt_dlpreload (preloaded) | |||
2241 | } | 2283 | } |
2242 | else | 2284 | else |
2243 | { | 2285 | { |
2244 | presym_free_symlists(); | 2286 | presym_free_symlists (); |
2245 | 2287 | ||
2246 | LT_DLMUTEX_LOCK (); | 2288 | LT_DLMUTEX_LOCK (); |
2247 | if (default_preloaded_symbols) | 2289 | if (default_preloaded_symbols) |
2248 | { | 2290 | { |
2249 | errors = lt_dlpreload (default_preloaded_symbols); | 2291 | errors = lt_dlpreload (default_preloaded_symbols); |
2250 | } | 2292 | } |
2251 | LT_DLMUTEX_UNLOCK (); | 2293 | LT_DLMUTEX_UNLOCK (); |
2252 | } | 2294 | } |
2253 | 2295 | ||
@@ -2269,7 +2311,7 @@ lt_dlexit () | |||
2269 | { | 2311 | { |
2270 | /* shut down libltdl */ | 2312 | /* shut down libltdl */ |
2271 | lt_dlloader *loader; | 2313 | lt_dlloader *loader; |
2272 | int errors = 0; | 2314 | int errors = 0; |
2273 | 2315 | ||
2274 | LT_DLMUTEX_LOCK (); | 2316 | LT_DLMUTEX_LOCK (); |
2275 | loader = loaders; | 2317 | loader = loaders; |
@@ -2284,54 +2326,54 @@ lt_dlexit () | |||
2284 | /* shut down only at last call. */ | 2326 | /* shut down only at last call. */ |
2285 | if (--initialized == 0) | 2327 | if (--initialized == 0) |
2286 | { | 2328 | { |
2287 | int level; | 2329 | int level; |
2288 | 2330 | ||
2289 | while (handles && LT_DLIS_RESIDENT (handles)) | 2331 | while (handles && LT_DLIS_RESIDENT (handles)) |
2290 | { | 2332 | { |
2291 | handles = handles->next; | 2333 | handles = handles->next; |
2292 | } | 2334 | } |
2293 | 2335 | ||
2294 | /* close all modules */ | 2336 | /* close all modules */ |
2295 | for (level = 1; handles; ++level) | 2337 | for (level = 1; handles; ++level) |
2296 | { | 2338 | { |
2297 | lt_dlhandle cur = handles; | 2339 | lt_dlhandle cur = handles; |
2298 | int saw_nonresident = 0; | 2340 | int saw_nonresident = 0; |
2299 | 2341 | ||
2300 | while (cur) | 2342 | while (cur) |
2301 | { | 2343 | { |
2302 | lt_dlhandle tmp = cur; | 2344 | lt_dlhandle tmp = cur; |
2303 | cur = cur->next; | 2345 | cur = cur->next; |
2304 | if (!LT_DLIS_RESIDENT (tmp)) | 2346 | if (!LT_DLIS_RESIDENT (tmp)) |
2305 | saw_nonresident = 1; | 2347 | saw_nonresident = 1; |
2306 | if (!LT_DLIS_RESIDENT (tmp) && tmp->info.ref_count <= level) | 2348 | if (!LT_DLIS_RESIDENT (tmp) && tmp->info.ref_count <= level) |
2307 | { | 2349 | { |
2308 | if (lt_dlclose (tmp)) | 2350 | if (lt_dlclose (tmp)) |
2309 | { | 2351 | { |
2310 | ++errors; | 2352 | ++errors; |
2311 | } | 2353 | } |
2312 | } | 2354 | } |
2313 | } | 2355 | } |
2314 | /* done if only resident modules are left */ | 2356 | /* done if only resident modules are left */ |
2315 | if (!saw_nonresident) | 2357 | if (!saw_nonresident) |
2316 | break; | 2358 | break; |
2317 | } | 2359 | } |
2318 | 2360 | ||
2319 | /* close all loaders */ | 2361 | /* close all loaders */ |
2320 | while (loader) | 2362 | while (loader) |
2321 | { | 2363 | { |
2322 | lt_dlloader *next = loader->next; | 2364 | lt_dlloader *next = loader->next; |
2323 | lt_user_data data = loader->dlloader_data; | 2365 | lt_user_data data = loader->dlloader_data; |
2324 | if (loader->dlloader_exit && loader->dlloader_exit (data)) | 2366 | if (loader->dlloader_exit && loader->dlloader_exit (data)) |
2325 | { | 2367 | { |
2326 | ++errors; | 2368 | ++errors; |
2327 | } | 2369 | } |
2328 | 2370 | ||
2329 | LT_DLMEM_REASSIGN (loader, next); | 2371 | LT_DLMEM_REASSIGN (loader, next); |
2330 | } | 2372 | } |
2331 | loaders = 0; | 2373 | loaders = 0; |
2332 | } | 2374 | } |
2333 | 2375 | ||
2334 | done: | 2376 | done: |
2335 | LT_DLMUTEX_UNLOCK (); | 2377 | LT_DLMUTEX_UNLOCK (); |
2336 | return errors; | 2378 | return errors; |
2337 | } | 2379 | } |
@@ -2341,15 +2383,15 @@ tryall_dlopen (handle, filename) | |||
2341 | lt_dlhandle *handle; | 2383 | lt_dlhandle *handle; |
2342 | const char *filename; | 2384 | const char *filename; |
2343 | { | 2385 | { |
2344 | lt_dlhandle cur; | 2386 | lt_dlhandle cur; |
2345 | lt_dlloader *loader; | 2387 | lt_dlloader *loader; |
2346 | const char *saved_error; | 2388 | const char *saved_error; |
2347 | int errors = 0; | 2389 | int errors = 0; |
2348 | 2390 | ||
2349 | LT_DLMUTEX_GETERROR (saved_error); | 2391 | LT_DLMUTEX_GETERROR (saved_error); |
2350 | LT_DLMUTEX_LOCK (); | 2392 | LT_DLMUTEX_LOCK (); |
2351 | 2393 | ||
2352 | cur = handles; | 2394 | cur = handles; |
2353 | loader = loaders; | 2395 | loader = loaders; |
2354 | 2396 | ||
2355 | /* check whether the module was already opened */ | 2397 | /* check whether the module was already opened */ |
@@ -2357,15 +2399,15 @@ tryall_dlopen (handle, filename) | |||
2357 | { | 2399 | { |
2358 | /* try to dlopen the program itself? */ | 2400 | /* try to dlopen the program itself? */ |
2359 | if (!cur->info.filename && !filename) | 2401 | if (!cur->info.filename && !filename) |
2360 | { | 2402 | { |
2361 | break; | 2403 | break; |
2362 | } | 2404 | } |
2363 | 2405 | ||
2364 | if (cur->info.filename && filename | 2406 | if (cur->info.filename && filename |
2365 | && strcmp (cur->info.filename, filename) == 0) | 2407 | && strcmp (cur->info.filename, filename) == 0) |
2366 | { | 2408 | { |
2367 | break; | 2409 | break; |
2368 | } | 2410 | } |
2369 | 2411 | ||
2370 | cur = cur->next; | 2412 | cur = cur->next; |
2371 | } | 2413 | } |
@@ -2381,23 +2423,23 @@ tryall_dlopen (handle, filename) | |||
2381 | if (filename) | 2423 | if (filename) |
2382 | { | 2424 | { |
2383 | /* Comment out the check of file permissions using access. | 2425 | /* Comment out the check of file permissions using access. |
2384 | This call seems to always return -1 with error EACCES. | 2426 | This call seems to always return -1 with error EACCES. |
2385 | */ | 2427 | */ |
2386 | /* We need to catch missing file errors early so that | 2428 | /* We need to catch missing file errors early so that |
2387 | file_not_found() can detect what happened. | 2429 | file_not_found() can detect what happened. |
2388 | if (access (filename, R_OK) != 0) | 2430 | if (access (filename, R_OK) != 0) |
2389 | { | 2431 | { |
2390 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (FILE_NOT_FOUND)); | 2432 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (FILE_NOT_FOUND)); |
2391 | ++errors; | 2433 | ++errors; |
2392 | goto done; | 2434 | goto done; |
2393 | } */ | 2435 | } */ |
2394 | 2436 | ||
2395 | cur->info.filename = lt_estrdup (filename); | 2437 | cur->info.filename = lt_estrdup (filename); |
2396 | if (!cur->info.filename) | 2438 | if (!cur->info.filename) |
2397 | { | 2439 | { |
2398 | ++errors; | 2440 | ++errors; |
2399 | goto done; | 2441 | goto done; |
2400 | } | 2442 | } |
2401 | } | 2443 | } |
2402 | else | 2444 | else |
2403 | { | 2445 | { |
@@ -2411,9 +2453,9 @@ tryall_dlopen (handle, filename) | |||
2411 | cur->module = loader->module_open (data, filename); | 2453 | cur->module = loader->module_open (data, filename); |
2412 | 2454 | ||
2413 | if (cur->module != 0) | 2455 | if (cur->module != 0) |
2414 | { | 2456 | { |
2415 | break; | 2457 | break; |
2416 | } | 2458 | } |
2417 | loader = loader->next; | 2459 | loader = loader->next; |
2418 | } | 2460 | } |
2419 | 2461 | ||
@@ -2424,10 +2466,10 @@ tryall_dlopen (handle, filename) | |||
2424 | goto done; | 2466 | goto done; |
2425 | } | 2467 | } |
2426 | 2468 | ||
2427 | cur->loader = loader; | 2469 | cur->loader = loader; |
2428 | LT_DLMUTEX_SETERROR (saved_error); | 2470 | LT_DLMUTEX_SETERROR (saved_error); |
2429 | 2471 | ||
2430 | done: | 2472 | done: |
2431 | LT_DLMUTEX_UNLOCK (); | 2473 | LT_DLMUTEX_UNLOCK (); |
2432 | 2474 | ||
2433 | return errors; | 2475 | return errors; |
@@ -2440,10 +2482,10 @@ tryall_dlopen_module (handle, prefix, dirname, dlname) | |||
2440 | const char *dirname; | 2482 | const char *dirname; |
2441 | const char *dlname; | 2483 | const char *dlname; |
2442 | { | 2484 | { |
2443 | int error = 0; | 2485 | int error = 0; |
2444 | char *filename = 0; | 2486 | char *filename = 0; |
2445 | size_t filename_len = 0; | 2487 | size_t filename_len = 0; |
2446 | size_t dirname_len = LT_STRLEN (dirname); | 2488 | size_t dirname_len = LT_STRLEN (dirname); |
2447 | 2489 | ||
2448 | assert (handle); | 2490 | assert (handle); |
2449 | assert (dirname); | 2491 | assert (dirname); |
@@ -2455,13 +2497,13 @@ tryall_dlopen_module (handle, prefix, dirname, dlname) | |||
2455 | #endif | 2497 | #endif |
2456 | 2498 | ||
2457 | if (dirname_len > 0) | 2499 | if (dirname_len > 0) |
2458 | if (dirname[dirname_len -1] == '/') | 2500 | if (dirname[dirname_len - 1] == '/') |
2459 | --dirname_len; | 2501 | --dirname_len; |
2460 | filename_len = dirname_len + 1 + LT_STRLEN (dlname); | 2502 | filename_len = dirname_len + 1 + LT_STRLEN (dlname); |
2461 | 2503 | ||
2462 | /* Allocate memory, and combine DIRNAME and MODULENAME into it. | 2504 | /* Allocate memory, and combine DIRNAME and MODULENAME into it. |
2463 | The PREFIX (if any) is handled below. */ | 2505 | The PREFIX (if any) is handled below. */ |
2464 | filename = LT_EMALLOC (char, dirname_len + 1 + filename_len + 1); | 2506 | filename = LT_EMALLOC (char, dirname_len + 1 + filename_len + 1); |
2465 | if (!filename) | 2507 | if (!filename) |
2466 | return 1; | 2508 | return 1; |
2467 | 2509 | ||
@@ -2473,7 +2515,7 @@ tryall_dlopen_module (handle, prefix, dirname, dlname) | |||
2473 | if (prefix) | 2515 | if (prefix) |
2474 | { | 2516 | { |
2475 | error += tryall_dlopen_module (handle, | 2517 | error += tryall_dlopen_module (handle, |
2476 | (const char *) 0, prefix, filename); | 2518 | (const char *) 0, prefix, filename); |
2477 | } | 2519 | } |
2478 | else if (tryall_dlopen (handle, filename) != 0) | 2520 | else if (tryall_dlopen (handle, filename) != 0) |
2479 | { | 2521 | { |
@@ -2506,24 +2548,23 @@ find_module (handle, dir, libdir, dlname, old_name, installed) | |||
2506 | { | 2548 | { |
2507 | /* try to open the installed module */ | 2549 | /* try to open the installed module */ |
2508 | if (installed && libdir) | 2550 | if (installed && libdir) |
2509 | { | 2551 | { |
2510 | if (tryall_dlopen_module (handle, | 2552 | if (tryall_dlopen_module (handle, |
2511 | (const char *) 0, libdir, dlname) == 0) | 2553 | (const char *) 0, libdir, dlname) == 0) |
2512 | return 0; | 2554 | return 0; |
2513 | } | 2555 | } |
2514 | 2556 | ||
2515 | /* try to open the not-installed module */ | 2557 | /* try to open the not-installed module */ |
2516 | if (!installed) | 2558 | if (!installed) |
2517 | { | 2559 | { |
2518 | if (tryall_dlopen_module (handle, dir, objdir, dlname) == 0) | 2560 | if (tryall_dlopen_module (handle, dir, objdir, dlname) == 0) |
2519 | return 0; | 2561 | return 0; |
2520 | } | 2562 | } |
2521 | 2563 | ||
2522 | /* maybe it was moved to another directory */ | 2564 | /* maybe it was moved to another directory */ |
2523 | { | 2565 | { |
2524 | if (tryall_dlopen_module (handle, | 2566 | if (tryall_dlopen_module (handle, (const char *) 0, dir, dlname) == 0) |
2525 | (const char *) 0, dir, dlname) == 0) | 2567 | return 0; |
2526 | return 0; | ||
2527 | } | 2568 | } |
2528 | } | 2569 | } |
2529 | 2570 | ||
@@ -2541,7 +2582,7 @@ canonicalize_path (path, pcanonical) | |||
2541 | assert (path && *path); | 2582 | assert (path && *path); |
2542 | assert (pcanonical); | 2583 | assert (pcanonical); |
2543 | 2584 | ||
2544 | canonical = LT_EMALLOC (char, 1+ LT_STRLEN (path)); | 2585 | canonical = LT_EMALLOC (char, 1 + LT_STRLEN (path)); |
2545 | if (!canonical) | 2586 | if (!canonical) |
2546 | return 1; | 2587 | return 1; |
2547 | 2588 | ||
@@ -2550,38 +2591,38 @@ canonicalize_path (path, pcanonical) | |||
2550 | size_t src; | 2591 | size_t src; |
2551 | for (src = 0; path[src] != LT_EOS_CHAR; ++src) | 2592 | for (src = 0; path[src] != LT_EOS_CHAR; ++src) |
2552 | { | 2593 | { |
2553 | /* Path separators are not copied to the beginning or end of | 2594 | /* Path separators are not copied to the beginning or end of |
2554 | the destination, or if another separator would follow | 2595 | the destination, or if another separator would follow |
2555 | immediately. */ | 2596 | immediately. */ |
2556 | if (path[src] == LT_PATHSEP_CHAR) | 2597 | if (path[src] == LT_PATHSEP_CHAR) |
2557 | { | 2598 | { |
2558 | if ((dest == 0) | 2599 | if ((dest == 0) |
2559 | || (path[1+ src] == LT_PATHSEP_CHAR) | 2600 | || (path[1 + src] == LT_PATHSEP_CHAR) |
2560 | || (path[1+ src] == LT_EOS_CHAR)) | 2601 | || (path[1 + src] == LT_EOS_CHAR)) |
2561 | continue; | 2602 | continue; |
2562 | } | 2603 | } |
2563 | 2604 | ||
2564 | /* Anything other than a directory separator is copied verbatim. */ | 2605 | /* Anything other than a directory separator is copied verbatim. */ |
2565 | if ((path[src] != '/') | 2606 | if ((path[src] != '/') |
2566 | #ifdef LT_DIRSEP_CHAR | 2607 | #ifdef LT_DIRSEP_CHAR |
2567 | && (path[src] != LT_DIRSEP_CHAR) | 2608 | && (path[src] != LT_DIRSEP_CHAR) |
2568 | #endif | 2609 | #endif |
2569 | ) | 2610 | ) |
2570 | { | 2611 | { |
2571 | canonical[dest++] = path[src]; | 2612 | canonical[dest++] = path[src]; |
2572 | } | 2613 | } |
2573 | /* Directory separators are converted and copied only if they are | 2614 | /* Directory separators are converted and copied only if they are |
2574 | not at the end of a path -- i.e. before a path separator or | 2615 | not at the end of a path -- i.e. before a path separator or |
2575 | NULL terminator. */ | 2616 | NULL terminator. */ |
2576 | else if ((path[1+ src] != LT_PATHSEP_CHAR) | 2617 | else if ((path[1 + src] != LT_PATHSEP_CHAR) |
2577 | && (path[1+ src] != LT_EOS_CHAR) | 2618 | && (path[1 + src] != LT_EOS_CHAR) |
2578 | #ifdef LT_DIRSEP_CHAR | 2619 | #ifdef LT_DIRSEP_CHAR |
2579 | && (path[1+ src] != LT_DIRSEP_CHAR) | 2620 | && (path[1 + src] != LT_DIRSEP_CHAR) |
2580 | #endif | 2621 | #endif |
2581 | && (path[1+ src] != '/')) | 2622 | && (path[1 + src] != '/')) |
2582 | { | 2623 | { |
2583 | canonical[dest++] = '/'; | 2624 | canonical[dest++] = '/'; |
2584 | } | 2625 | } |
2585 | } | 2626 | } |
2586 | 2627 | ||
2587 | /* Add an end-of-string marker at the end. */ | 2628 | /* Add an end-of-string marker at the end. */ |
@@ -2609,14 +2650,14 @@ argzize_path (path, pargz, pargz_len) | |||
2609 | if ((error = argz_create_sep (path, LT_PATHSEP_CHAR, pargz, pargz_len))) | 2650 | if ((error = argz_create_sep (path, LT_PATHSEP_CHAR, pargz, pargz_len))) |
2610 | { | 2651 | { |
2611 | switch (error) | 2652 | switch (error) |
2612 | { | 2653 | { |
2613 | case ENOMEM: | 2654 | case ENOMEM: |
2614 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (NO_MEMORY)); | 2655 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (NO_MEMORY)); |
2615 | break; | 2656 | break; |
2616 | default: | 2657 | default: |
2617 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (UNKNOWN)); | 2658 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (UNKNOWN)); |
2618 | break; | 2659 | break; |
2619 | } | 2660 | } |
2620 | 2661 | ||
2621 | return 1; | 2662 | return 1; |
2622 | } | 2663 | } |
@@ -2636,13 +2677,13 @@ foreach_dirinpath (search_path, base_name, func, data1, data2) | |||
2636 | lt_ptr data1; | 2677 | lt_ptr data1; |
2637 | lt_ptr data2; | 2678 | lt_ptr data2; |
2638 | { | 2679 | { |
2639 | int result = 0; | 2680 | int result = 0; |
2640 | int filenamesize = 0; | 2681 | int filenamesize = 0; |
2641 | size_t lenbase = LT_STRLEN (base_name); | 2682 | size_t lenbase = LT_STRLEN (base_name); |
2642 | size_t argz_len = 0; | 2683 | size_t argz_len = 0; |
2643 | char *argz = 0; | 2684 | char *argz = 0; |
2644 | char *filename = 0; | 2685 | char *filename = 0; |
2645 | char *canonical = 0; | 2686 | char *canonical = 0; |
2646 | 2687 | ||
2647 | LT_DLMUTEX_LOCK (); | 2688 | LT_DLMUTEX_LOCK (); |
2648 | 2689 | ||
@@ -2662,35 +2703,35 @@ foreach_dirinpath (search_path, base_name, func, data1, data2) | |||
2662 | char *dir_name = 0; | 2703 | char *dir_name = 0; |
2663 | while ((dir_name = argz_next (argz, argz_len, dir_name))) | 2704 | while ((dir_name = argz_next (argz, argz_len, dir_name))) |
2664 | { | 2705 | { |
2665 | size_t lendir = LT_STRLEN (dir_name); | 2706 | size_t lendir = LT_STRLEN (dir_name); |
2666 | 2707 | ||
2667 | if (lendir +1 +lenbase >= filenamesize) | 2708 | if (lendir + 1 + lenbase >= filenamesize) |
2668 | { | 2709 | { |
2669 | LT_DLFREE (filename); | 2710 | LT_DLFREE (filename); |
2670 | filenamesize = lendir +1 +lenbase +1; /* "/d" + '/' + "f" + '\0' */ | 2711 | filenamesize = lendir + 1 + lenbase + 1; /* "/d" + '/' + "f" + '\0' */ |
2671 | filename = LT_EMALLOC (char, filenamesize); | 2712 | filename = LT_EMALLOC (char, filenamesize); |
2672 | if (!filename) | 2713 | if (!filename) |
2673 | goto cleanup; | 2714 | goto cleanup; |
2674 | } | 2715 | } |
2675 | 2716 | ||
2676 | assert (filenamesize > lendir); | 2717 | assert (filenamesize > lendir); |
2677 | strcpy (filename, dir_name); | 2718 | strcpy (filename, dir_name); |
2678 | 2719 | ||
2679 | if (base_name && *base_name) | 2720 | if (base_name && *base_name) |
2680 | { | 2721 | { |
2681 | if (filename[lendir -1] != '/') | 2722 | if (filename[lendir - 1] != '/') |
2682 | filename[lendir++] = '/'; | 2723 | filename[lendir++] = '/'; |
2683 | strcpy (filename +lendir, base_name); | 2724 | strcpy (filename + lendir, base_name); |
2684 | } | 2725 | } |
2685 | 2726 | ||
2686 | if ((result = (*func) (filename, data1, data2))) | 2727 | if ((result = (*func) (filename, data1, data2))) |
2687 | { | 2728 | { |
2688 | break; | 2729 | break; |
2689 | } | 2730 | } |
2690 | } | 2731 | } |
2691 | } | 2732 | } |
2692 | 2733 | ||
2693 | cleanup: | 2734 | cleanup: |
2694 | LT_DLFREE (argz); | 2735 | LT_DLFREE (argz); |
2695 | LT_DLFREE (canonical); | 2736 | LT_DLFREE (canonical); |
2696 | LT_DLFREE (filename); | 2737 | LT_DLFREE (filename); |
@@ -2709,9 +2750,9 @@ find_file_callback (filename, data1, data2) | |||
2709 | lt_ptr data1; | 2750 | lt_ptr data1; |
2710 | lt_ptr data2; | 2751 | lt_ptr data2; |
2711 | { | 2752 | { |
2712 | char **pdir = (char **) data1; | 2753 | char **pdir = (char **) data1; |
2713 | FILE **pfile = (FILE **) data2; | 2754 | FILE **pfile = (FILE **) data2; |
2714 | int is_done = 0; | 2755 | int is_done = 0; |
2715 | 2756 | ||
2716 | assert (filename && *filename); | 2757 | assert (filename && *filename); |
2717 | assert (pdir); | 2758 | assert (pdir); |
@@ -2722,10 +2763,10 @@ find_file_callback (filename, data1, data2) | |||
2722 | char *dirend = strrchr (filename, '/'); | 2763 | char *dirend = strrchr (filename, '/'); |
2723 | 2764 | ||
2724 | if (dirend > filename) | 2765 | if (dirend > filename) |
2725 | *dirend = LT_EOS_CHAR; | 2766 | *dirend = LT_EOS_CHAR; |
2726 | 2767 | ||
2727 | LT_DLFREE (*pdir); | 2768 | LT_DLFREE (*pdir); |
2728 | *pdir = lt_estrdup (filename); | 2769 | *pdir = lt_estrdup (filename); |
2729 | is_done = (*pdir == 0) ? -1 : 1; | 2770 | is_done = (*pdir == 0) ? -1 : 1; |
2730 | } | 2771 | } |
2731 | 2772 | ||
@@ -2751,8 +2792,8 @@ find_handle_callback (filename, data, ignored) | |||
2751 | lt_ptr data; | 2792 | lt_ptr data; |
2752 | lt_ptr ignored; | 2793 | lt_ptr ignored; |
2753 | { | 2794 | { |
2754 | lt_dlhandle *handle = (lt_dlhandle *) data; | 2795 | lt_dlhandle *handle = (lt_dlhandle *) data; |
2755 | int notfound = access (filename, R_OK); | 2796 | int notfound = access (filename, R_OK); |
2756 | 2797 | ||
2757 | /* Bail out if file cannot be read... */ | 2798 | /* Bail out if file cannot be read... */ |
2758 | if (notfound) | 2799 | if (notfound) |
@@ -2778,7 +2819,7 @@ find_handle (search_path, base_name, handle) | |||
2778 | return 0; | 2819 | return 0; |
2779 | 2820 | ||
2780 | if (!foreach_dirinpath (search_path, base_name, find_handle_callback, | 2821 | if (!foreach_dirinpath (search_path, base_name, find_handle_callback, |
2781 | handle, 0)) | 2822 | handle, 0)) |
2782 | return 0; | 2823 | return 0; |
2783 | 2824 | ||
2784 | return handle; | 2825 | return handle; |
@@ -2790,12 +2831,12 @@ load_deplibs (handle, deplibs) | |||
2790 | char *deplibs; | 2831 | char *deplibs; |
2791 | { | 2832 | { |
2792 | #if LTDL_DLOPEN_DEPLIBS | 2833 | #if LTDL_DLOPEN_DEPLIBS |
2793 | char *p, *save_search_path = 0; | 2834 | char *p, *save_search_path = 0; |
2794 | int depcount = 0; | 2835 | int depcount = 0; |
2795 | int i; | 2836 | int i; |
2796 | char **names = 0; | 2837 | char **names = 0; |
2797 | #endif | 2838 | #endif |
2798 | int errors = 0; | 2839 | int errors = 0; |
2799 | 2840 | ||
2800 | handle->depcount = 0; | 2841 | handle->depcount = 0; |
2801 | 2842 | ||
@@ -2811,7 +2852,7 @@ load_deplibs (handle, deplibs) | |||
2811 | { | 2852 | { |
2812 | save_search_path = lt_estrdup (user_search_path); | 2853 | save_search_path = lt_estrdup (user_search_path); |
2813 | if (!save_search_path) | 2854 | if (!save_search_path) |
2814 | goto cleanup; | 2855 | goto cleanup; |
2815 | } | 2856 | } |
2816 | 2857 | ||
2817 | /* extract search paths and count deplibs */ | 2858 | /* extract search paths and count deplibs */ |
@@ -2819,34 +2860,34 @@ load_deplibs (handle, deplibs) | |||
2819 | while (*p) | 2860 | while (*p) |
2820 | { | 2861 | { |
2821 | if (!isspace ((int) *p)) | 2862 | if (!isspace ((int) *p)) |
2822 | { | 2863 | { |
2823 | char *end = p+1; | 2864 | char *end = p + 1; |
2824 | while (*end && !isspace((int) *end)) | 2865 | while (*end && !isspace ((int) *end)) |
2825 | { | 2866 | { |
2826 | ++end; | 2867 | ++end; |
2827 | } | 2868 | } |
2828 | 2869 | ||
2829 | if (strncmp(p, "-L", 2) == 0 || strncmp(p, "-R", 2) == 0) | 2870 | if (strncmp (p, "-L", 2) == 0 || strncmp (p, "-R", 2) == 0) |
2830 | { | 2871 | { |
2831 | char save = *end; | 2872 | char save = *end; |
2832 | *end = 0; /* set a temporary string terminator */ | 2873 | *end = 0; /* set a temporary string terminator */ |
2833 | if (lt_dladdsearchdir(p+2)) | 2874 | if (lt_dladdsearchdir (p + 2)) |
2834 | { | 2875 | { |
2835 | goto cleanup; | 2876 | goto cleanup; |
2836 | } | 2877 | } |
2837 | *end = save; | 2878 | *end = save; |
2838 | } | 2879 | } |
2839 | else | 2880 | else |
2840 | { | 2881 | { |
2841 | ++depcount; | 2882 | ++depcount; |
2842 | } | 2883 | } |
2843 | 2884 | ||
2844 | p = end; | 2885 | p = end; |
2845 | } | 2886 | } |
2846 | else | 2887 | else |
2847 | { | 2888 | { |
2848 | ++p; | 2889 | ++p; |
2849 | } | 2890 | } |
2850 | } | 2891 | } |
2851 | 2892 | ||
2852 | /* restore the old search path */ | 2893 | /* restore the old search path */ |
@@ -2861,7 +2902,7 @@ load_deplibs (handle, deplibs) | |||
2861 | goto cleanup; | 2902 | goto cleanup; |
2862 | } | 2903 | } |
2863 | 2904 | ||
2864 | names = LT_EMALLOC (char *, depcount * sizeof (char*)); | 2905 | names = LT_EMALLOC (char *, depcount * sizeof (char *)); |
2865 | if (!names) | 2906 | if (!names) |
2866 | goto cleanup; | 2907 | goto cleanup; |
2867 | 2908 | ||
@@ -2871,40 +2912,40 @@ load_deplibs (handle, deplibs) | |||
2871 | while (*p) | 2912 | while (*p) |
2872 | { | 2913 | { |
2873 | if (isspace ((int) *p)) | 2914 | if (isspace ((int) *p)) |
2874 | { | 2915 | { |
2875 | ++p; | 2916 | ++p; |
2876 | } | 2917 | } |
2877 | else | 2918 | else |
2878 | { | 2919 | { |
2879 | char *end = p+1; | 2920 | char *end = p + 1; |
2880 | while (*end && !isspace ((int) *end)) | 2921 | while (*end && !isspace ((int) *end)) |
2881 | { | 2922 | { |
2882 | ++end; | 2923 | ++end; |
2883 | } | 2924 | } |
2884 | 2925 | ||
2885 | if (strncmp(p, "-L", 2) != 0 && strncmp(p, "-R", 2) != 0) | 2926 | if (strncmp (p, "-L", 2) != 0 && strncmp (p, "-R", 2) != 0) |
2886 | { | 2927 | { |
2887 | char *name; | 2928 | char *name; |
2888 | char save = *end; | 2929 | char save = *end; |
2889 | *end = 0; /* set a temporary string terminator */ | 2930 | *end = 0; /* set a temporary string terminator */ |
2890 | if (strncmp(p, "-l", 2) == 0) | 2931 | if (strncmp (p, "-l", 2) == 0) |
2891 | { | 2932 | { |
2892 | size_t name_len = 3+ /* "lib" */ LT_STRLEN (p + 2); | 2933 | size_t name_len = 3 + /* "lib" */ LT_STRLEN (p + 2); |
2893 | name = LT_EMALLOC (char, 1+ name_len); | 2934 | name = LT_EMALLOC (char, 1 + name_len); |
2894 | if (name) | 2935 | if (name) |
2895 | sprintf (name, "lib%s", p+2); | 2936 | sprintf (name, "lib%s", p + 2); |
2896 | } | 2937 | } |
2897 | else | 2938 | else |
2898 | name = lt_estrdup(p); | 2939 | name = lt_estrdup (p); |
2899 | 2940 | ||
2900 | if (!name) | 2941 | if (!name) |
2901 | goto cleanup_names; | 2942 | goto cleanup_names; |
2902 | 2943 | ||
2903 | names[depcount++] = name; | 2944 | names[depcount++] = name; |
2904 | *end = save; | 2945 | *end = save; |
2905 | } | 2946 | } |
2906 | p = end; | 2947 | p = end; |
2907 | } | 2948 | } |
2908 | } | 2949 | } |
2909 | 2950 | ||
2910 | /* load the deplibs (in reverse order) | 2951 | /* load the deplibs (in reverse order) |
@@ -2914,32 +2955,32 @@ load_deplibs (handle, deplibs) | |||
2914 | later on if the loaded module cannot resolve all of its symbols. */ | 2955 | later on if the loaded module cannot resolve all of its symbols. */ |
2915 | if (depcount) | 2956 | if (depcount) |
2916 | { | 2957 | { |
2917 | int j = 0; | 2958 | int j = 0; |
2918 | 2959 | ||
2919 | handle->deplibs = (lt_dlhandle*) LT_EMALLOC (lt_dlhandle *, depcount); | 2960 | handle->deplibs = (lt_dlhandle *) LT_EMALLOC (lt_dlhandle *, depcount); |
2920 | if (!handle->deplibs) | 2961 | if (!handle->deplibs) |
2921 | goto cleanup; | 2962 | goto cleanup; |
2922 | 2963 | ||
2923 | for (i = 0; i < depcount; ++i) | 2964 | for (i = 0; i < depcount; ++i) |
2924 | { | 2965 | { |
2925 | handle->deplibs[j] = lt_dlopenext(names[depcount-1-i]); | 2966 | handle->deplibs[j] = lt_dlopenext (names[depcount - 1 - i]); |
2926 | if (handle->deplibs[j]) | 2967 | if (handle->deplibs[j]) |
2927 | { | 2968 | { |
2928 | ++j; | 2969 | ++j; |
2929 | } | 2970 | } |
2930 | } | 2971 | } |
2931 | 2972 | ||
2932 | handle->depcount = j; /* Number of successfully loaded deplibs */ | 2973 | handle->depcount = j; /* Number of successfully loaded deplibs */ |
2933 | errors = 0; | 2974 | errors = 0; |
2934 | } | 2975 | } |
2935 | 2976 | ||
2936 | cleanup_names: | 2977 | cleanup_names: |
2937 | for (i = 0; i < depcount; ++i) | 2978 | for (i = 0; i < depcount; ++i) |
2938 | { | 2979 | { |
2939 | LT_DLFREE (names[i]); | 2980 | LT_DLFREE (names[i]); |
2940 | } | 2981 | } |
2941 | 2982 | ||
2942 | cleanup: | 2983 | cleanup: |
2943 | LT_DLFREE (names); | 2984 | LT_DLFREE (names); |
2944 | #endif | 2985 | #endif |
2945 | 2986 | ||
@@ -2956,12 +2997,12 @@ unload_deplibs (handle) | |||
2956 | if (handle->depcount) | 2997 | if (handle->depcount) |
2957 | { | 2998 | { |
2958 | for (i = 0; i < handle->depcount; ++i) | 2999 | for (i = 0; i < handle->depcount; ++i) |
2959 | { | 3000 | { |
2960 | if (!LT_DLIS_RESIDENT (handle->deplibs[i])) | 3001 | if (!LT_DLIS_RESIDENT (handle->deplibs[i])) |
2961 | { | 3002 | { |
2962 | errors += lt_dlclose (handle->deplibs[i]); | 3003 | errors += lt_dlclose (handle->deplibs[i]); |
2963 | } | 3004 | } |
2964 | } | 3005 | } |
2965 | } | 3006 | } |
2966 | 3007 | ||
2967 | return errors; | 3008 | return errors; |
@@ -2974,8 +3015,8 @@ trim (dest, str) | |||
2974 | { | 3015 | { |
2975 | /* remove the leading and trailing "'" from str | 3016 | /* remove the leading and trailing "'" from str |
2976 | and store the result in dest */ | 3017 | and store the result in dest */ |
2977 | const char *end = strrchr (str, '\''); | 3018 | const char *end = strrchr (str, '\''); |
2978 | size_t len = LT_STRLEN (str); | 3019 | size_t len = LT_STRLEN (str); |
2979 | char *tmp; | 3020 | char *tmp; |
2980 | 3021 | ||
2981 | LT_DLFREE (*dest); | 3022 | LT_DLFREE (*dest); |
@@ -2984,10 +3025,10 @@ trim (dest, str) | |||
2984 | { | 3025 | { |
2985 | tmp = LT_EMALLOC (char, end - str); | 3026 | tmp = LT_EMALLOC (char, end - str); |
2986 | if (!tmp) | 3027 | if (!tmp) |
2987 | return 1; | 3028 | return 1; |
2988 | 3029 | ||
2989 | strncpy(tmp, &str[1], (end - str) - 1); | 3030 | strncpy (tmp, &str[1], (end - str) - 1); |
2990 | tmp[len-3] = LT_EOS_CHAR; | 3031 | tmp[len - 3] = LT_EOS_CHAR; |
2991 | *dest = tmp; | 3032 | *dest = tmp; |
2992 | } | 3033 | } |
2993 | else | 3034 | else |
@@ -3018,14 +3059,14 @@ try_dlopen (phandle, filename) | |||
3018 | lt_dlhandle *phandle; | 3059 | lt_dlhandle *phandle; |
3019 | const char *filename; | 3060 | const char *filename; |
3020 | { | 3061 | { |
3021 | const char * ext = 0; | 3062 | const char *ext = 0; |
3022 | const char * saved_error = 0; | 3063 | const char *saved_error = 0; |
3023 | char * canonical = 0; | 3064 | char *canonical = 0; |
3024 | char * base_name = 0; | 3065 | char *base_name = 0; |
3025 | char * dir = 0; | 3066 | char *dir = 0; |
3026 | char * name = 0; | 3067 | char *name = 0; |
3027 | int errors = 0; | 3068 | int errors = 0; |
3028 | lt_dlhandle newhandle; | 3069 | lt_dlhandle newhandle; |
3029 | 3070 | ||
3030 | assert (phandle); | 3071 | assert (phandle); |
3031 | assert (*phandle == 0); | 3072 | assert (*phandle == 0); |
@@ -3037,19 +3078,19 @@ try_dlopen (phandle, filename) | |||
3037 | { | 3078 | { |
3038 | *phandle = (lt_dlhandle) LT_EMALLOC (struct lt_dlhandle_struct, 1); | 3079 | *phandle = (lt_dlhandle) LT_EMALLOC (struct lt_dlhandle_struct, 1); |
3039 | if (*phandle == 0) | 3080 | if (*phandle == 0) |
3040 | return 1; | 3081 | return 1; |
3041 | 3082 | ||
3042 | memset (*phandle, 0, sizeof(struct lt_dlhandle_struct)); | 3083 | memset (*phandle, 0, sizeof (struct lt_dlhandle_struct)); |
3043 | newhandle = *phandle; | 3084 | newhandle = *phandle; |
3044 | 3085 | ||
3045 | /* lt_dlclose()ing yourself is very bad! Disallow it. */ | 3086 | /* lt_dlclose()ing yourself is very bad! Disallow it. */ |
3046 | LT_DLSET_FLAG (*phandle, LT_DLRESIDENT_FLAG); | 3087 | LT_DLSET_FLAG (*phandle, LT_DLRESIDENT_FLAG); |
3047 | 3088 | ||
3048 | if (tryall_dlopen (&newhandle, 0) != 0) | 3089 | if (tryall_dlopen (&newhandle, 0) != 0) |
3049 | { | 3090 | { |
3050 | LT_DLFREE (*phandle); | 3091 | LT_DLFREE (*phandle); |
3051 | return 1; | 3092 | return 1; |
3052 | } | 3093 | } |
3053 | 3094 | ||
3054 | goto register_handle; | 3095 | goto register_handle; |
3055 | } | 3096 | } |
@@ -3069,14 +3110,14 @@ try_dlopen (phandle, filename) | |||
3069 | base_name = strrchr (canonical, '/'); | 3110 | base_name = strrchr (canonical, '/'); |
3070 | if (base_name) | 3111 | if (base_name) |
3071 | { | 3112 | { |
3072 | size_t dirlen = (1+ base_name) - canonical; | 3113 | size_t dirlen = (1 + base_name) - canonical; |
3073 | 3114 | ||
3074 | dir = LT_EMALLOC (char, 1+ dirlen); | 3115 | dir = LT_EMALLOC (char, 1 + dirlen); |
3075 | if (!dir) | 3116 | if (!dir) |
3076 | { | 3117 | { |
3077 | ++errors; | 3118 | ++errors; |
3078 | goto cleanup; | 3119 | goto cleanup; |
3079 | } | 3120 | } |
3080 | 3121 | ||
3081 | strncpy (dir, canonical, dirlen); | 3122 | strncpy (dir, canonical, dirlen); |
3082 | dir[dirlen] = LT_EOS_CHAR; | 3123 | dir[dirlen] = LT_EOS_CHAR; |
@@ -3093,41 +3134,41 @@ try_dlopen (phandle, filename) | |||
3093 | if (ext && strcmp (ext, archive_ext) == 0) | 3134 | if (ext && strcmp (ext, archive_ext) == 0) |
3094 | { | 3135 | { |
3095 | /* this seems to be a libtool module */ | 3136 | /* this seems to be a libtool module */ |
3096 | FILE * file = 0; | 3137 | FILE *file = 0; |
3097 | char * dlname = 0; | 3138 | char *dlname = 0; |
3098 | char * old_name = 0; | 3139 | char *old_name = 0; |
3099 | char * libdir = 0; | 3140 | char *libdir = 0; |
3100 | char * deplibs = 0; | 3141 | char *deplibs = 0; |
3101 | char * line = 0; | 3142 | char *line = 0; |
3102 | size_t line_len; | 3143 | size_t line_len; |
3103 | 3144 | ||
3104 | /* if we can't find the installed flag, it is probably an | 3145 | /* if we can't find the installed flag, it is probably an |
3105 | installed libtool archive, produced with an old version | 3146 | installed libtool archive, produced with an old version |
3106 | of libtool */ | 3147 | of libtool */ |
3107 | int installed = 1; | 3148 | int installed = 1; |
3108 | 3149 | ||
3109 | /* extract the module name from the file name */ | 3150 | /* extract the module name from the file name */ |
3110 | name = LT_EMALLOC (char, ext - base_name + 1); | 3151 | name = LT_EMALLOC (char, ext - base_name + 1); |
3111 | if (!name) | 3152 | if (!name) |
3112 | { | 3153 | { |
3113 | ++errors; | 3154 | ++errors; |
3114 | goto cleanup; | 3155 | goto cleanup; |
3115 | } | 3156 | } |
3116 | 3157 | ||
3117 | /* canonicalize the module name */ | 3158 | /* canonicalize the module name */ |
3118 | { | 3159 | { |
3119 | size_t i; | 3160 | size_t i; |
3120 | for (i = 0; i < ext - base_name; ++i) | 3161 | for (i = 0; i < ext - base_name; ++i) |
3121 | { | 3162 | { |
3122 | if (isalnum ((int)(base_name[i]))) | 3163 | if (isalnum ((int) (base_name[i]))) |
3123 | { | 3164 | { |
3124 | name[i] = base_name[i]; | 3165 | name[i] = base_name[i]; |
3125 | } | 3166 | } |
3126 | else | 3167 | else |
3127 | { | 3168 | { |
3128 | name[i] = '_'; | 3169 | name[i] = '_'; |
3129 | } | 3170 | } |
3130 | } | 3171 | } |
3131 | name[ext - base_name] = LT_EOS_CHAR; | 3172 | name[ext - base_name] = LT_EOS_CHAR; |
3132 | } | 3173 | } |
3133 | 3174 | ||
@@ -3136,146 +3177,145 @@ try_dlopen (phandle, filename) | |||
3136 | prescribed paths. Otherwise (or in any case if the module was not | 3177 | prescribed paths. Otherwise (or in any case if the module was not |
3137 | yet found) try opening just the module name as passed. */ | 3178 | yet found) try opening just the module name as passed. */ |
3138 | if (!dir) | 3179 | if (!dir) |
3139 | { | 3180 | { |
3140 | const char *search_path; | 3181 | const char *search_path; |
3141 | 3182 | ||
3142 | LT_DLMUTEX_LOCK (); | 3183 | LT_DLMUTEX_LOCK (); |
3143 | search_path = user_search_path; | 3184 | search_path = user_search_path; |
3144 | if (search_path) | 3185 | if (search_path) |
3145 | file = find_file (user_search_path, base_name, &dir); | 3186 | file = find_file (user_search_path, base_name, &dir); |
3146 | LT_DLMUTEX_UNLOCK (); | 3187 | LT_DLMUTEX_UNLOCK (); |
3147 | 3188 | ||
3148 | if (!file) | 3189 | if (!file) |
3149 | { | 3190 | { |
3150 | search_path = getenv (LTDL_SEARCHPATH_VAR); | 3191 | search_path = getenv (LTDL_SEARCHPATH_VAR); |
3151 | if (search_path) | 3192 | if (search_path) |
3152 | file = find_file (search_path, base_name, &dir); | 3193 | file = find_file (search_path, base_name, &dir); |
3153 | } | 3194 | } |
3154 | 3195 | ||
3155 | #ifdef LTDL_SHLIBPATH_VAR | 3196 | #ifdef LTDL_SHLIBPATH_VAR |
3156 | if (!file) | 3197 | if (!file) |
3157 | { | 3198 | { |
3158 | search_path = getenv (LTDL_SHLIBPATH_VAR); | 3199 | search_path = getenv (LTDL_SHLIBPATH_VAR); |
3159 | if (search_path) | 3200 | if (search_path) |
3160 | file = find_file (search_path, base_name, &dir); | 3201 | file = find_file (search_path, base_name, &dir); |
3161 | } | 3202 | } |
3162 | #endif | 3203 | #endif |
3163 | #ifdef LTDL_SYSSEARCHPATH | 3204 | #ifdef LTDL_SYSSEARCHPATH |
3164 | if (!file && sys_search_path) | 3205 | if (!file && sys_search_path) |
3165 | { | 3206 | { |
3166 | file = find_file (sys_search_path, base_name, &dir); | 3207 | file = find_file (sys_search_path, base_name, &dir); |
3167 | } | 3208 | } |
3168 | #endif | 3209 | #endif |
3169 | } | 3210 | } |
3170 | if (!file) | 3211 | if (!file) |
3171 | { | 3212 | { |
3172 | file = fopen (filename, LT_READTEXT_MODE); | 3213 | file = fopen (filename, LT_READTEXT_MODE); |
3173 | } | 3214 | } |
3174 | 3215 | ||
3175 | /* If we didn't find the file by now, it really isn't there. Set | 3216 | /* If we didn't find the file by now, it really isn't there. Set |
3176 | the status flag, and bail out. */ | 3217 | the status flag, and bail out. */ |
3177 | if (!file) | 3218 | if (!file) |
3178 | { | 3219 | { |
3179 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (FILE_NOT_FOUND)); | 3220 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (FILE_NOT_FOUND)); |
3180 | ++errors; | 3221 | ++errors; |
3181 | goto cleanup; | 3222 | goto cleanup; |
3182 | } | 3223 | } |
3183 | 3224 | ||
3184 | line_len = LT_FILENAME_MAX; | 3225 | line_len = LT_FILENAME_MAX; |
3185 | line = LT_EMALLOC (char, line_len); | 3226 | line = LT_EMALLOC (char, line_len); |
3186 | if (!line) | 3227 | if (!line) |
3187 | { | 3228 | { |
3188 | fclose (file); | 3229 | fclose (file); |
3189 | ++errors; | 3230 | ++errors; |
3190 | goto cleanup; | 3231 | goto cleanup; |
3191 | } | 3232 | } |
3192 | 3233 | ||
3193 | /* read the .la file */ | 3234 | /* read the .la file */ |
3194 | while (!feof (file)) | 3235 | while (!feof (file)) |
3195 | { | 3236 | { |
3196 | if (!fgets (line, (int) line_len, file)) | 3237 | if (!fgets (line, (int) line_len, file)) |
3197 | { | 3238 | { |
3198 | break; | 3239 | break; |
3199 | } | 3240 | } |
3200 | 3241 | ||
3201 | /* Handle the case where we occasionally need to read a line | 3242 | /* Handle the case where we occasionally need to read a line |
3202 | that is longer than the initial buffer size. */ | 3243 | that is longer than the initial buffer size. */ |
3203 | while ((line[LT_STRLEN(line) -1] != '\n') && (!feof (file))) | 3244 | while ((line[LT_STRLEN (line) - 1] != '\n') && (!feof (file))) |
3204 | { | 3245 | { |
3205 | line = LT_DLREALLOC (char, line, line_len *2); | 3246 | line = LT_DLREALLOC (char, line, line_len * 2); |
3206 | if (!fgets (&line[line_len -1], (int) line_len +1, file)) | 3247 | if (!fgets (&line[line_len - 1], (int) line_len + 1, file)) |
3207 | { | 3248 | { |
3208 | break; | 3249 | break; |
3209 | } | 3250 | } |
3210 | line_len *= 2; | 3251 | line_len *= 2; |
3211 | } | 3252 | } |
3212 | 3253 | ||
3213 | if (line[0] == '\n' || line[0] == '#') | 3254 | if (line[0] == '\n' || line[0] == '#') |
3214 | { | 3255 | { |
3215 | continue; | 3256 | continue; |
3216 | } | 3257 | } |
3217 | 3258 | ||
3218 | #undef STR_DLNAME | 3259 | #undef STR_DLNAME |
3219 | #define STR_DLNAME "dlname=" | 3260 | #define STR_DLNAME "dlname=" |
3220 | if (strncmp (line, STR_DLNAME, sizeof (STR_DLNAME) - 1) == 0) | 3261 | if (strncmp (line, STR_DLNAME, sizeof (STR_DLNAME) - 1) == 0) |
3221 | { | 3262 | { |
3222 | errors += trim (&dlname, &line[sizeof (STR_DLNAME) - 1]); | 3263 | errors += trim (&dlname, &line[sizeof (STR_DLNAME) - 1]); |
3223 | } | 3264 | } |
3224 | 3265 | ||
3225 | #undef STR_OLD_LIBRARY | 3266 | #undef STR_OLD_LIBRARY |
3226 | #define STR_OLD_LIBRARY "old_library=" | 3267 | #define STR_OLD_LIBRARY "old_library=" |
3227 | else if (strncmp (line, STR_OLD_LIBRARY, | 3268 | else if (strncmp (line, STR_OLD_LIBRARY, |
3228 | sizeof (STR_OLD_LIBRARY) - 1) == 0) | 3269 | sizeof (STR_OLD_LIBRARY) - 1) == 0) |
3229 | { | 3270 | { |
3230 | errors += trim (&old_name, &line[sizeof (STR_OLD_LIBRARY) - 1]); | 3271 | errors += trim (&old_name, &line[sizeof (STR_OLD_LIBRARY) - 1]); |
3231 | } | 3272 | } |
3232 | #undef STR_LIBDIR | 3273 | #undef STR_LIBDIR |
3233 | #define STR_LIBDIR "libdir=" | 3274 | #define STR_LIBDIR "libdir=" |
3234 | else if (strncmp (line, STR_LIBDIR, sizeof (STR_LIBDIR) - 1) == 0) | 3275 | else if (strncmp (line, STR_LIBDIR, sizeof (STR_LIBDIR) - 1) == 0) |
3235 | { | 3276 | { |
3236 | errors += trim (&libdir, &line[sizeof(STR_LIBDIR) - 1]); | 3277 | errors += trim (&libdir, &line[sizeof (STR_LIBDIR) - 1]); |
3237 | } | 3278 | } |
3238 | 3279 | ||
3239 | #undef STR_DL_DEPLIBS | 3280 | #undef STR_DL_DEPLIBS |
3240 | #define STR_DL_DEPLIBS "dependency_libs=" | 3281 | #define STR_DL_DEPLIBS "dependency_libs=" |
3241 | else if (strncmp (line, STR_DL_DEPLIBS, | 3282 | else if (strncmp (line, STR_DL_DEPLIBS, |
3242 | sizeof (STR_DL_DEPLIBS) - 1) == 0) | 3283 | sizeof (STR_DL_DEPLIBS) - 1) == 0) |
3243 | { | 3284 | { |
3244 | errors += trim (&deplibs, &line[sizeof (STR_DL_DEPLIBS) - 1]); | 3285 | errors += trim (&deplibs, &line[sizeof (STR_DL_DEPLIBS) - 1]); |
3245 | } | 3286 | } |
3246 | else if (strcmp (line, "installed=yes\n") == 0) | 3287 | else if (strcmp (line, "installed=yes\n") == 0) |
3247 | { | 3288 | { |
3248 | installed = 1; | 3289 | installed = 1; |
3249 | } | 3290 | } |
3250 | else if (strcmp (line, "installed=no\n") == 0) | 3291 | else if (strcmp (line, "installed=no\n") == 0) |
3251 | { | 3292 | { |
3252 | installed = 0; | 3293 | installed = 0; |
3253 | } | 3294 | } |
3254 | 3295 | ||
3255 | #undef STR_LIBRARY_NAMES | 3296 | #undef STR_LIBRARY_NAMES |
3256 | #define STR_LIBRARY_NAMES "library_names=" | 3297 | #define STR_LIBRARY_NAMES "library_names=" |
3257 | else if (! dlname && strncmp (line, STR_LIBRARY_NAMES, | 3298 | else if (!dlname && strncmp (line, STR_LIBRARY_NAMES, |
3258 | sizeof (STR_LIBRARY_NAMES) - 1) == 0) | 3299 | sizeof (STR_LIBRARY_NAMES) - 1) == 0) |
3259 | { | 3300 | { |
3260 | char *last_libname; | 3301 | char *last_libname; |
3261 | errors += trim (&dlname, &line[sizeof (STR_LIBRARY_NAMES) - 1]); | 3302 | errors += trim (&dlname, &line[sizeof (STR_LIBRARY_NAMES) - 1]); |
3262 | if (!errors | 3303 | if (!errors |
3263 | && dlname | 3304 | && dlname && (last_libname = strrchr (dlname, ' ')) != 0) |
3264 | && (last_libname = strrchr (dlname, ' ')) != 0) | 3305 | { |
3265 | { | 3306 | last_libname = lt_estrdup (last_libname + 1); |
3266 | last_libname = lt_estrdup (last_libname + 1); | 3307 | if (!last_libname) |
3267 | if (!last_libname) | 3308 | { |
3268 | { | 3309 | ++errors; |
3269 | ++errors; | 3310 | goto cleanup; |
3270 | goto cleanup; | 3311 | } |
3271 | } | 3312 | LT_DLMEM_REASSIGN (dlname, last_libname); |
3272 | LT_DLMEM_REASSIGN (dlname, last_libname); | 3313 | } |
3273 | } | 3314 | } |
3274 | } | 3315 | |
3275 | 3316 | if (errors) | |
3276 | if (errors) | 3317 | break; |
3277 | break; | 3318 | } |
3278 | } | ||
3279 | 3319 | ||
3280 | fclose (file); | 3320 | fclose (file); |
3281 | LT_DLFREE (line); | 3321 | LT_DLFREE (line); |
@@ -3283,105 +3323,106 @@ try_dlopen (phandle, filename) | |||
3283 | /* allocate the handle */ | 3323 | /* allocate the handle */ |
3284 | *phandle = (lt_dlhandle) LT_EMALLOC (struct lt_dlhandle_struct, 1); | 3324 | *phandle = (lt_dlhandle) LT_EMALLOC (struct lt_dlhandle_struct, 1); |
3285 | if (*phandle == 0) | 3325 | if (*phandle == 0) |
3286 | ++errors; | 3326 | ++errors; |
3287 | 3327 | ||
3288 | if (errors) | 3328 | if (errors) |
3289 | { | 3329 | { |
3290 | free_vars (dlname, old_name, libdir, deplibs); | 3330 | free_vars (dlname, old_name, libdir, deplibs); |
3291 | LT_DLFREE (*phandle); | 3331 | LT_DLFREE (*phandle); |
3292 | goto cleanup; | 3332 | goto cleanup; |
3293 | } | 3333 | } |
3294 | 3334 | ||
3295 | assert (*phandle); | 3335 | assert (*phandle); |
3296 | 3336 | ||
3297 | memset (*phandle, 0, sizeof(struct lt_dlhandle_struct)); | 3337 | memset (*phandle, 0, sizeof (struct lt_dlhandle_struct)); |
3298 | if (load_deplibs (*phandle, deplibs) == 0) | 3338 | if (load_deplibs (*phandle, deplibs) == 0) |
3299 | { | 3339 | { |
3300 | newhandle = *phandle; | 3340 | newhandle = *phandle; |
3301 | /* find_module may replace newhandle */ | 3341 | /* find_module may replace newhandle */ |
3302 | if (find_module (&newhandle, dir, libdir, dlname, old_name, installed)) | 3342 | if (find_module |
3303 | { | 3343 | (&newhandle, dir, libdir, dlname, old_name, installed)) |
3304 | unload_deplibs (*phandle); | 3344 | { |
3305 | ++errors; | 3345 | unload_deplibs (*phandle); |
3306 | } | 3346 | ++errors; |
3307 | } | 3347 | } |
3348 | } | ||
3308 | else | 3349 | else |
3309 | { | 3350 | { |
3310 | ++errors; | 3351 | ++errors; |
3311 | } | 3352 | } |
3312 | 3353 | ||
3313 | free_vars (dlname, old_name, libdir, deplibs); | 3354 | free_vars (dlname, old_name, libdir, deplibs); |
3314 | if (errors) | 3355 | if (errors) |
3315 | { | 3356 | { |
3316 | LT_DLFREE (*phandle); | 3357 | LT_DLFREE (*phandle); |
3317 | goto cleanup; | 3358 | goto cleanup; |
3318 | } | 3359 | } |
3319 | 3360 | ||
3320 | if (*phandle != newhandle) | 3361 | if (*phandle != newhandle) |
3321 | { | 3362 | { |
3322 | unload_deplibs (*phandle); | 3363 | unload_deplibs (*phandle); |
3323 | } | 3364 | } |
3324 | } | 3365 | } |
3325 | else | 3366 | else |
3326 | { | 3367 | { |
3327 | /* not a libtool module */ | 3368 | /* not a libtool module */ |
3328 | *phandle = (lt_dlhandle) LT_EMALLOC (struct lt_dlhandle_struct, 1); | 3369 | *phandle = (lt_dlhandle) LT_EMALLOC (struct lt_dlhandle_struct, 1); |
3329 | if (*phandle == 0) | 3370 | if (*phandle == 0) |
3330 | { | 3371 | { |
3331 | ++errors; | 3372 | ++errors; |
3332 | goto cleanup; | 3373 | goto cleanup; |
3333 | } | 3374 | } |
3334 | 3375 | ||
3335 | memset (*phandle, 0, sizeof (struct lt_dlhandle_struct)); | 3376 | memset (*phandle, 0, sizeof (struct lt_dlhandle_struct)); |
3336 | newhandle = *phandle; | 3377 | newhandle = *phandle; |
3337 | 3378 | ||
3338 | /* If the module has no directory name component, try to find it | 3379 | /* If the module has no directory name component, try to find it |
3339 | first in user_search_path and then other prescribed paths. | 3380 | first in user_search_path and then other prescribed paths. |
3340 | Otherwise (or in any case if the module was not yet found) try | 3381 | Otherwise (or in any case if the module was not yet found) try |
3341 | opening just the module name as passed. */ | 3382 | opening just the module name as passed. */ |
3342 | if ((dir || (!find_handle (user_search_path, base_name, &newhandle) | 3383 | if ((dir || (!find_handle (user_search_path, base_name, &newhandle) |
3343 | && !find_handle (getenv (LTDL_SEARCHPATH_VAR), base_name, | 3384 | && !find_handle (getenv (LTDL_SEARCHPATH_VAR), base_name, |
3344 | &newhandle) | 3385 | &newhandle) |
3345 | #ifdef LTDL_SHLIBPATH_VAR | 3386 | #ifdef LTDL_SHLIBPATH_VAR |
3346 | && !find_handle (getenv (LTDL_SHLIBPATH_VAR), base_name, | 3387 | && !find_handle (getenv (LTDL_SHLIBPATH_VAR), base_name, |
3347 | &newhandle) | 3388 | &newhandle) |
3348 | #endif | 3389 | #endif |
3349 | #ifdef LTDL_SYSSEARCHPATH | 3390 | #ifdef LTDL_SYSSEARCHPATH |
3350 | && !find_handle (sys_search_path, base_name, &newhandle) | 3391 | && !find_handle (sys_search_path, base_name, &newhandle) |
3351 | #endif | 3392 | #endif |
3352 | ))) | 3393 | ))) |
3353 | { | 3394 | { |
3354 | if (tryall_dlopen (&newhandle, filename) != 0) | 3395 | if (tryall_dlopen (&newhandle, filename) != 0) |
3355 | { | 3396 | { |
3356 | newhandle = NULL; | 3397 | newhandle = NULL; |
3357 | } | 3398 | } |
3358 | } | 3399 | } |
3359 | 3400 | ||
3360 | if (!newhandle) | 3401 | if (!newhandle) |
3361 | { | 3402 | { |
3362 | LT_DLFREE (*phandle); | 3403 | LT_DLFREE (*phandle); |
3363 | ++errors; | 3404 | ++errors; |
3364 | goto cleanup; | 3405 | goto cleanup; |
3365 | } | 3406 | } |
3366 | } | 3407 | } |
3367 | 3408 | ||
3368 | register_handle: | 3409 | register_handle: |
3369 | LT_DLMEM_REASSIGN (*phandle, newhandle); | 3410 | LT_DLMEM_REASSIGN (*phandle, newhandle); |
3370 | 3411 | ||
3371 | if ((*phandle)->info.ref_count == 0) | 3412 | if ((*phandle)->info.ref_count == 0) |
3372 | { | 3413 | { |
3373 | (*phandle)->info.ref_count = 1; | 3414 | (*phandle)->info.ref_count = 1; |
3374 | LT_DLMEM_REASSIGN ((*phandle)->info.name, name); | 3415 | LT_DLMEM_REASSIGN ((*phandle)->info.name, name); |
3375 | 3416 | ||
3376 | LT_DLMUTEX_LOCK (); | 3417 | LT_DLMUTEX_LOCK (); |
3377 | (*phandle)->next = handles; | 3418 | (*phandle)->next = handles; |
3378 | handles = *phandle; | 3419 | handles = *phandle; |
3379 | LT_DLMUTEX_UNLOCK (); | 3420 | LT_DLMUTEX_UNLOCK (); |
3380 | } | 3421 | } |
3381 | 3422 | ||
3382 | LT_DLMUTEX_SETERROR (saved_error); | 3423 | LT_DLMUTEX_SETERROR (saved_error); |
3383 | 3424 | ||
3384 | cleanup: | 3425 | cleanup: |
3385 | LT_DLFREE (dir); | 3426 | LT_DLFREE (dir); |
3386 | LT_DLFREE (name); | 3427 | LT_DLFREE (name); |
3387 | LT_DLFREE (canonical); | 3428 | LT_DLFREE (canonical); |
@@ -3425,11 +3466,11 @@ lt_dlhandle | |||
3425 | lt_dlopenext (filename) | 3466 | lt_dlopenext (filename) |
3426 | const char *filename; | 3467 | const char *filename; |
3427 | { | 3468 | { |
3428 | lt_dlhandle handle = 0; | 3469 | lt_dlhandle handle = 0; |
3429 | char * tmp = 0; | 3470 | char *tmp = 0; |
3430 | char * ext = 0; | 3471 | char *ext = 0; |
3431 | size_t len; | 3472 | size_t len; |
3432 | int errors = 0; | 3473 | int errors = 0; |
3433 | 3474 | ||
3434 | if (!filename) | 3475 | if (!filename) |
3435 | { | 3476 | { |
@@ -3445,7 +3486,7 @@ lt_dlopenext (filename) | |||
3445 | to try appending additional extensions. */ | 3486 | to try appending additional extensions. */ |
3446 | if (ext && ((strcmp (ext, archive_ext) == 0) | 3487 | if (ext && ((strcmp (ext, archive_ext) == 0) |
3447 | #ifdef LTDL_SHLIB_EXT | 3488 | #ifdef LTDL_SHLIB_EXT |
3448 | || (strcmp (ext, shlib_ext) == 0) | 3489 | || (strcmp (ext, shlib_ext) == 0) |
3449 | #endif | 3490 | #endif |
3450 | )) | 3491 | )) |
3451 | { | 3492 | { |
@@ -3479,7 +3520,7 @@ lt_dlopenext (filename) | |||
3479 | LT_DLFREE (tmp); | 3520 | LT_DLFREE (tmp); |
3480 | tmp = LT_EMALLOC (char, len + LT_STRLEN (shlib_ext) + 1); | 3521 | tmp = LT_EMALLOC (char, len + LT_STRLEN (shlib_ext) + 1); |
3481 | if (!tmp) | 3522 | if (!tmp) |
3482 | return 0; | 3523 | return 0; |
3483 | 3524 | ||
3484 | strcpy (tmp, filename); | 3525 | strcpy (tmp, filename); |
3485 | } | 3526 | } |
@@ -3488,7 +3529,7 @@ lt_dlopenext (filename) | |||
3488 | tmp[len] = LT_EOS_CHAR; | 3529 | tmp[len] = LT_EOS_CHAR; |
3489 | } | 3530 | } |
3490 | 3531 | ||
3491 | strcat(tmp, shlib_ext); | 3532 | strcat (tmp, shlib_ext); |
3492 | errors = try_dlopen (&handle, tmp); | 3533 | errors = try_dlopen (&handle, tmp); |
3493 | 3534 | ||
3494 | /* As before, if the file was found but loading failed, return now | 3535 | /* As before, if the file was found but loading failed, return now |
@@ -3520,14 +3561,14 @@ lt_argz_insert (pargz, pargz_len, before, entry) | |||
3520 | if ((error = argz_insert (pargz, pargz_len, before, entry))) | 3561 | if ((error = argz_insert (pargz, pargz_len, before, entry))) |
3521 | { | 3562 | { |
3522 | switch (error) | 3563 | switch (error) |
3523 | { | 3564 | { |
3524 | case ENOMEM: | 3565 | case ENOMEM: |
3525 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (NO_MEMORY)); | 3566 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (NO_MEMORY)); |
3526 | break; | 3567 | break; |
3527 | default: | 3568 | default: |
3528 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (UNKNOWN)); | 3569 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (UNKNOWN)); |
3529 | break; | 3570 | break; |
3530 | } | 3571 | } |
3531 | return 1; | 3572 | return 1; |
3532 | } | 3573 | } |
3533 | 3574 | ||
@@ -3549,10 +3590,12 @@ lt_argz_insertinorder (pargz, pargz_len, entry) | |||
3549 | if (*pargz) | 3590 | if (*pargz) |
3550 | while ((before = argz_next (*pargz, *pargz_len, before))) | 3591 | while ((before = argz_next (*pargz, *pargz_len, before))) |
3551 | { | 3592 | { |
3552 | int cmp = strcmp (entry, before); | 3593 | int cmp = strcmp (entry, before); |
3553 | 3594 | ||
3554 | if (cmp < 0) break; | 3595 | if (cmp < 0) |
3555 | if (cmp == 0) return 0; /* No duplicates! */ | 3596 | break; |
3597 | if (cmp == 0) | ||
3598 | return 0; /* No duplicates! */ | ||
3556 | } | 3599 | } |
3557 | 3600 | ||
3558 | return lt_argz_insert (pargz, pargz_len, before, entry); | 3601 | return lt_argz_insert (pargz, pargz_len, before, entry); |
@@ -3565,26 +3608,26 @@ lt_argz_insertdir (pargz, pargz_len, dirnam, dp) | |||
3565 | const char *dirnam; | 3608 | const char *dirnam; |
3566 | struct dirent *dp; | 3609 | struct dirent *dp; |
3567 | { | 3610 | { |
3568 | char *buf = 0; | 3611 | char *buf = 0; |
3569 | size_t buf_len = 0; | 3612 | size_t buf_len = 0; |
3570 | char *end = 0; | 3613 | char *end = 0; |
3571 | size_t end_offset = 0; | 3614 | size_t end_offset = 0; |
3572 | size_t dir_len = 0; | 3615 | size_t dir_len = 0; |
3573 | int errors = 0; | 3616 | int errors = 0; |
3574 | 3617 | ||
3575 | assert (pargz); | 3618 | assert (pargz); |
3576 | assert (pargz_len); | 3619 | assert (pargz_len); |
3577 | assert (dp); | 3620 | assert (dp); |
3578 | 3621 | ||
3579 | dir_len = LT_STRLEN (dirnam); | 3622 | dir_len = LT_STRLEN (dirnam); |
3580 | end = dp->d_name + LT_D_NAMLEN(dp); | 3623 | end = dp->d_name + LT_D_NAMLEN (dp); |
3581 | 3624 | ||
3582 | /* Ignore version numbers. */ | 3625 | /* Ignore version numbers. */ |
3583 | { | 3626 | { |
3584 | char *p; | 3627 | char *p; |
3585 | for (p = end; p -1 > dp->d_name; --p) | 3628 | for (p = end; p - 1 > dp->d_name; --p) |
3586 | if (strchr (".0123456789", p[-1]) == 0) | 3629 | if (strchr (".0123456789", p[-1]) == 0) |
3587 | break; | 3630 | break; |
3588 | 3631 | ||
3589 | if (*p == '.') | 3632 | if (*p == '.') |
3590 | end = p; | 3633 | end = p; |
@@ -3593,25 +3636,25 @@ lt_argz_insertdir (pargz, pargz_len, dirnam, dp) | |||
3593 | /* Ignore filename extension. */ | 3636 | /* Ignore filename extension. */ |
3594 | { | 3637 | { |
3595 | char *p; | 3638 | char *p; |
3596 | for (p = end -1; p > dp->d_name; --p) | 3639 | for (p = end - 1; p > dp->d_name; --p) |
3597 | if (*p == '.') | 3640 | if (*p == '.') |
3598 | { | 3641 | { |
3599 | end = p; | 3642 | end = p; |
3600 | break; | 3643 | break; |
3601 | } | 3644 | } |
3602 | } | 3645 | } |
3603 | 3646 | ||
3604 | /* Prepend the directory name. */ | 3647 | /* Prepend the directory name. */ |
3605 | end_offset = end - dp->d_name; | 3648 | end_offset = end - dp->d_name; |
3606 | buf_len = dir_len + 1+ end_offset; | 3649 | buf_len = dir_len + 1 + end_offset; |
3607 | buf = LT_EMALLOC (char, 1+ buf_len); | 3650 | buf = LT_EMALLOC (char, 1 + buf_len); |
3608 | if (!buf) | 3651 | if (!buf) |
3609 | return ++errors; | 3652 | return ++errors; |
3610 | 3653 | ||
3611 | assert (buf); | 3654 | assert (buf); |
3612 | 3655 | ||
3613 | strcpy (buf, dirnam); | 3656 | strcpy (buf, dirnam); |
3614 | strcat (buf, "/"); | 3657 | strcat (buf, "/"); |
3615 | strncat (buf, dp->d_name, end_offset); | 3658 | strncat (buf, dp->d_name, end_offset); |
3616 | buf[buf_len] = LT_EOS_CHAR; | 3659 | buf[buf_len] = LT_EOS_CHAR; |
3617 | 3660 | ||
@@ -3630,26 +3673,26 @@ list_files_by_dir (dirnam, pargz, pargz_len) | |||
3630 | char **pargz; | 3673 | char **pargz; |
3631 | size_t *pargz_len; | 3674 | size_t *pargz_len; |
3632 | { | 3675 | { |
3633 | DIR *dirp = 0; | 3676 | DIR *dirp = 0; |
3634 | int errors = 0; | 3677 | int errors = 0; |
3635 | 3678 | ||
3636 | assert (dirnam && *dirnam); | 3679 | assert (dirnam && *dirnam); |
3637 | assert (pargz); | 3680 | assert (pargz); |
3638 | assert (pargz_len); | 3681 | assert (pargz_len); |
3639 | assert (dirnam[LT_STRLEN(dirnam) -1] != '/'); | 3682 | assert (dirnam[LT_STRLEN (dirnam) - 1] != '/'); |
3640 | 3683 | ||
3641 | dirp = opendir (dirnam); | 3684 | dirp = opendir (dirnam); |
3642 | if (dirp) | 3685 | if (dirp) |
3643 | { | 3686 | { |
3644 | struct dirent *dp = 0; | 3687 | struct dirent *dp = 0; |
3645 | 3688 | ||
3646 | while ((dp = readdir (dirp))) | 3689 | while ((dp = readdir (dirp))) |
3647 | if (dp->d_name[0] != '.') | 3690 | if (dp->d_name[0] != '.') |
3648 | if (lt_argz_insertdir (pargz, pargz_len, dirnam, dp)) | 3691 | if (lt_argz_insertdir (pargz, pargz_len, dirnam, dp)) |
3649 | { | 3692 | { |
3650 | ++errors; | 3693 | ++errors; |
3651 | break; | 3694 | break; |
3652 | } | 3695 | } |
3653 | 3696 | ||
3654 | closedir (dirp); | 3697 | closedir (dirp); |
3655 | } | 3698 | } |
@@ -3668,12 +3711,12 @@ foreachfile_callback (dirname, data1, data2) | |||
3668 | lt_ptr data1; | 3711 | lt_ptr data1; |
3669 | lt_ptr data2; | 3712 | lt_ptr data2; |
3670 | { | 3713 | { |
3671 | int (*func) LT_PARAMS((const char *filename, lt_ptr data)) | 3714 | int (*func) LT_PARAMS ((const char *filename, lt_ptr data)) |
3672 | = (int (*) LT_PARAMS((const char *filename, lt_ptr data))) data1; | 3715 | = (int (*)LT_PARAMS ((const char *filename, lt_ptr data))) data1; |
3673 | 3716 | ||
3674 | int is_done = 0; | 3717 | int is_done = 0; |
3675 | char *argz = 0; | 3718 | char *argz = 0; |
3676 | size_t argz_len = 0; | 3719 | size_t argz_len = 0; |
3677 | 3720 | ||
3678 | if (list_files_by_dir (dirname, &argz, &argz_len) != 0) | 3721 | if (list_files_by_dir (dirname, &argz, &argz_len) != 0) |
3679 | goto cleanup; | 3722 | goto cleanup; |
@@ -3684,10 +3727,10 @@ foreachfile_callback (dirname, data1, data2) | |||
3684 | char *filename = 0; | 3727 | char *filename = 0; |
3685 | while ((filename = argz_next (argz, argz_len, filename))) | 3728 | while ((filename = argz_next (argz, argz_len, filename))) |
3686 | if ((is_done = (*func) (filename, data2))) | 3729 | if ((is_done = (*func) (filename, data2))) |
3687 | break; | 3730 | break; |
3688 | } | 3731 | } |
3689 | 3732 | ||
3690 | cleanup: | 3733 | cleanup: |
3691 | LT_DLFREE (argz); | 3734 | LT_DLFREE (argz); |
3692 | 3735 | ||
3693 | return is_done; | 3736 | return is_done; |
@@ -3711,34 +3754,34 @@ lt_dlforeachfile (search_path, func, data) | |||
3711 | if (search_path) | 3754 | if (search_path) |
3712 | { | 3755 | { |
3713 | /* If a specific path was passed, search only the directories | 3756 | /* If a specific path was passed, search only the directories |
3714 | listed in it. */ | 3757 | listed in it. */ |
3715 | is_done = foreach_dirinpath (search_path, 0, | 3758 | is_done = foreach_dirinpath (search_path, 0, |
3716 | foreachfile_callback, func, data); | 3759 | foreachfile_callback, func, data); |
3717 | } | 3760 | } |
3718 | else | 3761 | else |
3719 | { | 3762 | { |
3720 | /* Otherwise search the default paths. */ | 3763 | /* Otherwise search the default paths. */ |
3721 | is_done = foreach_dirinpath (user_search_path, 0, | 3764 | is_done = foreach_dirinpath (user_search_path, 0, |
3722 | foreachfile_callback, func, data); | 3765 | foreachfile_callback, func, data); |
3723 | if (!is_done) | 3766 | if (!is_done) |
3724 | { | 3767 | { |
3725 | is_done = foreach_dirinpath (getenv("LTDL_LIBRARY_PATH"), 0, | 3768 | is_done = foreach_dirinpath (getenv ("LTDL_LIBRARY_PATH"), 0, |
3726 | foreachfile_callback, func, data); | 3769 | foreachfile_callback, func, data); |
3727 | } | 3770 | } |
3728 | 3771 | ||
3729 | #ifdef LTDL_SHLIBPATH_VAR | 3772 | #ifdef LTDL_SHLIBPATH_VAR |
3730 | if (!is_done) | 3773 | if (!is_done) |
3731 | { | 3774 | { |
3732 | is_done = foreach_dirinpath (getenv(LTDL_SHLIBPATH_VAR), 0, | 3775 | is_done = foreach_dirinpath (getenv (LTDL_SHLIBPATH_VAR), 0, |
3733 | foreachfile_callback, func, data); | 3776 | foreachfile_callback, func, data); |
3734 | } | 3777 | } |
3735 | #endif | 3778 | #endif |
3736 | #ifdef LTDL_SYSSEARCHPATH | 3779 | #ifdef LTDL_SYSSEARCHPATH |
3737 | if (!is_done) | 3780 | if (!is_done) |
3738 | { | 3781 | { |
3739 | is_done = foreach_dirinpath (getenv(LTDL_SYSSEARCHPATH), 0, | 3782 | is_done = foreach_dirinpath (getenv (LTDL_SYSSEARCHPATH), 0, |
3740 | foreachfile_callback, func, data); | 3783 | foreachfile_callback, func, data); |
3741 | } | 3784 | } |
3742 | #endif | 3785 | #endif |
3743 | } | 3786 | } |
3744 | 3787 | ||
@@ -3780,16 +3823,16 @@ lt_dlclose (handle) | |||
3780 | lt_user_data data = handle->loader->dlloader_data; | 3823 | lt_user_data data = handle->loader->dlloader_data; |
3781 | 3824 | ||
3782 | if (handle != handles) | 3825 | if (handle != handles) |
3783 | { | 3826 | { |
3784 | last->next = handle->next; | 3827 | last->next = handle->next; |
3785 | } | 3828 | } |
3786 | else | 3829 | else |
3787 | { | 3830 | { |
3788 | handles = handle->next; | 3831 | handles = handle->next; |
3789 | } | 3832 | } |
3790 | 3833 | ||
3791 | errors += handle->loader->module_close (data, handle->module); | 3834 | errors += handle->loader->module_close (data, handle->module); |
3792 | errors += unload_deplibs(handle); | 3835 | errors += unload_deplibs (handle); |
3793 | 3836 | ||
3794 | /* It is up to the callers to free the data itself. */ | 3837 | /* It is up to the callers to free the data itself. */ |
3795 | LT_DLFREE (handle->caller_data); | 3838 | LT_DLFREE (handle->caller_data); |
@@ -3807,7 +3850,7 @@ lt_dlclose (handle) | |||
3807 | ++errors; | 3850 | ++errors; |
3808 | } | 3851 | } |
3809 | 3852 | ||
3810 | done: | 3853 | done: |
3811 | LT_DLMUTEX_UNLOCK (); | 3854 | LT_DLMUTEX_UNLOCK (); |
3812 | 3855 | ||
3813 | return errors; | 3856 | return errors; |
@@ -3819,8 +3862,8 @@ lt_dlsym (handle, symbol) | |||
3819 | const char *symbol; | 3862 | const char *symbol; |
3820 | { | 3863 | { |
3821 | size_t lensym; | 3864 | size_t lensym; |
3822 | char lsym[LT_SYMBOL_LENGTH]; | 3865 | char lsym[LT_SYMBOL_LENGTH]; |
3823 | char *sym; | 3866 | char *sym; |
3824 | lt_ptr address; | 3867 | lt_ptr address; |
3825 | lt_user_data data; | 3868 | lt_user_data data; |
3826 | 3869 | ||
@@ -3837,7 +3880,7 @@ lt_dlsym (handle, symbol) | |||
3837 | } | 3880 | } |
3838 | 3881 | ||
3839 | lensym = LT_STRLEN (symbol) + LT_STRLEN (handle->loader->sym_prefix) | 3882 | lensym = LT_STRLEN (symbol) + LT_STRLEN (handle->loader->sym_prefix) |
3840 | + LT_STRLEN (handle->info.name); | 3883 | + LT_STRLEN (handle->info.name); |
3841 | 3884 | ||
3842 | if (lensym + LT_SYMBOL_OVERHEAD < LT_SYMBOL_LENGTH) | 3885 | if (lensym + LT_SYMBOL_OVERHEAD < LT_SYMBOL_LENGTH) |
3843 | { | 3886 | { |
@@ -3847,10 +3890,10 @@ lt_dlsym (handle, symbol) | |||
3847 | { | 3890 | { |
3848 | sym = LT_EMALLOC (char, lensym + LT_SYMBOL_OVERHEAD + 1); | 3891 | sym = LT_EMALLOC (char, lensym + LT_SYMBOL_OVERHEAD + 1); |
3849 | if (!sym) | 3892 | if (!sym) |
3850 | { | 3893 | { |
3851 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (BUFFER_OVERFLOW)); | 3894 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (BUFFER_OVERFLOW)); |
3852 | return 0; | 3895 | return 0; |
3853 | } | 3896 | } |
3854 | } | 3897 | } |
3855 | 3898 | ||
3856 | data = handle->loader->dlloader_data; | 3899 | data = handle->loader->dlloader_data; |
@@ -3862,40 +3905,40 @@ lt_dlsym (handle, symbol) | |||
3862 | 3905 | ||
3863 | /* this is a libtool module */ | 3906 | /* this is a libtool module */ |
3864 | if (handle->loader->sym_prefix) | 3907 | if (handle->loader->sym_prefix) |
3865 | { | 3908 | { |
3866 | strcpy(sym, handle->loader->sym_prefix); | 3909 | strcpy (sym, handle->loader->sym_prefix); |
3867 | strcat(sym, handle->info.name); | 3910 | strcat (sym, handle->info.name); |
3868 | } | 3911 | } |
3869 | else | 3912 | else |
3870 | { | 3913 | { |
3871 | strcpy(sym, handle->info.name); | 3914 | strcpy (sym, handle->info.name); |
3872 | } | 3915 | } |
3873 | 3916 | ||
3874 | strcat(sym, "_LTX_"); | 3917 | strcat (sym, "_LTX_"); |
3875 | strcat(sym, symbol); | 3918 | strcat (sym, symbol); |
3876 | 3919 | ||
3877 | /* try "modulename_LTX_symbol" */ | 3920 | /* try "modulename_LTX_symbol" */ |
3878 | address = handle->loader->find_sym (data, handle->module, sym); | 3921 | address = handle->loader->find_sym (data, handle->module, sym); |
3879 | if (address) | 3922 | if (address) |
3880 | { | 3923 | { |
3881 | if (sym != lsym) | 3924 | if (sym != lsym) |
3882 | { | 3925 | { |
3883 | LT_DLFREE (sym); | 3926 | LT_DLFREE (sym); |
3884 | } | 3927 | } |
3885 | return address; | 3928 | return address; |
3886 | } | 3929 | } |
3887 | LT_DLMUTEX_SETERROR (saved_error); | 3930 | LT_DLMUTEX_SETERROR (saved_error); |
3888 | } | 3931 | } |
3889 | 3932 | ||
3890 | /* otherwise try "symbol" */ | 3933 | /* otherwise try "symbol" */ |
3891 | if (handle->loader->sym_prefix) | 3934 | if (handle->loader->sym_prefix) |
3892 | { | 3935 | { |
3893 | strcpy(sym, handle->loader->sym_prefix); | 3936 | strcpy (sym, handle->loader->sym_prefix); |
3894 | strcat(sym, symbol); | 3937 | strcat (sym, symbol); |
3895 | } | 3938 | } |
3896 | else | 3939 | else |
3897 | { | 3940 | { |
3898 | strcpy(sym, symbol); | 3941 | strcpy (sym, symbol); |
3899 | } | 3942 | } |
3900 | 3943 | ||
3901 | address = handle->loader->find_sym (data, handle->module, sym); | 3944 | address = handle->loader->find_sym (data, handle->module, sym); |
@@ -3924,10 +3967,10 @@ lt_dlpath_insertdir (ppath, before, dir) | |||
3924 | char *before; | 3967 | char *before; |
3925 | const char *dir; | 3968 | const char *dir; |
3926 | { | 3969 | { |
3927 | int errors = 0; | 3970 | int errors = 0; |
3928 | char *canonical = 0; | 3971 | char *canonical = 0; |
3929 | char *argz = 0; | 3972 | char *argz = 0; |
3930 | size_t argz_len = 0; | 3973 | size_t argz_len = 0; |
3931 | 3974 | ||
3932 | assert (ppath); | 3975 | assert (ppath); |
3933 | assert (dir && *dir); | 3976 | assert (dir && *dir); |
@@ -3943,12 +3986,12 @@ lt_dlpath_insertdir (ppath, before, dir) | |||
3943 | /* If *PPATH is empty, set it to DIR. */ | 3986 | /* If *PPATH is empty, set it to DIR. */ |
3944 | if (*ppath == 0) | 3987 | if (*ppath == 0) |
3945 | { | 3988 | { |
3946 | assert (!before); /* BEFORE cannot be set without PPATH. */ | 3989 | assert (!before); /* BEFORE cannot be set without PPATH. */ |
3947 | assert (dir); /* Without DIR, don't call this function! */ | 3990 | assert (dir); /* Without DIR, don't call this function! */ |
3948 | 3991 | ||
3949 | *ppath = lt_estrdup (dir); | 3992 | *ppath = lt_estrdup (dir); |
3950 | if (*ppath == 0) | 3993 | if (*ppath == 0) |
3951 | ++errors; | 3994 | ++errors; |
3952 | 3995 | ||
3953 | return errors; | 3996 | return errors; |
3954 | } | 3997 | } |
@@ -3981,9 +4024,9 @@ lt_dlpath_insertdir (ppath, before, dir) | |||
3981 | } | 4024 | } |
3982 | 4025 | ||
3983 | argz_stringify (argz, argz_len, LT_PATHSEP_CHAR); | 4026 | argz_stringify (argz, argz_len, LT_PATHSEP_CHAR); |
3984 | LT_DLMEM_REASSIGN (*ppath, argz); | 4027 | LT_DLMEM_REASSIGN (*ppath, argz); |
3985 | 4028 | ||
3986 | cleanup: | 4029 | cleanup: |
3987 | LT_DLFREE (canonical); | 4030 | LT_DLFREE (canonical); |
3988 | LT_DLFREE (argz); | 4031 | LT_DLFREE (argz); |
3989 | 4032 | ||
@@ -4000,7 +4043,7 @@ lt_dladdsearchdir (search_dir) | |||
4000 | { | 4043 | { |
4001 | LT_DLMUTEX_LOCK (); | 4044 | LT_DLMUTEX_LOCK (); |
4002 | if (lt_dlpath_insertdir (&user_search_path, 0, search_dir) != 0) | 4045 | if (lt_dlpath_insertdir (&user_search_path, 0, search_dir) != 0) |
4003 | ++errors; | 4046 | ++errors; |
4004 | LT_DLMUTEX_UNLOCK (); | 4047 | LT_DLMUTEX_UNLOCK (); |
4005 | } | 4048 | } |
4006 | 4049 | ||
@@ -4018,12 +4061,12 @@ lt_dlinsertsearchdir (before, search_dir) | |||
4018 | { | 4061 | { |
4019 | LT_DLMUTEX_LOCK (); | 4062 | LT_DLMUTEX_LOCK (); |
4020 | if ((before < user_search_path) | 4063 | if ((before < user_search_path) |
4021 | || (before >= user_search_path + LT_STRLEN (user_search_path))) | 4064 | || (before >= user_search_path + LT_STRLEN (user_search_path))) |
4022 | { | 4065 | { |
4023 | LT_DLMUTEX_UNLOCK (); | 4066 | LT_DLMUTEX_UNLOCK (); |
4024 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (INVALID_POSITION)); | 4067 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (INVALID_POSITION)); |
4025 | return 1; | 4068 | return 1; |
4026 | } | 4069 | } |
4027 | LT_DLMUTEX_UNLOCK (); | 4070 | LT_DLMUTEX_UNLOCK (); |
4028 | } | 4071 | } |
4029 | 4072 | ||
@@ -4031,10 +4074,10 @@ lt_dlinsertsearchdir (before, search_dir) | |||
4031 | { | 4074 | { |
4032 | LT_DLMUTEX_LOCK (); | 4075 | LT_DLMUTEX_LOCK (); |
4033 | if (lt_dlpath_insertdir (&user_search_path, | 4076 | if (lt_dlpath_insertdir (&user_search_path, |
4034 | (char *) before, search_dir) != 0) | 4077 | (char *) before, search_dir) != 0) |
4035 | { | 4078 | { |
4036 | ++errors; | 4079 | ++errors; |
4037 | } | 4080 | } |
4038 | LT_DLMUTEX_UNLOCK (); | 4081 | LT_DLMUTEX_UNLOCK (); |
4039 | } | 4082 | } |
4040 | 4083 | ||
@@ -4045,7 +4088,7 @@ int | |||
4045 | lt_dlsetsearchpath (search_path) | 4088 | lt_dlsetsearchpath (search_path) |
4046 | const char *search_path; | 4089 | const char *search_path; |
4047 | { | 4090 | { |
4048 | int errors = 0; | 4091 | int errors = 0; |
4049 | 4092 | ||
4050 | LT_DLMUTEX_LOCK (); | 4093 | LT_DLMUTEX_LOCK (); |
4051 | LT_DLFREE (user_search_path); | 4094 | LT_DLFREE (user_search_path); |
@@ -4096,7 +4139,7 @@ lt_dlmakeresident (handle) | |||
4096 | } | 4139 | } |
4097 | 4140 | ||
4098 | int | 4141 | int |
4099 | lt_dlisresident (handle) | 4142 | lt_dlisresident (handle) |
4100 | lt_dlhandle handle; | 4143 | lt_dlhandle handle; |
4101 | { | 4144 | { |
4102 | if (!handle) | 4145 | if (!handle) |
@@ -4107,10 +4150,10 @@ lt_dlisresident (handle) | |||
4107 | 4150 | ||
4108 | return LT_DLIS_RESIDENT (handle); | 4151 | return LT_DLIS_RESIDENT (handle); |
4109 | } | 4152 | } |
4153 | |||
4110 | 4154 | ||
4111 | 4155 | ||
4112 | 4156 | ||
4113 | |||
4114 | /* --- MODULE INFORMATION --- */ | 4157 | /* --- MODULE INFORMATION --- */ |
4115 | 4158 | ||
4116 | const lt_dlinfo * | 4159 | const lt_dlinfo * |
@@ -4135,7 +4178,7 @@ lt_dlhandle_next (place) | |||
4135 | 4178 | ||
4136 | int | 4179 | int |
4137 | lt_dlforeach (func, data) | 4180 | lt_dlforeach (func, data) |
4138 | int (*func) LT_PARAMS((lt_dlhandle handle, lt_ptr data)); | 4181 | int (*func) LT_PARAMS ((lt_dlhandle handle, lt_ptr data)); |
4139 | lt_ptr data; | 4182 | lt_ptr data; |
4140 | { | 4183 | { |
4141 | int errors = 0; | 4184 | int errors = 0; |
@@ -4150,10 +4193,10 @@ lt_dlforeach (func, data) | |||
4150 | 4193 | ||
4151 | cur = cur->next; | 4194 | cur = cur->next; |
4152 | if ((*func) (tmp, data)) | 4195 | if ((*func) (tmp, data)) |
4153 | { | 4196 | { |
4154 | ++errors; | 4197 | ++errors; |
4155 | break; | 4198 | break; |
4156 | } | 4199 | } |
4157 | } | 4200 | } |
4158 | 4201 | ||
4159 | LT_DLMUTEX_UNLOCK (); | 4202 | LT_DLMUTEX_UNLOCK (); |
@@ -4195,10 +4238,10 @@ lt_dlcaller_set_data (key, handle, data) | |||
4195 | for (i = 0; i < n_elements; ++i) | 4238 | for (i = 0; i < n_elements; ++i) |
4196 | { | 4239 | { |
4197 | if (handle->caller_data[i].key == key) | 4240 | if (handle->caller_data[i].key == key) |
4198 | { | 4241 | { |
4199 | stale = handle->caller_data[i].data; | 4242 | stale = handle->caller_data[i].data; |
4200 | break; | 4243 | break; |
4201 | } | 4244 | } |
4202 | } | 4245 | } |
4203 | 4246 | ||
4204 | /* Ensure that there is enough room in this handle's caller_data | 4247 | /* Ensure that there is enough room in this handle's caller_data |
@@ -4206,31 +4249,31 @@ lt_dlcaller_set_data (key, handle, data) | |||
4206 | if (i == n_elements) | 4249 | if (i == n_elements) |
4207 | { | 4250 | { |
4208 | lt_caller_data *temp | 4251 | lt_caller_data *temp |
4209 | = LT_DLREALLOC (lt_caller_data, handle->caller_data, 2+ n_elements); | 4252 | = LT_DLREALLOC (lt_caller_data, handle->caller_data, 2 + n_elements); |
4210 | 4253 | ||
4211 | if (!temp) | 4254 | if (!temp) |
4212 | { | 4255 | { |
4213 | stale = 0; | 4256 | stale = 0; |
4214 | goto done; | 4257 | goto done; |
4215 | } | 4258 | } |
4216 | 4259 | ||
4217 | handle->caller_data = temp; | 4260 | handle->caller_data = temp; |
4218 | 4261 | ||
4219 | /* We only need this if we needed to allocate a new caller_data. */ | 4262 | /* We only need this if we needed to allocate a new caller_data. */ |
4220 | handle->caller_data[i].key = key; | 4263 | handle->caller_data[i].key = key; |
4221 | handle->caller_data[1+ i].key = 0; | 4264 | handle->caller_data[1 + i].key = 0; |
4222 | } | 4265 | } |
4223 | 4266 | ||
4224 | handle->caller_data[i].data = data; | 4267 | handle->caller_data[i].data = data; |
4225 | 4268 | ||
4226 | done: | 4269 | done: |
4227 | LT_DLMUTEX_UNLOCK (); | 4270 | LT_DLMUTEX_UNLOCK (); |
4228 | 4271 | ||
4229 | return stale; | 4272 | return stale; |
4230 | } | 4273 | } |
4231 | 4274 | ||
4232 | lt_ptr | 4275 | lt_ptr |
4233 | lt_dlcaller_get_data (key, handle) | 4276 | lt_dlcaller_get_data (key, handle) |
4234 | lt_dlcaller_id key; | 4277 | lt_dlcaller_id key; |
4235 | lt_dlhandle handle; | 4278 | lt_dlhandle handle; |
4236 | { | 4279 | { |
@@ -4245,11 +4288,11 @@ lt_dlcaller_get_data (key, handle) | |||
4245 | int i; | 4288 | int i; |
4246 | for (i = 0; handle->caller_data[i].key; ++i) | 4289 | for (i = 0; handle->caller_data[i].key; ++i) |
4247 | { | 4290 | { |
4248 | if (handle->caller_data[i].key == key) | 4291 | if (handle->caller_data[i].key == key) |
4249 | { | 4292 | { |
4250 | result = handle->caller_data[i].data; | 4293 | result = handle->caller_data[i].data; |
4251 | break; | 4294 | break; |
4252 | } | 4295 | } |
4253 | } | 4296 | } |
4254 | } | 4297 | } |
4255 | 4298 | ||
@@ -4257,9 +4300,9 @@ lt_dlcaller_get_data (key, handle) | |||
4257 | 4300 | ||
4258 | return result; | 4301 | return result; |
4259 | } | 4302 | } |
4303 | |||
4260 | 4304 | ||
4261 | 4305 | ||
4262 | |||
4263 | /* --- USER MODULE LOADER API --- */ | 4306 | /* --- USER MODULE LOADER API --- */ |
4264 | 4307 | ||
4265 | 4308 | ||
@@ -4272,10 +4315,9 @@ lt_dlloader_add (place, dlloader, loader_name) | |||
4272 | int errors = 0; | 4315 | int errors = 0; |
4273 | lt_dlloader *node = 0, *ptr = 0; | 4316 | lt_dlloader *node = 0, *ptr = 0; |
4274 | 4317 | ||
4275 | if ((dlloader == 0) /* diagnose null parameters */ | 4318 | if ((dlloader == 0) /* diagnose null parameters */ |
4276 | || (dlloader->module_open == 0) | 4319 | || (dlloader->module_open == 0) |
4277 | || (dlloader->module_close == 0) | 4320 | || (dlloader->module_close == 0) || (dlloader->find_sym == 0)) |
4278 | || (dlloader->find_sym == 0)) | ||
4279 | { | 4321 | { |
4280 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (INVALID_LOADER)); | 4322 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (INVALID_LOADER)); |
4281 | return 1; | 4323 | return 1; |
@@ -4286,14 +4328,14 @@ lt_dlloader_add (place, dlloader, loader_name) | |||
4286 | if (!node) | 4328 | if (!node) |
4287 | return 1; | 4329 | return 1; |
4288 | 4330 | ||
4289 | node->next = 0; | 4331 | node->next = 0; |
4290 | node->loader_name = loader_name; | 4332 | node->loader_name = loader_name; |
4291 | node->sym_prefix = dlloader->sym_prefix; | 4333 | node->sym_prefix = dlloader->sym_prefix; |
4292 | node->dlloader_exit = dlloader->dlloader_exit; | 4334 | node->dlloader_exit = dlloader->dlloader_exit; |
4293 | node->module_open = dlloader->module_open; | 4335 | node->module_open = dlloader->module_open; |
4294 | node->module_close = dlloader->module_close; | 4336 | node->module_close = dlloader->module_close; |
4295 | node->find_sym = dlloader->find_sym; | 4337 | node->find_sym = dlloader->find_sym; |
4296 | node->dlloader_data = dlloader->dlloader_data; | 4338 | node->dlloader_data = dlloader->dlloader_data; |
4297 | 4339 | ||
4298 | LT_DLMUTEX_LOCK (); | 4340 | LT_DLMUTEX_LOCK (); |
4299 | if (!loaders) | 4341 | if (!loaders) |
@@ -4304,11 +4346,11 @@ lt_dlloader_add (place, dlloader, loader_name) | |||
4304 | else if (!place) | 4346 | else if (!place) |
4305 | { | 4347 | { |
4306 | /* If PLACE is not set, add NODE to the end of the | 4348 | /* If PLACE is not set, add NODE to the end of the |
4307 | LOADERS list. */ | 4349 | LOADERS list. */ |
4308 | for (ptr = loaders; ptr->next; ptr = ptr->next) | 4350 | for (ptr = loaders; ptr->next; ptr = ptr->next) |
4309 | { | 4351 | { |
4310 | /*NOWORK*/; | 4352 | /*NOWORK*/; |
4311 | } | 4353 | } |
4312 | 4354 | ||
4313 | ptr->next = node; | 4355 | ptr->next = node; |
4314 | } | 4356 | } |
@@ -4322,21 +4364,21 @@ lt_dlloader_add (place, dlloader, loader_name) | |||
4322 | { | 4364 | { |
4323 | /* Find the node immediately preceding PLACE. */ | 4365 | /* Find the node immediately preceding PLACE. */ |
4324 | for (ptr = loaders; ptr->next != place; ptr = ptr->next) | 4366 | for (ptr = loaders; ptr->next != place; ptr = ptr->next) |
4325 | { | 4367 | { |
4326 | /*NOWORK*/; | 4368 | /*NOWORK*/; |
4327 | } | 4369 | } |
4328 | 4370 | ||
4329 | if (ptr->next != place) | 4371 | if (ptr->next != place) |
4330 | { | 4372 | { |
4331 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (INVALID_LOADER)); | 4373 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (INVALID_LOADER)); |
4332 | ++errors; | 4374 | ++errors; |
4333 | } | 4375 | } |
4334 | else | 4376 | else |
4335 | { | 4377 | { |
4336 | /* Insert NODE between PTR and PLACE. */ | 4378 | /* Insert NODE between PTR and PLACE. */ |
4337 | node->next = place; | 4379 | node->next = place; |
4338 | ptr->next = node; | 4380 | ptr->next = node; |
4339 | } | 4381 | } |
4340 | } | 4382 | } |
4341 | 4383 | ||
4342 | LT_DLMUTEX_UNLOCK (); | 4384 | LT_DLMUTEX_UNLOCK (); |
@@ -4361,14 +4403,14 @@ lt_dlloader_remove (loader_name) | |||
4361 | LT_DLMUTEX_LOCK (); | 4403 | LT_DLMUTEX_LOCK (); |
4362 | 4404 | ||
4363 | /* Fail if there are any open modules which use this loader. */ | 4405 | /* Fail if there are any open modules which use this loader. */ |
4364 | for (handle = handles; handle; handle = handle->next) | 4406 | for (handle = handles; handle; handle = handle->next) |
4365 | { | 4407 | { |
4366 | if (handle->loader == place) | 4408 | if (handle->loader == place) |
4367 | { | 4409 | { |
4368 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (REMOVE_LOADER)); | 4410 | LT_DLMUTEX_SETERROR (LT_DLSTRERROR (REMOVE_LOADER)); |
4369 | ++errors; | 4411 | ++errors; |
4370 | goto done; | 4412 | goto done; |
4371 | } | 4413 | } |
4372 | } | 4414 | } |
4373 | 4415 | ||
4374 | if (place == loaders) | 4416 | if (place == loaders) |
@@ -4381,12 +4423,12 @@ lt_dlloader_remove (loader_name) | |||
4381 | /* Find the loader before the one being removed. */ | 4423 | /* Find the loader before the one being removed. */ |
4382 | lt_dlloader *prev; | 4424 | lt_dlloader *prev; |
4383 | for (prev = loaders; prev->next; prev = prev->next) | 4425 | for (prev = loaders; prev->next; prev = prev->next) |
4384 | { | 4426 | { |
4385 | if (!strcmp (prev->next->loader_name, loader_name)) | 4427 | if (!strcmp (prev->next->loader_name, loader_name)) |
4386 | { | 4428 | { |
4387 | break; | 4429 | break; |
4388 | } | 4430 | } |
4389 | } | 4431 | } |
4390 | 4432 | ||
4391 | place = prev->next; | 4433 | place = prev->next; |
4392 | prev->next = prev->next->next; | 4434 | prev->next = prev->next->next; |
@@ -4399,7 +4441,7 @@ lt_dlloader_remove (loader_name) | |||
4399 | 4441 | ||
4400 | LT_DLFREE (place); | 4442 | LT_DLFREE (place); |
4401 | 4443 | ||
4402 | done: | 4444 | done: |
4403 | LT_DLMUTEX_UNLOCK (); | 4445 | LT_DLMUTEX_UNLOCK (); |
4404 | 4446 | ||
4405 | return errors; | 4447 | return errors; |
@@ -4468,9 +4510,9 @@ lt_dlloader_find (loader_name) | |||
4468 | for (place = loaders; place; place = place->next) | 4510 | for (place = loaders; place; place = place->next) |
4469 | { | 4511 | { |
4470 | if (strcmp (place->loader_name, loader_name) == 0) | 4512 | if (strcmp (place->loader_name, loader_name) == 0) |
4471 | { | 4513 | { |
4472 | break; | 4514 | break; |
4473 | } | 4515 | } |
4474 | } | 4516 | } |
4475 | LT_DLMUTEX_UNLOCK (); | 4517 | LT_DLMUTEX_UNLOCK (); |
4476 | 4518 | ||
diff --git a/libltdl/ltdl.h b/libltdl/ltdl.h index 995d4038..2e246515 100644 --- a/libltdl/ltdl.h +++ b/libltdl/ltdl.h | |||
@@ -28,9 +28,9 @@ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA | |||
28 | #ifndef LTDL_H | 28 | #ifndef LTDL_H |
29 | #define LTDL_H 1 | 29 | #define LTDL_H 1 |
30 | 30 | ||
31 | #include <sys/types.h> /* for size_t declaration */ | 31 | #include <sys/types.h> /* for size_t declaration */ |
32 | |||
33 | 32 | ||
33 | |||
34 | /* --- MACROS FOR PORTABILITY --- */ | 34 | /* --- MACROS FOR PORTABILITY --- */ |
35 | 35 | ||
36 | 36 | ||
@@ -44,13 +44,11 @@ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA | |||
44 | # define LT_BEGIN_C_DECLS extern "C" { | 44 | # define LT_BEGIN_C_DECLS extern "C" { |
45 | # define LT_END_C_DECLS } | 45 | # define LT_END_C_DECLS } |
46 | #else | 46 | #else |
47 | # define LT_BEGIN_C_DECLS /* empty */ | 47 | # define LT_BEGIN_C_DECLS /* empty */ |
48 | # define LT_END_C_DECLS /* empty */ | 48 | # define LT_END_C_DECLS /* empty */ |
49 | #endif | 49 | #endif |
50 | 50 | ||
51 | LT_BEGIN_C_DECLS | 51 | LT_BEGIN_C_DECLS |
52 | |||
53 | |||
54 | /* LT_PARAMS is a macro used to wrap function prototypes, so that compilers | 52 | /* LT_PARAMS is a macro used to wrap function prototypes, so that compilers |
55 | that don't understand ANSI C prototypes still work, and ANSI C | 53 | that don't understand ANSI C prototypes still work, and ANSI C |
56 | compilers can issue warnings about type mismatches. */ | 54 | compilers can issue warnings about type mismatches. */ |
@@ -61,7 +59,6 @@ LT_BEGIN_C_DECLS | |||
61 | # define LT_PARAMS(protos) () | 59 | # define LT_PARAMS(protos) () |
62 | # define lt_ptr char* | 60 | # define lt_ptr char* |
63 | #endif | 61 | #endif |
64 | |||
65 | /* LT_STMT_START/END are used to create macros which expand to a | 62 | /* LT_STMT_START/END are used to create macros which expand to a |
66 | a single compound statement in a portable way. */ | 63 | a single compound statement in a portable way. */ |
67 | #if defined (__GNUC__) && !defined (__STRICT_ANSI__) && !defined (__cplusplus) | 64 | #if defined (__GNUC__) && !defined (__STRICT_ANSI__) && !defined (__cplusplus) |
@@ -76,7 +73,6 @@ LT_BEGIN_C_DECLS | |||
76 | # define LT_STMT_END while (0) | 73 | # define LT_STMT_END while (0) |
77 | # endif | 74 | # endif |
78 | #endif | 75 | #endif |
79 | |||
80 | /* LT_CONC creates a new concatenated symbol for the compiler | 76 | /* LT_CONC creates a new concatenated symbol for the compiler |
81 | in a portable way. */ | 77 | in a portable way. */ |
82 | #if defined(__STDC__) || defined(__cplusplus) || defined(_MSC_VER) | 78 | #if defined(__STDC__) || defined(__cplusplus) || defined(_MSC_VER) |
@@ -84,15 +80,9 @@ LT_BEGIN_C_DECLS | |||
84 | #else | 80 | #else |
85 | # define LT_CONC(s,t) s/**/t | 81 | # define LT_CONC(s,t) s/**/t |
86 | #endif | 82 | #endif |
87 | |||
88 | /* LT_STRLEN can be used safely on NULL pointers. */ | 83 | /* LT_STRLEN can be used safely on NULL pointers. */ |
89 | #define LT_STRLEN(s) (((s) && (s)[0]) ? strlen (s) : 0) | 84 | #define LT_STRLEN(s) (((s) && (s)[0]) ? strlen (s) : 0) |
90 | 85 | /* --- WINDOWS SUPPORT --- */ | |
91 | |||
92 | |||
93 | /* --- WINDOWS SUPPORT --- */ | ||
94 | |||
95 | |||
96 | /* Canonicalise Windows and Cygwin recognition macros. */ | 86 | /* Canonicalise Windows and Cygwin recognition macros. */ |
97 | #ifdef __CYGWIN32__ | 87 | #ifdef __CYGWIN32__ |
98 | # ifndef __CYGWIN__ | 88 | # ifndef __CYGWIN__ |
@@ -110,8 +100,6 @@ LT_BEGIN_C_DECLS | |||
110 | # endif | 100 | # endif |
111 | # endif | 101 | # endif |
112 | #endif | 102 | #endif |
113 | |||
114 | |||
115 | #ifdef __WINDOWS__ | 103 | #ifdef __WINDOWS__ |
116 | # ifndef __CYGWIN__ | 104 | # ifndef __CYGWIN__ |
117 | /* LT_DIRSEP_CHAR is accepted *in addition* to '/' as a directory | 105 | /* LT_DIRSEP_CHAR is accepted *in addition* to '/' as a directory |
@@ -123,81 +111,72 @@ LT_BEGIN_C_DECLS | |||
123 | #ifndef LT_PATHSEP_CHAR | 111 | #ifndef LT_PATHSEP_CHAR |
124 | # define LT_PATHSEP_CHAR ':' | 112 | # define LT_PATHSEP_CHAR ':' |
125 | #endif | 113 | #endif |
126 | |||
127 | /* DLL building support on win32 hosts; mostly to workaround their | 114 | /* DLL building support on win32 hosts; mostly to workaround their |
128 | ridiculous implementation of data symbol exporting. */ | 115 | ridiculous implementation of data symbol exporting. */ |
129 | #ifndef LT_SCOPE | 116 | #ifndef LT_SCOPE |
130 | # ifdef __WINDOWS__ | 117 | # ifdef __WINDOWS__ |
131 | # ifdef DLL_EXPORT /* defined by libtool (if required) */ | 118 | # ifdef DLL_EXPORT /* defined by libtool (if required) */ |
132 | # define LT_SCOPE __declspec(dllexport) | 119 | # define LT_SCOPE __declspec(dllexport) |
133 | # endif | 120 | # endif |
134 | # ifdef LIBLTDL_DLL_IMPORT /* define if linking with this dll */ | 121 | # ifdef LIBLTDL_DLL_IMPORT /* define if linking with this dll */ |
135 | # define LT_SCOPE extern __declspec(dllimport) | 122 | # define LT_SCOPE extern __declspec(dllimport) |
136 | # endif | 123 | # endif |
137 | # endif | 124 | # endif |
138 | # ifndef LT_SCOPE /* static linking or !__WINDOWS__ */ | 125 | # ifndef LT_SCOPE /* static linking or !__WINDOWS__ */ |
139 | # define LT_SCOPE extern | 126 | # define LT_SCOPE extern |
140 | # endif | 127 | # endif |
141 | #endif | 128 | #endif |
142 | 129 | #if defined(_MSC_VER) /* Visual Studio */ | |
143 | |||
144 | #if defined(_MSC_VER) /* Visual Studio */ | ||
145 | # define R_OK 4 | 130 | # define R_OK 4 |
146 | #endif | 131 | #endif |
147 | 132 | /* --- DYNAMIC MODULE LOADING API --- */ | |
148 | 133 | typedef struct lt_dlhandle_struct *lt_dlhandle; /* A loaded module. */ | |
149 | |||
150 | /* --- DYNAMIC MODULE LOADING API --- */ | ||
151 | |||
152 | |||
153 | typedef struct lt_dlhandle_struct *lt_dlhandle; /* A loaded module. */ | ||
154 | 134 | ||
155 | /* Initialisation and finalisation functions for libltdl. */ | 135 | /* Initialisation and finalisation functions for libltdl. */ |
156 | LT_SCOPE int lt_dlinit LT_PARAMS((void)); | 136 | LT_SCOPE int lt_dlinit LT_PARAMS ((void)); |
157 | LT_SCOPE int lt_dlexit LT_PARAMS((void)); | 137 | LT_SCOPE int lt_dlexit LT_PARAMS ((void)); |
158 | 138 | ||
159 | /* Module search path manipulation. */ | 139 | /* Module search path manipulation. */ |
160 | LT_SCOPE int lt_dladdsearchdir LT_PARAMS((const char *search_dir)); | 140 | LT_SCOPE int lt_dladdsearchdir LT_PARAMS ((const char *search_dir)); |
161 | LT_SCOPE int lt_dlinsertsearchdir LT_PARAMS((const char *before, | 141 | LT_SCOPE int lt_dlinsertsearchdir LT_PARAMS ((const char *before, |
162 | const char *search_dir)); | 142 | const char *search_dir)); |
163 | LT_SCOPE int lt_dlsetsearchpath LT_PARAMS((const char *search_path)); | 143 | LT_SCOPE int lt_dlsetsearchpath LT_PARAMS ((const char *search_path)); |
164 | LT_SCOPE const char *lt_dlgetsearchpath LT_PARAMS((void)); | 144 | LT_SCOPE const char *lt_dlgetsearchpath LT_PARAMS ((void)); |
165 | LT_SCOPE int lt_dlforeachfile LT_PARAMS(( | 145 | LT_SCOPE int lt_dlforeachfile LT_PARAMS ((const char *search_path, |
166 | const char *search_path, | 146 | int (*func) (const char *filename, |
167 | int (*func) (const char *filename, lt_ptr data), | 147 | lt_ptr data), |
168 | lt_ptr data)); | 148 | lt_ptr data)); |
169 | 149 | ||
170 | /* Portable libltdl versions of the system dlopen() API. */ | 150 | /* Portable libltdl versions of the system dlopen() API. */ |
171 | LT_SCOPE lt_dlhandle lt_dlopen LT_PARAMS((const char *filename)); | 151 | LT_SCOPE lt_dlhandle lt_dlopen LT_PARAMS ((const char *filename)); |
172 | LT_SCOPE lt_dlhandle lt_dlopenext LT_PARAMS((const char *filename)); | 152 | LT_SCOPE lt_dlhandle lt_dlopenext LT_PARAMS ((const char *filename)); |
173 | LT_SCOPE lt_ptr lt_dlsym LT_PARAMS((lt_dlhandle handle, | 153 | LT_SCOPE lt_ptr lt_dlsym LT_PARAMS ((lt_dlhandle handle, const char *name)); |
174 | const char *name)); | 154 | LT_SCOPE const char *lt_dlerror LT_PARAMS ((void)); |