Mercurial > hg > nginx-vendor-0-8
comparison src/core/ngx_inet.c @ 0:f0b350454894 NGINX_0_1_0
nginx 0.1.0
*) The first public version.
author | Igor Sysoev <http://sysoev.ru> |
---|---|
date | Mon, 04 Oct 2004 00:00:00 +0400 |
parents | |
children | 46833bd150cb |
comparison
equal
deleted
inserted
replaced
-1:000000000000 | 0:f0b350454894 |
---|---|
1 | |
2 /* | |
3 * Copyright (C) Igor Sysoev | |
4 */ | |
5 | |
6 | |
7 | |
8 #include <ngx_config.h> | |
9 #include <ngx_core.h> | |
10 | |
11 | |
12 ngx_inline static size_t ngx_sprint_uchar(u_char *text, u_char c, size_t len) | |
13 { | |
14 size_t n; | |
15 ngx_uint_t c1, c2; | |
16 | |
17 n = 0; | |
18 | |
19 if (len == n) { | |
20 return n; | |
21 } | |
22 | |
23 c1 = c / 100; | |
24 | |
25 if (c1) { | |
26 *text++ = (u_char) (c1 + '0'); | |
27 n++; | |
28 | |
29 if (len == n) { | |
30 return n; | |
31 } | |
32 } | |
33 | |
34 c2 = (c % 100) / 10; | |
35 | |
36 if (c1 || c2) { | |
37 *text++ = (u_char) (c2 + '0'); | |
38 n++; | |
39 | |
40 if (len == n) { | |
41 return n; | |
42 } | |
43 } | |
44 | |
45 c2 = c % 10; | |
46 | |
47 *text++ = (u_char) (c2 + '0'); | |
48 n++; | |
49 | |
50 return n; | |
51 } | |
52 | |
53 | |
54 /* AF_INET only */ | |
55 | |
56 size_t ngx_sock_ntop(int family, struct sockaddr *addr, u_char *text, | |
57 size_t len) | |
58 { | |
59 u_char *p; | |
60 size_t n; | |
61 ngx_uint_t i; | |
62 struct sockaddr_in *addr_in; | |
63 | |
64 if (len == 0) { | |
65 return 0; | |
66 } | |
67 | |
68 if (family != AF_INET) { | |
69 return 0; | |
70 } | |
71 | |
72 addr_in = (struct sockaddr_in *) addr; | |
73 p = (u_char *) &addr_in->sin_addr; | |
74 | |
75 if (len > INET_ADDRSTRLEN) { | |
76 len = INET_ADDRSTRLEN; | |
77 } | |
78 | |
79 n = ngx_sprint_uchar(text, p[0], len); | |
80 | |
81 i = 1; | |
82 | |
83 do { | |
84 if (len == n) { | |
85 text[n - 1] = '\0'; | |
86 return n; | |
87 } | |
88 | |
89 text[n++] = '.'; | |
90 | |
91 if (len == n) { | |
92 text[n - 1] = '\0'; | |
93 return n; | |
94 } | |
95 | |
96 n += ngx_sprint_uchar(&text[n], p[i++], len - n); | |
97 | |
98 } while (i < 4); | |
99 | |
100 if (len == n) { | |
101 text[n] = '\0'; | |
102 return n; | |
103 } | |
104 | |
105 text[n] = '\0'; | |
106 | |
107 return n; | |
108 | |
109 #if 0 | |
110 return ngx_snprintf((char *) text, | |
111 len > INET_ADDRSTRLEN ? INET_ADDRSTRLEN : len, | |
112 "%u.%u.%u.%u", p[0], p[1], p[2], p[3]); | |
113 #endif | |
114 } | |
115 | |
116 | |
117 size_t ngx_inet_ntop(int family, void *addr, u_char *text, size_t len) | |
118 { | |
119 u_char *p; | |
120 size_t n; | |
121 ngx_uint_t i; | |
122 | |
123 if (len == 0) { | |
124 return 0; | |
125 } | |
126 | |
127 if (family != AF_INET) { | |
128 return 0; | |
129 } | |
130 | |
131 p = (u_char *) addr; | |
132 | |
133 if (len > INET_ADDRSTRLEN) { | |
134 len = INET_ADDRSTRLEN; | |
135 } | |
136 | |
137 n = ngx_sprint_uchar(text, p[0], len); | |
138 | |
139 i = 1; | |
140 | |
141 do { | |
142 if (len == n) { | |
143 text[n - 1] = '\0'; | |
144 return n; | |
145 } | |
146 | |
147 text[n++] = '.'; | |
148 | |
149 if (len == n) { | |
150 text[n - 1] = '\0'; | |
151 return n; | |
152 } | |
153 | |
154 n += ngx_sprint_uchar(&text[n], p[i++], len - n); | |
155 | |
156 } while (i < 4); | |
157 | |
158 if (len == n) { | |
159 text[n] = '\0'; | |
160 return n; | |
161 } | |
162 | |
163 text[n] = '\0'; | |
164 | |
165 return n; | |
166 | |
167 #if 0 | |
168 return ngx_snprintf((char *) text, | |
169 len > INET_ADDRSTRLEN ? INET_ADDRSTRLEN : len, | |
170 "%u.%u.%u.%u", p[0], p[1], p[2], p[3]); | |
171 #endif | |
172 } | |
173 | |
174 | |
175 /* AF_INET only */ | |
176 | |
177 ngx_int_t ngx_ptocidr(ngx_str_t *text, void *cidr) | |
178 { | |
179 ngx_int_t m; | |
180 ngx_uint_t i; | |
181 ngx_inet_cidr_t *in_cidr; | |
182 | |
183 in_cidr = cidr; | |
184 | |
185 for (i = 0; i < text->len; i++) { | |
186 if (text->data[i] == '/') { | |
187 break; | |
188 } | |
189 } | |
190 | |
191 if (i == text->len) { | |
192 return NGX_ERROR; | |
193 } | |
194 | |
195 text->data[i] = '\0'; | |
196 in_cidr->addr = inet_addr((char *) text->data); | |
197 text->data[i] = '/'; | |
198 if (in_cidr->addr == INADDR_NONE) { | |
199 return NGX_ERROR; | |
200 } | |
201 | |
202 m = ngx_atoi(&text->data[i + 1], text->len - (i + 1)); | |
203 if (m == NGX_ERROR) { | |
204 return NGX_ERROR; | |
205 } | |
206 | |
207 if (m == 0) { | |
208 | |
209 /* the x86 compilers use the shl instruction that shifts by modulo 32 */ | |
210 | |
211 in_cidr->mask = 0; | |
212 return NGX_OK; | |
213 } | |
214 | |
215 in_cidr->mask = htonl((ngx_uint_t) (0 - (1 << (32 - m)))); | |
216 | |
217 return NGX_OK; | |
218 } | |
219 | |
220 | |
221 #if 0 | |
222 | |
223 ngx_int_t ngx_inet_addr_port(ngx_conf_t *cf, ngx_command_t *cmd, | |
224 ngx_str_t *addr_port) | |
225 { | |
226 u_char *host; | |
227 ngx_int_t port; | |
228 ngx_uint_t p; | |
229 struct hostent *h; | |
230 | |
231 for (p = 0; p < addr_port->len; p++) { | |
232 if (addr_port->data[p] == ':') { | |
233 break; | |
234 } | |
235 } | |
236 | |
237 in_addr->host.len = p; | |
238 if (!(in_addr->host.data = ngx_palloc(pool, p + 1))) { | |
239 return NGX_ERROR; | |
240 } | |
241 | |
242 ngx_cpystrn(in_addr->host.data, addr_port->data, p + 1); | |
243 | |
244 if (p == addr_port->len) { | |
245 p = 0; | |
246 } | |
247 | |
248 port = ngx_atoi(&addr[p], args[1].len - p); | |
249 if (port == NGX_ERROR && p == 0) { | |
250 | |
251 /* default port */ | |
252 iap->port = 0; | |
253 | |
254 } else if ((port == NGX_ERROR && p != 0) /* "listen host:NONNUMBER" */ | |
255 || (port < 1 || port > 65536)) { /* "listen 99999" */ | |
256 | |
257 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, | |
258 "invalid port \"%s\" in \"%s\" directive, " | |
259 "it must be a number between 1 and 65535", | |
260 &addr[p], cmd->name.data); | |
261 | |
262 return NGX_CONF_ERROR; | |
263 | |
264 } else if (p == 0) { | |
265 ls->addr = INADDR_ANY; | |
266 ls->port = (in_port_t) port; | |
267 return NGX_CONF_OK; | |
268 } | |
269 | |
270 return NGX_OK; | |
271 } | |
272 | |
273 #endif |