597 |
|
|
598 |
|
|
599 |
|
|
600 |
|
#if ! HAVE_ARGZ_STRINGIFY |
601 |
|
# define argz_stringify rpl_argz_stringify |
602 |
|
|
603 |
|
static void argz_stringify LT_PARAMS((char *argz, size_t argz_len, |
604 |
|
int sep)); |
605 |
|
|
606 |
|
void |
607 |
|
argz_stringify (argz, argz_len, sep) |
608 |
|
char *argz; |
609 |
|
size_t argz_len; |
610 |
|
int sep; |
611 |
|
{ |
612 |
|
assert ((argz && argz_len) || (!argz && !argz_len)); |
613 |
|
|
614 |
|
if (sep) |
615 |
|
{ |
616 |
|
while (--argz_len >= 0) |
617 |
|
{ |
618 |
|
if (argz[argz_len] == LT_EOS_CHAR) |
619 |
|
argz[argz_len] = sep; |
620 |
|
} |
621 |
|
} |
622 |
|
} |
623 |
|
#endif /* !HAVE_ARGZ_STRINGIFY */ |
624 |
|
|
625 |
|
|
626 |
|
|
627 |
|
|
628 |
/* --- TYPE DEFINITIONS -- */ |
/* --- TYPE DEFINITIONS -- */ |
629 |
|
|
1631 |
lt_ptr data2)); |
lt_ptr data2)); |
1632 |
|
|
1633 |
|
|
1634 |
static int canonicalize_path LT_PARAMS((const char *path, |
static int canonicalize_path LT_PARAMS((const char *path, |
1635 |
char **pcanonical)); |
char **pcanonical)); |
1636 |
static int argzize_path LT_PARAMS((const char *path, |
static int argzize_path LT_PARAMS((const char *path, |
1637 |
char **pargz, |
char **pargz, |
1638 |
size_t *pargz_len)); |
size_t *pargz_len)); |
1639 |
static FILE *find_file LT_PARAMS((const char *search_path, |
static FILE *find_file LT_PARAMS((const char *search_path, |
1640 |
const char *base_name, |
const char *base_name, |
1641 |
char **pdir)); |
char **pdir)); |
1642 |
static lt_dlhandle *find_handle LT_PARAMS((const char *search_path, |
static lt_dlhandle *find_handle LT_PARAMS((const char *search_path, |
1657 |
static int tryall_dlopen LT_PARAMS((lt_dlhandle *handle, |
static int tryall_dlopen LT_PARAMS((lt_dlhandle *handle, |
1658 |
const char *filename)); |
const char *filename)); |
1659 |
static int unload_deplibs LT_PARAMS((lt_dlhandle handle)); |
static int unload_deplibs LT_PARAMS((lt_dlhandle handle)); |
1660 |
|
static int lt_argz_insert LT_PARAMS((char **pargz, |
1661 |
|
size_t *pargz_len, |
1662 |
|
char *before, |
1663 |
|
const char *entry)); |
1664 |
|
static int lt_argz_insertinorder LT_PARAMS((char **pargz, |
1665 |
|
size_t *pargz_len, |
1666 |
|
const char *entry)); |
1667 |
|
static int lt_dlpath_insertdir LT_PARAMS((char **ppath, |
1668 |
|
char *before, |
1669 |
|
const char *dir)); |
1670 |
|
|
1671 |
static char *user_search_path= 0; |
static char *user_search_path= 0; |
1672 |
static lt_dlloader *loaders = 0; |
static lt_dlloader *loaders = 0; |
2891 |
return 0; |
return 0; |
2892 |
} |
} |
2893 |
|
|
2894 |
|
|
2895 |
|
int |
2896 |
|
lt_argz_insert (pargz, pargz_len, before, entry) |
2897 |
|
char **pargz; |
2898 |
|
size_t *pargz_len; |
2899 |
|
char *before; |
2900 |
|
const char *entry; |
2901 |
|
{ |
2902 |
|
error_t error; |
2903 |
|
|
2904 |
|
if ((error = argz_insert (pargz, pargz_len, before, entry))) |
2905 |
|
{ |
2906 |
|
switch (error) |
2907 |
|
{ |
2908 |
|
case ENOMEM: |
2909 |
|
LT_DLMUTEX_SETERROR (LT_DLSTRERROR (NO_MEMORY)); |
2910 |
|
break; |
2911 |
|
default: |
2912 |
|
LT_DLMUTEX_SETERROR (LT_DLSTRERROR (UNKNOWN)); |
2913 |
|
break; |
2914 |
|
} |
2915 |
|
return 1; |
2916 |
|
} |
2917 |
|
|
2918 |
|
return 0; |
2919 |
|
} |
2920 |
|
|
2921 |
int |
int |
2922 |
lt_argz_insert (pargz, pargz_len, entry) |
lt_argz_insertinorder (pargz, pargz_len, entry) |
2923 |
char **pargz; |
char **pargz; |
2924 |
size_t *pargz_len; |
size_t *pargz_len; |
2925 |
const char *entry; |
const char *entry; |
2938 |
if (cmp < 0) break; |
if (cmp < 0) break; |
2939 |
if (cmp == 0) return 0; /* No duplicates! */ |
if (cmp == 0) return 0; /* No duplicates! */ |
2940 |
} |
} |
|
|
|
|
{ |
|
|
error_t error; |
|
|
|
|
|
if ((error = argz_insert (pargz, pargz_len, before, entry))) |
|
|
{ |
|
|
switch (error) |
|
|
{ |
|
|
case ENOMEM: |
|
|
LT_DLMUTEX_SETERROR (LT_DLSTRERROR (NO_MEMORY)); |
|
|
break; |
|
|
default: |
|
|
LT_DLMUTEX_SETERROR (LT_DLSTRERROR (UNKNOWN)); |
|
|
break; |
|
|
} |
|
|
return 1; |
|
|
} |
|
|
} |
|
2941 |
|
|
2942 |
return 0; |
return lt_argz_insert (pargz, pargz_len, before, entry); |
2943 |
} |
} |
2944 |
|
|
2945 |
int |
int |
3000 |
buf[buf_len] = LT_EOS_CHAR; |
buf[buf_len] = LT_EOS_CHAR; |
3001 |
|
|
3002 |
/* Try to insert (in order) into ARGZ/ARGZ_LEN. */ |
/* Try to insert (in order) into ARGZ/ARGZ_LEN. */ |
3003 |
if (lt_argz_insert (pargz, pargz_len, buf) != 0) |
if (lt_argz_insertinorder (pargz, pargz_len, buf) != 0) |
3004 |
++errors; |
++errors; |
3005 |
|
|
3006 |
LT_DLFREE (buf); |
LT_DLFREE (buf); |
3300 |
} |
} |
3301 |
|
|
3302 |
int |
int |
3303 |
lt_dladdsearchdir (search_dir) |
lt_dlpath_insertdir (ppath, before, dir) |
3304 |
const char *search_dir; |
char **ppath; |
3305 |
|
char *before; |
3306 |
|
const char *dir; |
3307 |
{ |
{ |
3308 |
int errors = 0; |
int errors = 0; |
3309 |
|
char *canonical = 0; |
3310 |
|
char *argz = 0; |
3311 |
|
size_t argz_len = 0; |
3312 |
|
|
3313 |
if (!search_dir || !LT_STRLEN(search_dir)) |
assert (ppath); |
3314 |
|
assert (dir && *dir); |
3315 |
|
|
3316 |
|
if (canonicalize_path (dir, &canonical) != 0) |
3317 |
{ |
{ |
3318 |
return errors; |
++errors; |
3319 |
|
goto cleanup; |
3320 |
} |
} |
3321 |
|
|
3322 |
LT_DLMUTEX_LOCK (); |
assert (canonical && *canonical); |
3323 |
if (!user_search_path) |
|
3324 |
|
/* If *PPATH is empty, set it to DIR. */ |
3325 |
|
if (*ppath == 0) |
3326 |
{ |
{ |
3327 |
user_search_path = lt_estrdup (search_dir); |
assert (!before); /* BEFORE cannot be set without PPATH. */ |
3328 |
if (!user_search_path) |
assert (dir); /* Without DIR, don't call this function! */ |
3329 |
|
|
3330 |
|
*ppath = lt_estrdup (dir); |
3331 |
|
if (*ppath == 0) |
3332 |
++errors; |
++errors; |
3333 |
|
|
3334 |
|
return errors; |
3335 |
} |
} |
3336 |
else |
|
3337 |
|
assert (ppath && *ppath); |
3338 |
|
|
3339 |
|
if (argzize_path (*ppath, &argz, &argz_len) != 0) |
3340 |
{ |
{ |
3341 |
size_t len = LT_STRLEN (user_search_path) + 1 + LT_STRLEN (search_dir); |
++errors; |
3342 |
char *new_search_path = LT_EMALLOC (char, 1+ len); |
goto cleanup; |
3343 |
|
} |
3344 |
|
|
3345 |
|
/* Convert BEFORE into an equivalent offset into ARGZ. This only works |
3346 |
|
if *PPATH is already canonicalized, and hence does not change length |
3347 |
|
with respect to ARGZ. We canonicalize each entry as it is added to |
3348 |
|
the search path, and don't call this function with (uncanonicalized) |
3349 |
|
user paths, so this is a fair assumption. */ |
3350 |
|
if (before) |
3351 |
|
{ |
3352 |
|
assert (*ppath <= before); |
3353 |
|
assert (before - *ppath <= strlen (*ppath)); |
3354 |
|
|
3355 |
|
before = before - *ppath + argz; |
3356 |
|
} |
3357 |
|
|
3358 |
|
if (lt_argz_insert (&argz, &argz_len, before, dir) != 0) |
3359 |
|
{ |
3360 |
|
++errors; |
3361 |
|
goto cleanup; |
3362 |
|
} |
3363 |
|
|
3364 |
|
argz_stringify (argz, argz_len, LT_PATHSEP_CHAR); |
3365 |
|
LT_DLMEM_REASSIGN (*ppath, argz); |
3366 |
|
|
3367 |
|
cleanup: |
3368 |
|
LT_DLFREE (canonical); |
3369 |
|
LT_DLFREE (argz); |
3370 |
|
|
3371 |
if (!new_search_path) |
return errors; |
3372 |
|
} |
3373 |
|
|
3374 |
|
int |
3375 |
|
lt_dladdsearchdir (search_dir) |
3376 |
|
const char *search_dir; |
3377 |
|
{ |
3378 |
|
int errors = 0; |
3379 |
|
|
3380 |
|
if (search_dir && *search_dir) |
3381 |
|
{ |
3382 |
|
LT_DLMUTEX_LOCK (); |
3383 |
|
if (lt_dlpath_insertdir (&user_search_path, 0, search_dir) != 0) |
3384 |
|
++errors; |
3385 |
|
LT_DLMUTEX_UNLOCK (); |
3386 |
|
} |
3387 |
|
|
3388 |
|
return errors; |
3389 |
|
} |
3390 |
|
|
3391 |
|
int |
3392 |
|
lt_dlinsertsearchdir (before, search_dir) |
3393 |
|
const char *before; |
3394 |
|
const char *search_dir; |
3395 |
|
{ |
3396 |
|
int errors = 0; |
3397 |
|
|
3398 |
|
if (before) |
3399 |
|
{ |
3400 |
|
LT_DLMUTEX_LOCK (); |
3401 |
|
if ((before < user_search_path) |
3402 |
|
|| (before >= LT_STRLEN (user_search_path))) |
3403 |
{ |
{ |
3404 |
++errors; |
LT_DLMUTEX_UNLOCK (); |
3405 |
|
LT_DLMUTEX_SETERROR (LT_DLSTRERROR (INVALID_POSITION)); |
3406 |
|
return 1; |
3407 |
} |
} |
3408 |
else |
LT_DLMUTEX_UNLOCK (); |
3409 |
{ |
} |
|
sprintf (new_search_path, "%s%c%s", user_search_path, |
|
|
LT_PATHSEP_CHAR, search_dir); |
|
3410 |
|
|
3411 |
LT_DLMEM_REASSIGN (user_search_path, new_search_path); |
if (search_dir && *search_dir) |
3412 |
|
{ |
3413 |
|
LT_DLMUTEX_LOCK (); |
3414 |
|
if (lt_dlpath_insertdir (&user_search_path, |
3415 |
|
(char *) before, search_dir) != 0) |
3416 |
|
{ |
3417 |
|
++errors; |
3418 |
} |
} |
3419 |
|
LT_DLMUTEX_UNLOCK (); |
3420 |
} |
} |
|
LT_DLMUTEX_UNLOCK (); |
|
3421 |
|
|
3422 |
return errors; |
return errors; |
3423 |
} |
} |
3426 |
lt_dlsetsearchpath (search_path) |
lt_dlsetsearchpath (search_path) |
3427 |
const char *search_path; |
const char *search_path; |
3428 |
{ |
{ |
3429 |
int errors = 0; |
int errors = 0; |
3430 |
|
|
3431 |
LT_DLMUTEX_LOCK (); |
LT_DLMUTEX_LOCK (); |
3432 |
LT_DLFREE (user_search_path); |
LT_DLFREE (user_search_path); |
3438 |
} |
} |
3439 |
|
|
3440 |
LT_DLMUTEX_LOCK (); |
LT_DLMUTEX_LOCK (); |
3441 |
user_search_path = lt_estrdup (search_path); |
if (canonicalize_path (search_path, &user_search_path) != 0) |
|
if (!user_search_path) |
|
3442 |
++errors; |
++errors; |
3443 |
LT_DLMUTEX_UNLOCK (); |
LT_DLMUTEX_UNLOCK (); |
3444 |
|
|