Mercurial > hg > nginx

comparison src/core/ngx_resolver.c @ 6559:adf25b8d0431

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Introduced the ngx_sockaddr_t type. It's properly aligned and can hold any supported sockaddr.
author Ruslan Ermilov <ru@nginx.com>
date Mon, 23 May 2016 16:37:20 +0300
parents 7640d6c213e1
children b3b7e33083ac
comparison
equal deleted inserted replaced
6558:68854ce64ec7 6559:adf25b8d0431
2990 2990
2991 2991
2992 static void 2992 static void
2993 ngx_resolver_srv_names_handler(ngx_resolver_ctx_t *cctx) 2993 ngx_resolver_srv_names_handler(ngx_resolver_ctx_t *cctx)
2994 { 2994 {
2995 ngx_uint_t i; 2995 ngx_uint_t i;
2996 u_char (*sockaddr)[NGX_SOCKADDRLEN]; 2996 ngx_addr_t *addrs;
2997 ngx_addr_t *addrs; 2997 ngx_resolver_t *r;
2998 ngx_resolver_t *r; 2998 ngx_sockaddr_t *sockaddr;
2999 struct sockaddr_in *sin; 2999 struct sockaddr_in *sin;
3000 ngx_resolver_ctx_t *ctx; 3000 ngx_resolver_ctx_t *ctx;
3001 ngx_resolver_srv_name_t *srv; 3001 ngx_resolver_srv_name_t *srv;
3002 #if (NGX_HAVE_INET6) 3002 #if (NGX_HAVE_INET6)
3003 struct sockaddr_in6 *sin6; 3003 struct sockaddr_in6 *sin6;
3004 #endif 3004 #endif
3005 3005
3006 r = cctx->resolver; 3006 r = cctx->resolver;
3007 ctx = cctx->data; 3007 ctx = cctx->data;
3008 srv = cctx->srvs; 3008 srv = cctx->srvs;
3024 3024
3025 ctx->handler(ctx); 3025 ctx->handler(ctx);
3026 return; 3026 return;
3027 } 3027 }
3028 3028
3029 sockaddr = ngx_resolver_alloc(r, cctx->naddrs * NGX_SOCKADDRLEN); 3029 sockaddr = ngx_resolver_alloc(r, cctx->naddrs * sizeof(ngx_sockaddr_t));
3030 if (sockaddr == NULL) { 3030 if (sockaddr == NULL) {
3031 ngx_resolver_free(r, addrs); 3031 ngx_resolver_free(r, addrs);
3032 ngx_resolve_name_done(cctx); 3032 ngx_resolve_name_done(cctx);
3033 3033
3034 ctx->state = NGX_ERROR; 3034 ctx->state = NGX_ERROR;
3037 ctx->handler(ctx); 3037 ctx->handler(ctx);
3038 return; 3038 return;
3039 } 3039 }
3040 3040
3041 for (i = 0; i < cctx->naddrs; i++) { 3041 for (i = 0; i < cctx->naddrs; i++) {
3042 addrs[i].sockaddr = (struct sockaddr *) sockaddr[i]; 3042 addrs[i].sockaddr = &sockaddr[i].sockaddr;
3043 addrs[i].socklen = cctx->addrs[i].socklen; 3043 addrs[i].socklen = cctx->addrs[i].socklen;
3044 3044
3045 ngx_memcpy(sockaddr[i], cctx->addrs[i].sockaddr, 3045 ngx_memcpy(&sockaddr[i], cctx->addrs[i].sockaddr,
3046 addrs[i].socklen); 3046 addrs[i].socklen);
3047 3047
3048 switch (addrs[i].sockaddr->sa_family) { 3048 switch (addrs[i].sockaddr->sa_family) {
3049 #if (NGX_HAVE_INET6) 3049 #if (NGX_HAVE_INET6)
3050 case AF_INET6: 3050 case AF_INET6:
4159 4159
4160 static ngx_resolver_addr_t * 4160 static ngx_resolver_addr_t *
4161 ngx_resolver_export(ngx_resolver_t *r, ngx_resolver_node_t *rn, 4161 ngx_resolver_export(ngx_resolver_t *r, ngx_resolver_node_t *rn,
4162 ngx_uint_t rotate) 4162 ngx_uint_t rotate)
4163 { 4163 {
4164 ngx_uint_t d, i, j, n; 4164 ngx_uint_t d, i, j, n;
4165 u_char (*sockaddr)[NGX_SOCKADDRLEN]; 4165 in_addr_t *addr;
4166 in_addr_t *addr; 4166 ngx_sockaddr_t *sockaddr;
4167 struct sockaddr_in *sin; 4167 struct sockaddr_in *sin;
4168 ngx_resolver_addr_t *dst; 4168 ngx_resolver_addr_t *dst;
4169 #if (NGX_HAVE_INET6) 4169 #if (NGX_HAVE_INET6)
4170 struct in6_addr *addr6; 4170 struct in6_addr *addr6;
4171 struct sockaddr_in6 *sin6; 4171 struct sockaddr_in6 *sin6;
4172 #endif 4172 #endif
4173 4173
4174 n = rn->naddrs; 4174 n = rn->naddrs;
4175 #if (NGX_HAVE_INET6) 4175 #if (NGX_HAVE_INET6)
4176 n += rn->naddrs6; 4176 n += rn->naddrs6;
4179 dst = ngx_resolver_calloc(r, n * sizeof(ngx_resolver_addr_t)); 4179 dst = ngx_resolver_calloc(r, n * sizeof(ngx_resolver_addr_t));
4180 if (dst == NULL) { 4180 if (dst == NULL) {
4181 return NULL; 4181 return NULL;
4182 } 4182 }
4183 4183
4184 sockaddr = ngx_resolver_calloc(r, n * NGX_SOCKADDRLEN); 4184 sockaddr = ngx_resolver_calloc(r, n * sizeof(ngx_sockaddr_t));
4185 if (sockaddr == NULL) { 4185 if (sockaddr == NULL) {
4186 ngx_resolver_free(r, dst); 4186 ngx_resolver_free(r, dst);
4187 return NULL; 4187 return NULL;
4188 } 4188 }
4189 4189
4194 j = rotate ? ngx_random() % rn->naddrs : 0; 4194 j = rotate ? ngx_random() % rn->naddrs : 0;
4195 4195
4196 addr = (rn->naddrs == 1) ? &rn->u.addr : rn->u.addrs; 4196 addr = (rn->naddrs == 1) ? &rn->u.addr : rn->u.addrs;
4197 4197
4198 do { 4198 do {
4199 sin = (struct sockaddr_in *) sockaddr[d]; 4199 sin = &sockaddr[d].sockaddr_in;
4200 sin->sin_family = AF_INET; 4200 sin->sin_family = AF_INET;
4201 sin->sin_addr.s_addr = addr[j++]; 4201 sin->sin_addr.s_addr = addr[j++];
4202 dst[d].sockaddr = (struct sockaddr *) sin; 4202 dst[d].sockaddr = (struct sockaddr *) sin;
4203 dst[d++].socklen = sizeof(struct sockaddr_in); 4203 dst[d++].socklen = sizeof(struct sockaddr_in);
4204 4204
4217 j = rotate ? ngx_random() % rn->naddrs6 : 0; 4217 j = rotate ? ngx_random() % rn->naddrs6 : 0;
4218 4218
4219 addr6 = (rn->naddrs6 == 1) ? &rn->u6.addr6 : rn->u6.addrs6; 4219 addr6 = (rn->naddrs6 == 1) ? &rn->u6.addr6 : rn->u6.addrs6;
4220 4220
4221 do { 4221 do {
4222 sin6 = (struct sockaddr_in6 *) sockaddr[d]; 4222 sin6 = &sockaddr[d].sockaddr_in6;
4223 sin6->sin6_family = AF_INET6; 4223 sin6->sin6_family = AF_INET6;
4224 ngx_memcpy(sin6->sin6_addr.s6_addr, addr6[j++].s6_addr, 16); 4224 ngx_memcpy(sin6->sin6_addr.s6_addr, addr6[j++].s6_addr, 16);
4225 dst[d].sockaddr = (struct sockaddr *) sin6; 4225 dst[d].sockaddr = (struct sockaddr *) sin6;
4226 dst[d++].socklen = sizeof(struct sockaddr_in6); 4226 dst[d++].socklen = sizeof(struct sockaddr_in6);
4227 4227