Mercurial > hg > nginx
comparison src/core/ngx_inet.c @ 2203:8e5bf1bc87e2
*) refactor ngx_parse_inet_url()
*) refactor ngx_parse_unix_domain_url()
*) delete unused ngx_url_t fields
author | Igor Sysoev <igor@sysoev.ru> |
---|---|
date | Tue, 26 Aug 2008 14:24:14 +0000 |
parents | 2300ab9b069e |
children | 6ea36910aa57 |
comparison
equal
deleted
inserted
replaced
2202:2300ab9b069e | 2203:8e5bf1bc87e2 |
---|---|
177 | 177 |
178 static ngx_int_t | 178 static ngx_int_t |
179 ngx_parse_unix_domain_url(ngx_pool_t *pool, ngx_url_t *u) | 179 ngx_parse_unix_domain_url(ngx_pool_t *pool, ngx_url_t *u) |
180 { | 180 { |
181 #if (NGX_HAVE_UNIX_DOMAIN) | 181 #if (NGX_HAVE_UNIX_DOMAIN) |
182 u_char *p; | 182 u_char *path, *uri, *last; |
183 size_t len; | 183 size_t len; |
184 ngx_uint_t i; | |
185 struct sockaddr_un *saun; | 184 struct sockaddr_un *saun; |
186 | 185 |
187 len = u->url.len; | 186 len = u->url.len; |
188 p = u->url.data; | 187 path = u->url.data; |
189 | 188 |
190 p += 5; | 189 path += 5; |
191 len -= 5; | 190 len -= 5; |
192 | 191 |
193 u->uri.len = len; | |
194 u->uri.data = p; | |
195 | |
196 if (u->uri_part) { | 192 if (u->uri_part) { |
197 for (i = 0; i < len; i++) { | 193 |
198 | 194 last = path + len; |
199 if (p[i] == ':') { | 195 uri = ngx_strlchr(path, last, ':'); |
200 len = i; | 196 |
201 | 197 if (uri) { |
202 u->uri.len -= len + 1; | 198 len = uri - path; |
203 u->uri.data += len + 1; | 199 uri++; |
204 | 200 u->uri.len = last - uri; |
205 break; | 201 u->uri.data = uri; |
206 } | |
207 } | 202 } |
208 } | 203 } |
209 | 204 |
210 if (len == 0) { | 205 if (len == 0) { |
211 u->err = "no path in the unix domain socket"; | 206 u->err = "no path in the unix domain socket"; |
212 return NGX_ERROR; | 207 return NGX_ERROR; |
213 } | 208 } |
214 | 209 |
215 if (len + 1 > sizeof(saun->sun_path)) { | 210 u->host.len = len++; |
211 u->host.data = path; | |
212 u->family = AF_UNIX; | |
213 | |
214 if (len > sizeof(saun->sun_path)) { | |
216 u->err = "too long path in the unix domain socket"; | 215 u->err = "too long path in the unix domain socket"; |
217 return NGX_ERROR; | 216 return NGX_ERROR; |
218 } | 217 } |
219 | 218 |
220 u->addrs = ngx_pcalloc(pool, sizeof(ngx_peer_addr_t)); | 219 u->addrs = ngx_pcalloc(pool, sizeof(ngx_peer_addr_t)); |
228 } | 227 } |
229 | 228 |
230 u->naddrs = 1; | 229 u->naddrs = 1; |
231 | 230 |
232 saun->sun_family = AF_UNIX; | 231 saun->sun_family = AF_UNIX; |
233 (void) ngx_cpystrn((u_char *) saun->sun_path, p, len + 1); | 232 (void) ngx_cpystrn((u_char *) saun->sun_path, path, len); |
234 | 233 |
235 u->addrs[0].sockaddr = (struct sockaddr *) saun; | 234 u->addrs[0].sockaddr = (struct sockaddr *) saun; |
236 u->addrs[0].socklen = sizeof(struct sockaddr_un); | 235 u->addrs[0].socklen = sizeof(struct sockaddr_un); |
237 u->addrs[0].name.len = len + 5; | 236 u->addrs[0].name.len = len + 4; |
238 u->addrs[0].name.data = u->url.data; | 237 u->addrs[0].name.data = u->url.data; |
239 | |
240 u->host.len = len; | |
241 u->host.data = p; | |
242 | |
243 u->unix_socket = 1; | |
244 | 238 |
245 return NGX_OK; | 239 return NGX_OK; |
246 | 240 |
247 #else | 241 #else |
248 | 242 |
255 | 249 |
256 | 250 |
257 static ngx_int_t | 251 static ngx_int_t |
258 ngx_parse_inet_url(ngx_pool_t *pool, ngx_url_t *u) | 252 ngx_parse_inet_url(ngx_pool_t *pool, ngx_url_t *u) |
259 { | 253 { |
260 u_char *p, *host, *port_start; | 254 u_char *p, *host, *port, *last, *uri; |
261 size_t len, port_len; | 255 size_t len; |
262 ngx_int_t port; | 256 ngx_int_t n; |
263 ngx_uint_t i; | |
264 struct hostent *h; | 257 struct hostent *h; |
265 | 258 |
266 len = u->url.len; | 259 host = u->url.data; |
267 p = u->url.data; | 260 |
268 | 261 last = host + u->url.len; |
269 u->host.data = p; | 262 |
270 | 263 port = ngx_strlchr(host, last, ':'); |
271 port_start = NULL; | 264 |
272 port_len = 0; | 265 uri = ngx_strlchr(port ? port : host, last, '/'); |
273 | 266 |
274 for (i = 0; i < len; i++) { | 267 if (uri) { |
275 | 268 if (u->listen || !u->uri_part) { |
276 if (p[i] == ':') { | 269 u->err = "invalid host"; |
277 port_start = &p[i + 1]; | 270 return NGX_ERROR; |
278 u->host.len = i; | 271 } |
279 | 272 |
280 if (!u->uri_part) { | 273 u->uri.len = last - uri; |
281 port_len = len - (i + 1); | 274 u->uri.data = uri; |
282 break; | 275 |
276 last = uri; | |
277 } | |
278 | |
279 if (port) { | |
280 port++; | |
281 | |
282 if (last - port == 0) { | |
283 u->err = "invalid port"; | |
284 return NGX_ERROR; | |
285 } | |
286 | |
287 u->port_text.len = last - port; | |
288 u->port_text.data = port; | |
289 | |
290 last = port - 1; | |
291 | |
292 } else { | |
293 if (uri == NULL) { | |
294 | |
295 if (u->listen) { | |
296 | |
297 /* test value as port only */ | |
298 | |
299 n = ngx_atoi(host, last - host); | |
300 | |
301 if (n != NGX_ERROR) { | |
302 | |
303 if (n < 1 || n > 65536) { | |
304 u->err = "invalid port"; | |
305 return NGX_ERROR; | |
306 } | |
307 | |
308 u->port = (in_port_t) n; | |
309 | |
310 u->port_text.len = last - host; | |
311 u->port_text.data = host; | |
312 | |
313 return NGX_OK; | |
314 } | |
283 } | 315 } |
284 } | 316 } |
285 | 317 |
286 if (p[i] == '/') { | 318 u->no_port = 1; |
287 u->uri.len = len - i; | 319 } |
288 u->uri.data = &p[i]; | 320 |
289 | 321 len = last - host; |
290 if (u->host.len == 0) { | 322 |
291 u->host.len = i; | 323 if (len == 0) { |
292 } | 324 u->err = "no host"; |
293 | 325 return NGX_ERROR; |
294 if (port_start == NULL) { | 326 } |
295 u->no_port = 1; | 327 |
296 goto no_port; | 328 if (len == 1 && *host == '*') { |
297 } | 329 len = 0; |
298 | 330 } |
299 port_len = &p[i] - port_start; | 331 |
300 | 332 u->host.len = len; |
301 if (port_len == 0) { | 333 u->host.data = host; |
302 u->err = "invalid port"; | 334 |
335 if (len++) { | |
336 | |
337 p = ngx_alloc(len, pool->log); | |
338 if (p == NULL) { | |
339 return NGX_ERROR; | |
340 } | |
341 | |
342 (void) ngx_cpystrn(p, host, len); | |
343 | |
344 u->addr.in_addr = inet_addr((const char *) p); | |
345 | |
346 if (u->addr.in_addr == INADDR_NONE) { | |
347 h = gethostbyname((const char *) p); | |
348 | |
349 if (h == NULL || h->h_addr_list[0] == NULL) { | |
350 ngx_free(p); | |
351 u->err = "host not found"; | |
303 return NGX_ERROR; | 352 return NGX_ERROR; |
304 } | 353 } |
305 | 354 |
306 break; | 355 u->addr.in_addr = *(in_addr_t *) (h->h_addr_list[0]); |
307 } | 356 } |
308 } | 357 |
309 | 358 ngx_free(p); |
310 if (port_start) { | 359 |
311 | 360 } else { |
312 if (port_len == 0) { | 361 u->addr.in_addr = INADDR_ANY; |
313 port_len = &p[i] - port_start; | 362 } |
314 | 363 |
315 if (port_len == 0) { | 364 if (u->port_text.len) { |
316 u->err = "invalid port"; | 365 |
317 return NGX_ERROR; | 366 n = ngx_atoi(u->port_text.data, u->port_text.len); |
318 } | 367 |
319 } | 368 if (n < 1 || n > 65536) { |
320 | |
321 port = ngx_atoi(port_start, port_len); | |
322 | |
323 if (port == NGX_ERROR || port < 1 || port > 65536) { | |
324 u->err = "invalid port"; | 369 u->err = "invalid port"; |
325 return NGX_ERROR; | 370 return NGX_ERROR; |
326 } | 371 } |
327 | 372 |
328 u->port_text.len = port_len; | 373 u->port = (in_port_t) n; |
329 u->port_text.data = port_start; | 374 } |
330 | 375 |
331 } else { | 376 u->family = AF_INET; |
332 port = ngx_atoi(p, len); | |
333 | |
334 if (port == NGX_ERROR) { | |
335 u->host.len = len; | |
336 u->no_port = 1; | |
337 | |
338 goto no_port; | |
339 } | |
340 | |
341 u->wildcard = 1; | |
342 } | |
343 | |
344 u->port = (in_port_t) port; | |
345 | |
346 no_port: | |
347 | |
348 if (u->listen) { | |
349 | |
350 if (u->port == 0) { | |
351 if (u->default_port == 0) { | |
352 u->err = "no port"; | |
353 return NGX_ERROR; | |
354 } | |
355 | |
356 u->port = u->default_port; | |
357 } | |
358 | |
359 if (u->host.len == 1 && u->host.data[0] == '*') { | |
360 u->host.len = 0; | |
361 } | |
362 | |
363 /* AF_INET only */ | |
364 | |
365 if (u->host.len) { | |
366 | |
367 host = ngx_alloc(u->host.len + 1, pool->log); | |
368 if (host == NULL) { | |
369 return NGX_ERROR; | |
370 } | |
371 | |
372 (void) ngx_cpystrn(host, u->host.data, u->host.len + 1); | |
373 | |
374 u->addr.in_addr = inet_addr((const char *) host); | |
375 | |
376 if (u->addr.in_addr == INADDR_NONE) { | |
377 h = gethostbyname((const char *) host); | |
378 | |
379 if (h == NULL || h->h_addr_list[0] == NULL) { | |
380 ngx_free(host); | |
381 u->err = "host not found"; | |
382 return NGX_ERROR; | |
383 } | |
384 | |
385 u->addr.in_addr = *(in_addr_t *) (h->h_addr_list[0]); | |
386 } | |
387 | |
388 ngx_free(host); | |
389 | |
390 } else { | |
391 u->addr.in_addr = INADDR_ANY; | |
392 } | |
393 | |
394 return NGX_OK; | |
395 } | |
396 | |
397 if (u->host.len == 0) { | |
398 u->err = "no host"; | |
399 return NGX_ERROR; | |
400 } | |
401 | 377 |
402 if (u->no_resolve) { | 378 if (u->no_resolve) { |
403 return NGX_OK; | 379 return NGX_OK; |
404 } | 380 } |
405 | 381 |
406 if (u->no_port) { | 382 if (u->no_port) { |
407 u->port = u->default_port; | 383 u->port = u->default_port; |
408 } | 384 } |
409 | 385 |
410 if (u->port == 0) { | 386 if (u->listen) { |
411 u->err = "no port"; | 387 return NGX_OK; |
412 return NGX_ERROR; | |
413 } | 388 } |
414 | 389 |
415 if (ngx_inet_resolve_host(pool, u) != NGX_OK) { | 390 if (ngx_inet_resolve_host(pool, u) != NGX_OK) { |
416 return NGX_ERROR; | 391 return NGX_ERROR; |
417 } | 392 } |