← Back to branch summary

~clint-fewbar/ubuntu/precise/erlang/merge-15b

« back to all changes in this revision

Viewing changes to erts/emulator/sys/unix/erl_unix_sys_ddll.c

  • Committer: Elliot Murphy
  • Date: 2009-12-22 02:56:21 UTC
  • mfrom: (3.3.5 sid)
  • Revision ID: elliot@elliotmurphy.com-20091222025621-qv3rja8gbpiabkbe
Tags: 1:13.b.3-dfsg-2ubuntu1
* Merge with Debian testing; remaining Ubuntu changes:
  - Drop libwxgtk2.8-dev build dependency. Wx isn't in main, and not
    supposed to. (LP #438365)
  - Drop erlang-wx binary.
  - Drop erlang-wx dependency from -megaco, -common-test, and -reltool, they
    do not really need wx. Also drop it from -debugger; the GUI needs wx,
    but it apparently has CLI bits as well, and is also needed by -megaco,
    so let's keep the package for now.
* Fixed dialyzer(1) manpage which was placed into section 3 and conflicted
  with dialyzer(3erl).
* New upstream release (it adds a new binary package erlang-erl-docgen).
* Refreshed patches, removed most of emacs.patch which is applied upstream.
* Linked run_test binary from erlang-common-test package to /usr/bin.
* Fixed VCS headers in debian/control.
* Moved from prebuilt manpages to generated from sources. This adds
  erlang-manpages binary package and xsltproc build dependency.

Show diffs side-by-side

added added

removed removed

Lines of Context:
erts/emulator/sys/unix/erl_unix_sys_ddll.c
49
49
static int num_errcodes = 0;
50
50
static int num_errcodes_allocated = 0;
51
51
 
 
52
#define my_strdup(WHAT) my_strdup_in(ERTS_ALC_T_DDLL_ERRCODES, WHAT);
52
53
 
53
 
static char *my_strdup(char *what)
 
54
static char *my_strdup_in(ErtsAlcType_t type, char *what)
54
55
{
55
 
    char *res = erts_alloc(ERTS_ALC_T_DDLL_ERRCODES, strlen(what) + 1);
 
56
    char *res = erts_alloc(type, strlen(what) + 1);
56
57
    strcpy(res, what);
57
58
    return res;
58
59
}
59
60
 
60
 
static int find_errcode(char *string) 
 
61
 
 
62
static int find_errcode(char *string, ErtsSysDdllError* err) 
61
63
{
62
64
    int i;
63
65
 
 
66
    if (err != NULL) {
 
67
        erts_sys_ddll_free_error(err); /* in case we ignored an earlier error */
 
68
        err->str = my_strdup_in(ERTS_ALC_T_DDLL_TMP_BUF, string);
 
69
        return 0;
 
70
    }
64
71
    for(i=0;i<num_errcodes;++i) {
65
72
        if (!strcmp(string, errcodes[i])) {
66
73
            return i;
94
101
/* 
95
102
 * Open a shared object
96
103
 */
97
 
int erts_sys_ddll_open(char *full_name, void **handle)
 
104
int erts_sys_ddll_open2(char *full_name, void **handle, ErtsSysDdllError* err)
98
105
{
99
106
#if defined(HAVE_DLOPEN)
100
 
    char dlname[MAX_NAME_LEN+1];
101
 
    int len;
 
107
    char* dlname; 
 
108
    int len = sys_strlen(full_name);
 
109
    int ret;
102
110
    
103
 
    if ((len = sys_strlen(full_name)) >= MAX_NAME_LEN-EXT_LEN) {
104
 
        return ERL_DE_LOAD_ERROR_NAME_TO_LONG;
105
 
    }
 
111
    dlname = erts_alloc(ERTS_ALC_T_TMP, len + EXT_LEN + 1);
106
112
    sys_strcpy(dlname, full_name);
107
113
    sys_strcpy(dlname+len, FILE_EXT);
108
114
    
109
 
    return erts_sys_ddll_open_noext(dlname, handle);
 
115
    ret = erts_sys_ddll_open_noext(dlname, handle, err);
 
116
 
 
117
    erts_free(ERTS_ALC_T_TMP, (void *) dlname);
 
118
    return ret;
110
119
#else
111
120
    return ERL_DE_ERROR_NO_DDLL_FUNCTIONALITY;
112
121
#endif
113
122
}
114
123
 
115
 
int erts_sys_ddll_open_noext(char *dlname, void **handle)
 
124
int erts_sys_ddll_open_noext(char *dlname, void **handle, ErtsSysDdllError* err)
116
125
{
117
126
    int ret = ERL_DE_NO_ERROR;
118
127
    char *str;
120
129
    if ((*handle = dlopen(dlname, RTLD_NOW)) == NULL) {
121
130
        str = dlerror();
122
131
 
123
 
        /*
124
 
         * Remove prefix filename to avoid exploading number of
125
 
         * error codes on extreme usage.
126
 
         */
127
 
        if (strstr(str,dlname) == str) {
128
 
            char *save_str = str;
129
 
            str += strlen(dlname);
130
 
            while (*str == ':' || *str == ' ') {
131
 
                ++str;
132
 
            }
133
 
            if (*str == '\0') { /* Better with filename than nothing... */
134
 
                str = save_str;
 
132
        if (err == NULL) {
 
133
            /*
 
134
             * Remove prefix filename to avoid exploading number of
 
135
             * error codes on extreme usage.
 
136
             */
 
137
            if (strstr(str,dlname) == str) {
 
138
                char *save_str = str;
 
139
                str += strlen(dlname);
 
140
                while (*str == ':' || *str == ' ') {
 
141
                    ++str;
 
142
                }
 
143
                if (*str == '\0') { /* Better with filename than nothing... */
 
144
                    str = save_str;
 
145
                }
135
146
            }
136
147
        }
137
 
        ret = ERL_DE_DYNAMIC_ERROR_OFFSET - find_errcode(str);
 
148
        ret = ERL_DE_DYNAMIC_ERROR_OFFSET - find_errcode(str, err);
138
149
    }
139
150
    return ret;
140
151
}
142
153
/* 
143
154
 * Find a symbol in the shared object
144
155
 */
145
 
int erts_sys_ddll_sym(void *handle, char *func_name, void **function)
 
156
int erts_sys_ddll_sym2(void *handle, char *func_name, void **function,
 
157
                       ErtsSysDdllError* err)
146
158
{
147
159
#if defined(HAVE_DLOPEN)
148
160
    void *sym;
151
163
    dlerror();
152
164
    sym = dlsym(handle, func_name);
153
165
    if ((e = dlerror()) != NULL) {
154
 
        ret = ERL_DE_DYNAMIC_ERROR_OFFSET - find_errcode(e);
 
166
        ret = ERL_DE_DYNAMIC_ERROR_OFFSET - find_errcode(e, err);
155
167
    } else {
156
168
        *function = sym;
157
169
        ret = ERL_DE_NO_ERROR;
172
184
{
173
185
    void *fn;
174
186
    int res;
175
 
    if ((res = erts_sys_ddll_sym(handle, "driver_init", &fn)) != ERL_DE_NO_ERROR) {
176
 
        res = erts_sys_ddll_sym(handle, "_driver_init", &fn);
 
187
    if ((res = erts_sys_ddll_sym2(handle, "driver_init", &fn, NULL)) != ERL_DE_NO_ERROR) {
 
188
        res = erts_sys_ddll_sym2(handle, "_driver_init", &fn, NULL);
 
189
    }
 
190
    if (res == ERL_DE_NO_ERROR) {
 
191
        *function = fn;
 
192
    }
 
193
    return res;
 
194
}
 
195
 
 
196
int erts_sys_ddll_load_nif_init(void *handle, void **function, ErtsSysDdllError* err)
 
197
{
 
198
    void *fn;
 
199
    int res;
 
200
    if ((res = erts_sys_ddll_sym2(handle, "nif_init", &fn, err)) != ERL_DE_NO_ERROR) {
 
201
        res = erts_sys_ddll_sym2(handle, "_nif_init", &fn, err);
177
202
    }
178
203
    if (res == ERL_DE_NO_ERROR) {
179
204
        *function = fn;
188
213
    void *(*initfn)(void) = function;
189
214
    return (*initfn)();
190
215
}
 
216
void *erts_sys_ddll_call_nif_init(void *function) {
 
217
    return erts_sys_ddll_call_init(function);
 
218
}
 
219
 
191
220
 
192
221
 
193
222
/* 
194
223
 * Close a chared object
195
224
 */
196
 
int erts_sys_ddll_close(void *handle)
 
225
int erts_sys_ddll_close2(void *handle, ErtsSysDdllError* err)
197
226
{
198
227
#if defined(HAVE_DLOPEN)
199
228
    int ret;
203
232
        ret = ERL_DE_NO_ERROR;
204
233
    } else {
205
234
        if ((s = dlerror()) == NULL) {
 
235
            find_errcode("unspecified error", err);
206
236
            ret = ERL_DE_ERROR_UNSPECIFIED;
207
237
        } else {
208
 
            ret = ERL_DE_DYNAMIC_ERROR_OFFSET - find_errcode(s);
 
238
            ret = ERL_DE_DYNAMIC_ERROR_OFFSET - find_errcode(s, err);
209
239
        }
210
240
    }
211
241
    return ret;
240
270
#endif
241
271
    return "no error";
242
272
}
 
273
 
 
274
void erts_sys_ddll_free_error(ErtsSysDdllError* err)
 
275
{   
 
276
    if (err->str != NULL) {
 
277
        erts_free(ERTS_ALC_T_DDLL_TMP_BUF, err->str);
 
278
    }
 
279
}
 
280