1 /* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
2 * Permission is hereby granted, free of charge, to any person obtaining a copy
3 * of this software and associated documentation files (the "Software"), to
4 * deal in the Software without restriction, including without limitation the
5 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
6 * sell copies of the Software, and to permit persons to whom the Software is
7 * furnished to do so, subject to the following conditions:
8 *
9 * The above copyright notice and this permission notice shall be included in
10 * all copies or substantial portions of the Software.
11 *
12 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
13 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
14 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
15 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
16 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
17 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
18 * IN THE SOFTWARE.
19 */
20
21 /* Expose glibc-specific EAI_* error codes. Needs to be defined before we
22 * include any headers.
23 */
24
25 #include "uv.h"
26 #include "internal.h"
27 #include "idna.h"
28
29 #include <errno.h>
30 #include <stddef.h> /* NULL */
31 #include <stdlib.h>
32 #include <string.h>
33 #include <net/if.h> /* if_indextoname() */
34
35 /* EAI_* constants. */
36 #include <netdb.h>
37
38
uv__getaddrinfo_translate_error(int sys_err)39 int uv__getaddrinfo_translate_error(int sys_err) {
40 switch (sys_err) {
41 case 0: return 0;
42 #if defined(EAI_ADDRFAMILY)
43 case EAI_ADDRFAMILY: return UV_EAI_ADDRFAMILY;
44 #endif
45 #if defined(EAI_AGAIN)
46 case EAI_AGAIN: return UV_EAI_AGAIN;
47 #endif
48 #if defined(EAI_BADFLAGS)
49 case EAI_BADFLAGS: return UV_EAI_BADFLAGS;
50 #endif
51 #if defined(EAI_BADHINTS)
52 case EAI_BADHINTS: return UV_EAI_BADHINTS;
53 #endif
54 #if defined(EAI_CANCELED)
55 case EAI_CANCELED: return UV_EAI_CANCELED;
56 #endif
57 #if defined(EAI_FAIL)
58 case EAI_FAIL: return UV_EAI_FAIL;
59 #endif
60 #if defined(EAI_FAMILY)
61 case EAI_FAMILY: return UV_EAI_FAMILY;
62 #endif
63 #if defined(EAI_MEMORY)
64 case EAI_MEMORY: return UV_EAI_MEMORY;
65 #endif
66 #if defined(EAI_NODATA)
67 case EAI_NODATA: return UV_EAI_NODATA;
68 #endif
69 #if defined(EAI_NONAME)
70 # if !defined(EAI_NODATA) || EAI_NODATA != EAI_NONAME
71 case EAI_NONAME: return UV_EAI_NONAME;
72 # endif
73 #endif
74 #if defined(EAI_OVERFLOW)
75 case EAI_OVERFLOW: return UV_EAI_OVERFLOW;
76 #endif
77 #if defined(EAI_PROTOCOL)
78 case EAI_PROTOCOL: return UV_EAI_PROTOCOL;
79 #endif
80 #if defined(EAI_SERVICE)
81 case EAI_SERVICE: return UV_EAI_SERVICE;
82 #endif
83 #if defined(EAI_SOCKTYPE)
84 case EAI_SOCKTYPE: return UV_EAI_SOCKTYPE;
85 #endif
86 #if defined(EAI_SYSTEM)
87 case EAI_SYSTEM: return UV__ERR(errno);
88 #endif
89 }
90 assert(0 && "unknown EAI_* error code");
91 abort();
92 #ifndef __SUNPRO_C
93 return 0; /* Pacify compiler. */
94 #endif
95 }
96
97
98 #ifdef USE_FFRT
uv__getaddrinfo_work(struct uv__work * w,int qos)99 static void uv__getaddrinfo_work(struct uv__work* w, int qos) {
100 #else
101 static void uv__getaddrinfo_work(struct uv__work* w) {
102 #endif
103 uv_getaddrinfo_t* req;
104 int err;
105
106 req = container_of(w, uv_getaddrinfo_t, work_req);
107 err = getaddrinfo(req->hostname, req->service, req->hints, &req->addrinfo);
108 req->retcode = uv__getaddrinfo_translate_error(err);
109 #ifdef USE_FFRT
110 if (qos != -1) {
111 uv__work_submit_to_eventloop((uv_req_t*)req, w, qos);
112 }
113 #endif
114 }
115
116
117 static void uv__getaddrinfo_done(struct uv__work* w, int status) {
118 uv_getaddrinfo_t* req;
119
120 req = container_of(w, uv_getaddrinfo_t, work_req);
121 uv__req_unregister(req->loop, req);
122
123 /* See initialization in uv_getaddrinfo(). */
124 if (req->hints)
125 uv__free(req->hints);
126 else if (req->service)
127 uv__free(req->service);
128 else if (req->hostname)
129 uv__free(req->hostname);
130 else
131 assert(0);
132
133 req->hints = NULL;
134 req->service = NULL;
135 req->hostname = NULL;
136
137 if (status == UV_ECANCELED) {
138 assert(req->retcode == 0);
139 req->retcode = UV_EAI_CANCELED;
140 }
141
142 if (req->cb)
143 req->cb(req, req->retcode, req->addrinfo);
144 }
145
146
147 int uv_getaddrinfo(uv_loop_t* loop,
148 uv_getaddrinfo_t* req,
149 uv_getaddrinfo_cb cb,
150 const char* hostname,
151 const char* service,
152 const struct addrinfo* hints) {
153 char hostname_ascii[256];
154 size_t hostname_len;
155 size_t service_len;
156 size_t hints_len;
157 size_t len;
158 char* buf;
159 long rc;
160
161 if (req == NULL || (hostname == NULL && service == NULL))
162 return UV_EINVAL;
163
164 /* FIXME(bnoordhuis) IDNA does not seem to work z/OS,
165 * probably because it uses EBCDIC rather than ASCII.
166 */
167 #ifdef __MVS__
168 (void) &hostname_ascii;
169 #else
170 if (hostname != NULL) {
171 rc = uv__idna_toascii(hostname,
172 hostname + strlen(hostname),
173 hostname_ascii,
174 hostname_ascii + sizeof(hostname_ascii));
175 if (rc < 0)
176 return rc;
177 hostname = hostname_ascii;
178 }
179 #endif
180
181 hostname_len = hostname ? strlen(hostname) + 1 : 0;
182 service_len = service ? strlen(service) + 1 : 0;
183 hints_len = hints ? sizeof(*hints) : 0;
184 buf = uv__malloc(hostname_len + service_len + hints_len);
185
186 if (buf == NULL)
187 return UV_ENOMEM;
188
189 uv__req_init(loop, req, UV_GETADDRINFO);
190 req->loop = loop;
191 req->cb = cb;
192 req->addrinfo = NULL;
193 req->hints = NULL;
194 req->service = NULL;
195 req->hostname = NULL;
196 req->retcode = 0;
197
198 /* order matters, see uv_getaddrinfo_done() */
199 len = 0;
200
201 if (hints) {
202 req->hints = memcpy(buf + len, hints, sizeof(*hints));
203 len += sizeof(*hints);
204 }
205
206 if (service) {
207 req->service = memcpy(buf + len, service, service_len);
208 len += service_len;
209 }
210
211 if (hostname)
212 req->hostname = memcpy(buf + len, hostname, hostname_len);
213
214 if (cb) {
215 uv__work_submit(loop,
216 #ifdef USE_FFRT
217 (uv_req_t*)req,
218 #endif
219 &req->work_req,
220 UV__WORK_SLOW_IO,
221 uv__getaddrinfo_work,
222 uv__getaddrinfo_done);
223 return 0;
224 } else {
225 #ifdef USE_FFRT
226 uv__getaddrinfo_work(&req->work_req, -1);
227 #else
228 uv__getaddrinfo_work(&req->work_req);
229 #endif
230 uv__getaddrinfo_done(&req->work_req, 0);
231 return req->retcode;
232 }
233 }
234
235
236 void uv_freeaddrinfo(struct addrinfo* ai) {
237 if (ai)
238 freeaddrinfo(ai);
239 }
240
241
242 int uv_if_indextoname(unsigned int ifindex, char* buffer, size_t* size) {
243 char ifname_buf[UV_IF_NAMESIZE];
244 size_t len;
245
246 if (buffer == NULL || size == NULL || *size == 0)
247 return UV_EINVAL;
248
249 if (if_indextoname(ifindex, ifname_buf) == NULL)
250 return UV__ERR(errno);
251
252 len = strnlen(ifname_buf, sizeof(ifname_buf));
253
254 if (*size <= len) {
255 *size = len + 1;
256 return UV_ENOBUFS;
257 }
258
259 memcpy(buffer, ifname_buf, len);
260 buffer[len] = '\0';
261 *size = len;
262
263 return 0;
264 }
265
266 int uv_if_indextoiid(unsigned int ifindex, char* buffer, size_t* size) {
267 return uv_if_indextoname(ifindex, buffer, size);
268 }
269