summaryrefslogtreecommitdiff
path: root/src/lib/libcrypto/bio/b_sock.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/lib/libcrypto/bio/b_sock.c')
-rw-r--r--src/lib/libcrypto/bio/b_sock.c1025
1 files changed, 503 insertions, 522 deletions
diff --git a/src/lib/libcrypto/bio/b_sock.c b/src/lib/libcrypto/bio/b_sock.c
index bd43307456..d739452580 100644
--- a/src/lib/libcrypto/bio/b_sock.c
+++ b/src/lib/libcrypto/bio/b_sock.c
@@ -85,7 +85,7 @@ NETDB_DEFINE_CONTEXT
85#endif 85#endif
86 86
87#if defined(OPENSSL_SYS_WINDOWS) || (defined(OPENSSL_SYS_NETWARE) && !defined(NETWARE_BSDSOCK)) 87#if defined(OPENSSL_SYS_WINDOWS) || (defined(OPENSSL_SYS_NETWARE) && !defined(NETWARE_BSDSOCK))
88static int wsa_init_done=0; 88static int wsa_init_done = 0;
89#endif 89#endif
90 90
91/* 91/*
@@ -100,36 +100,36 @@ static int wsa_init_done=0;
100#endif 100#endif
101 101
102#if 0 102#if 0
103static unsigned long BIO_ghbn_hits=0L; 103static unsigned long BIO_ghbn_hits = 0L;
104static unsigned long BIO_ghbn_miss=0L; 104static unsigned long BIO_ghbn_miss = 0L;
105 105
106#define GHBN_NUM 4 106#define GHBN_NUM 4
107static struct ghbn_cache_st 107static struct ghbn_cache_st {
108 {
109 char name[129]; 108 char name[129];
110 struct hostent *ent; 109 struct hostent *ent;
111 unsigned long order; 110 unsigned long order;
112 } ghbn_cache[GHBN_NUM]; 111} ghbn_cache[GHBN_NUM];
113#endif 112#endif
114 113
115static int get_ip(const char *str,unsigned char *ip); 114static int get_ip(const char *str, unsigned char *ip);
116#if 0 115#if 0
117static void ghbn_free(struct hostent *a); 116static void ghbn_free(struct hostent *a);
118static struct hostent *ghbn_dup(struct hostent *a); 117static struct hostent *ghbn_dup(struct hostent *a);
119#endif 118#endif
120int BIO_get_host_ip(const char *str, unsigned char *ip) 119
121 { 120int
121BIO_get_host_ip(const char *str, unsigned char *ip)
122{
122 int i; 123 int i;
123 int err = 1; 124 int err = 1;
124 int locked = 0; 125 int locked = 0;
125 struct hostent *he; 126 struct hostent *he;
126 127
127 i=get_ip(str,ip); 128 i = get_ip(str, ip);
128 if (i < 0) 129 if (i < 0) {
129 { 130 BIOerr(BIO_F_BIO_GET_HOST_IP, BIO_R_INVALID_IP_ADDRESS);
130 BIOerr(BIO_F_BIO_GET_HOST_IP,BIO_R_INVALID_IP_ADDRESS);
131 goto err; 131 goto err;
132 } 132 }
133 133
134 /* At this point, we have something that is most probably correct 134 /* At this point, we have something that is most probably correct
135 in some way, so let's init the socket. */ 135 in some way, so let's init the socket. */
@@ -138,172 +138,169 @@ int BIO_get_host_ip(const char *str, unsigned char *ip)
138 138
139 /* If the string actually contained an IP address, we need not do 139 /* If the string actually contained an IP address, we need not do
140 anything more */ 140 anything more */
141 if (i > 0) return(1); 141 if (i > 0)
142 return (1);
142 143
143 /* do a gethostbyname */ 144 /* do a gethostbyname */
144 CRYPTO_w_lock(CRYPTO_LOCK_GETHOSTBYNAME); 145 CRYPTO_w_lock(CRYPTO_LOCK_GETHOSTBYNAME);
145 locked = 1; 146 locked = 1;
146 he=BIO_gethostbyname(str); 147 he = BIO_gethostbyname(str);
147 if (he == NULL) 148 if (he == NULL) {
148 { 149 BIOerr(BIO_F_BIO_GET_HOST_IP, BIO_R_BAD_HOSTNAME_LOOKUP);
149 BIOerr(BIO_F_BIO_GET_HOST_IP,BIO_R_BAD_HOSTNAME_LOOKUP);
150 goto err; 150 goto err;
151 } 151 }
152 152
153 /* cast to short because of win16 winsock definition */ 153 /* cast to short because of win16 winsock definition */
154 if ((short)he->h_addrtype != AF_INET) 154 if ((short)he->h_addrtype != AF_INET) {
155 { 155 BIOerr(BIO_F_BIO_GET_HOST_IP, BIO_R_GETHOSTBYNAME_ADDR_IS_NOT_AF_INET);
156 BIOerr(BIO_F_BIO_GET_HOST_IP,BIO_R_GETHOSTBYNAME_ADDR_IS_NOT_AF_INET);
157 goto err; 156 goto err;
158 } 157 }
159 for (i=0; i<4; i++) 158 for (i = 0; i < 4; i++)
160 ip[i]=he->h_addr_list[0][i]; 159 ip[i] = he->h_addr_list[0][i];
161 err = 0; 160 err = 0;
162 161
163 err: 162err:
164 if (locked) 163 if (locked)
165 CRYPTO_w_unlock(CRYPTO_LOCK_GETHOSTBYNAME); 164 CRYPTO_w_unlock(CRYPTO_LOCK_GETHOSTBYNAME);
166 if (err) 165 if (err) {
167 { 166 ERR_add_error_data(2, "host=", str);
168 ERR_add_error_data(2,"host=",str);
169 return 0; 167 return 0;
170 } 168 } else
171 else
172 return 1; 169 return 1;
173 } 170}
174 171
175int BIO_get_port(const char *str, unsigned short *port_ptr) 172int
176 { 173BIO_get_port(const char *str, unsigned short *port_ptr)
174{
177 int i; 175 int i;
178 struct servent *s; 176 struct servent *s;
179 177
180 if (str == NULL) 178 if (str == NULL) {
181 { 179 BIOerr(BIO_F_BIO_GET_PORT, BIO_R_NO_PORT_DEFINED);
182 BIOerr(BIO_F_BIO_GET_PORT,BIO_R_NO_PORT_DEFINED); 180 return (0);
183 return(0); 181 }
184 } 182 i = atoi(str);
185 i=atoi(str);
186 if (i != 0) 183 if (i != 0)
187 *port_ptr=(unsigned short)i; 184 *port_ptr = (unsigned short)i;
188 else 185 else {
189 {
190 CRYPTO_w_lock(CRYPTO_LOCK_GETSERVBYNAME); 186 CRYPTO_w_lock(CRYPTO_LOCK_GETSERVBYNAME);
191 /* Note: under VMS with SOCKETSHR, it seems like the first 187 /* Note: under VMS with SOCKETSHR, it seems like the first
192 * parameter is 'char *', instead of 'const char *' 188 * parameter is 'char *', instead of 'const char *'
193 */ 189 */
194#ifndef CONST_STRICT 190#ifndef CONST_STRICT
195 s=getservbyname((char *)str,"tcp"); 191 s = getservbyname((char *)str, "tcp");
196#else 192#else
197 s=getservbyname(str,"tcp"); 193 s = getservbyname(str, "tcp");
198#endif 194#endif
199 if(s != NULL) 195 if (s != NULL)
200 *port_ptr=ntohs((unsigned short)s->s_port); 196 *port_ptr = ntohs((unsigned short)s->s_port);
201 CRYPTO_w_unlock(CRYPTO_LOCK_GETSERVBYNAME); 197 CRYPTO_w_unlock(CRYPTO_LOCK_GETSERVBYNAME);
202 if(s == NULL) 198 if (s == NULL) {
203 { 199 if (strcmp(str, "http") == 0)
204 if (strcmp(str,"http") == 0) 200 *port_ptr = 80;
205 *port_ptr=80; 201 else if (strcmp(str, "telnet") == 0)
206 else if (strcmp(str,"telnet") == 0) 202 *port_ptr = 23;
207 *port_ptr=23; 203 else if (strcmp(str, "socks") == 0)
208 else if (strcmp(str,"socks") == 0) 204 *port_ptr = 1080;
209 *port_ptr=1080; 205 else if (strcmp(str, "https") == 0)
210 else if (strcmp(str,"https") == 0) 206 *port_ptr = 443;
211 *port_ptr=443; 207 else if (strcmp(str, "ssl") == 0)
212 else if (strcmp(str,"ssl") == 0) 208 *port_ptr = 443;
213 *port_ptr=443; 209 else if (strcmp(str, "ftp") == 0)
214 else if (strcmp(str,"ftp") == 0) 210 *port_ptr = 21;
215 *port_ptr=21; 211 else if (strcmp(str, "gopher") == 0)
216 else if (strcmp(str,"gopher") == 0) 212 *port_ptr = 70;
217 *port_ptr=70;
218#if 0 213#if 0
219 else if (strcmp(str,"wais") == 0) 214 else if (strcmp(str, "wais") == 0)
220 *port_ptr=21; 215 *port_ptr = 21;
221#endif 216#endif
222 else 217 else {
223 { 218 SYSerr(SYS_F_GETSERVBYNAME, errno);
224 SYSerr(SYS_F_GETSERVBYNAME,errno); 219 ERR_add_error_data(3, "service = '", str, "'");
225 ERR_add_error_data(3,"service='",str,"'"); 220 return (0);
226 return(0);
227 }
228 } 221 }
229 } 222 }
230 return(1);
231 } 223 }
224 return (1);
225}
232 226
233int BIO_sock_error(int sock) 227int
234 { 228BIO_sock_error(int sock)
235 int j,i; 229{
230 int j, i;
236 int size; 231 int size;
237 232
238#if defined(OPENSSL_SYS_BEOS_R5) 233#if defined(OPENSSL_SYS_BEOS_R5)
239 return 0; 234 return 0;
240#endif 235#endif
241 236
242 size=sizeof(int); 237 size = sizeof(int);
243 /* Note: under Windows the third parameter is of type (char *) 238 /* Note: under Windows the third parameter is of type (char *)
244 * whereas under other systems it is (void *) if you don't have 239 * whereas under other systems it is (void *) if you don't have
245 * a cast it will choke the compiler: if you do have a cast then 240 * a cast it will choke the compiler: if you do have a cast then
246 * you can either go for (char *) or (void *). 241 * you can either go for (char *) or (void *).
247 */ 242 */
248 i=getsockopt(sock,SOL_SOCKET,SO_ERROR,(void *)&j,(void *)&size); 243 i = getsockopt(sock, SOL_SOCKET, SO_ERROR,(void *)&j,(void *)&size);
249 if (i < 0) 244 if (i < 0)
250 return(1); 245 return (1);
251 else 246 else
252 return(j); 247 return (j);
253 } 248}
254 249
255#if 0 250#if 0
256long BIO_ghbn_ctrl(int cmd, int iarg, char *parg) 251long
257 { 252BIO_ghbn_ctrl(int cmd, int iarg, char *parg)
253{
258 int i; 254 int i;
259 char **p; 255 char **p;
260 256
261 switch (cmd) 257 switch (cmd) {
262 {
263 case BIO_GHBN_CTRL_HITS: 258 case BIO_GHBN_CTRL_HITS:
264 return(BIO_ghbn_hits); 259 return (BIO_ghbn_hits);
265 /* break; */ 260 /* break; */
266 case BIO_GHBN_CTRL_MISSES: 261 case BIO_GHBN_CTRL_MISSES:
267 return(BIO_ghbn_miss); 262 return (BIO_ghbn_miss);
268 /* break; */ 263 /* break; */
269 case BIO_GHBN_CTRL_CACHE_SIZE: 264 case BIO_GHBN_CTRL_CACHE_SIZE:
270 return(GHBN_NUM); 265 return (GHBN_NUM);
271 /* break; */ 266 /* break; */
272 case BIO_GHBN_CTRL_GET_ENTRY: 267 case BIO_GHBN_CTRL_GET_ENTRY:
273 if ((iarg >= 0) && (iarg <GHBN_NUM) && 268 if ((iarg >= 0) && (iarg < GHBN_NUM) &&
274 (ghbn_cache[iarg].order > 0)) 269 (ghbn_cache[iarg].order > 0)) {
275 { 270 p = (char **)parg;
276 p=(char **)parg; 271 if (p == NULL)
277 if (p == NULL) return(0); 272 return (0);
278 *p=ghbn_cache[iarg].name; 273 *p = ghbn_cache[iarg].name;
279 ghbn_cache[iarg].name[128]='\0'; 274 ghbn_cache[iarg].name[128] = '\0';
280 return(1); 275 return (1);
281 } 276 }
282 return(0); 277 return (0);
283 /* break; */ 278 /* break; */
284 case BIO_GHBN_CTRL_FLUSH: 279 case BIO_GHBN_CTRL_FLUSH:
285 for (i=0; i<GHBN_NUM; i++) 280 for (i = 0; i < GHBN_NUM; i++)
286 ghbn_cache[i].order=0; 281 ghbn_cache[i].order = 0;
287 break; 282 break;
288 default: 283 default:
289 return(0); 284 return (0);
290 }
291 return(1);
292 } 285 }
286 return (1);
287}
293#endif 288#endif
294 289
295#if 0 290#if 0
296static struct hostent *ghbn_dup(struct hostent *a) 291static struct hostent
297 { 292*ghbn_dup(struct hostent *a)
293{
298 struct hostent *ret; 294 struct hostent *ret;
299 int i,j; 295 int i, j;
300 296
301 MemCheck_off(); 297 MemCheck_off();
302 ret=(struct hostent *)OPENSSL_malloc(sizeof(struct hostent)); 298 ret = (struct hostent *)OPENSSL_malloc(sizeof(struct hostent));
303 if (ret == NULL) return(NULL); 299 if (ret == NULL)
304 memset(ret,0,sizeof(struct hostent)); 300 return (NULL);
301 memset(ret, 0, sizeof(struct hostent));
305 302
306 for (i=0; a->h_aliases[i] != NULL; i++) 303 for (i = 0; a->h_aliases[i] != NULL; i++)
307 ; 304 ;
308 i++; 305 i++;
309 ret->h_aliases = (char **)OPENSSL_malloc(i*sizeof(char *)); 306 ret->h_aliases = (char **)OPENSSL_malloc(i*sizeof(char *));
@@ -311,69 +308,66 @@ static struct hostent *ghbn_dup(struct hostent *a)
311 goto err; 308 goto err;
312 memset(ret->h_aliases, 0, i*sizeof(char *)); 309 memset(ret->h_aliases, 0, i*sizeof(char *));
313 310
314 for (i=0; a->h_addr_list[i] != NULL; i++) 311 for (i = 0; a->h_addr_list[i] != NULL; i++)
315 ; 312 ;
316 i++; 313 i++;
317 ret->h_addr_list=(char **)OPENSSL_malloc(i*sizeof(char *)); 314 ret->h_addr_list = (char **)OPENSSL_malloc(i*sizeof(char *));
318 if (ret->h_addr_list == NULL) 315 if (ret->h_addr_list == NULL)
319 goto err; 316 goto err;
320 memset(ret->h_addr_list, 0, i*sizeof(char *)); 317 memset(ret->h_addr_list, 0, i*sizeof(char *));
321 318
322 j=strlen(a->h_name)+1; 319 j = strlen(a->h_name) + 1;
323 if ((ret->h_name=OPENSSL_malloc(j)) == NULL) goto err; 320 if ((ret->h_name = OPENSSL_malloc(j)) == NULL) goto err;
324 memcpy((char *)ret->h_name,a->h_name,j); 321 memcpy((char *)ret->h_name, a->h_name, j);
325 for (i=0; a->h_aliases[i] != NULL; i++) 322 for (i = 0; a->h_aliases[i] != NULL; i++) {
326 { 323 j = strlen(a->h_aliases[i]) + 1;
327 j=strlen(a->h_aliases[i])+1; 324 if ((ret->h_aliases[i] = OPENSSL_malloc(j)) == NULL) goto err;
328 if ((ret->h_aliases[i]=OPENSSL_malloc(j)) == NULL) goto err; 325 memcpy(ret->h_aliases[i], a->h_aliases[i], j);
329 memcpy(ret->h_aliases[i],a->h_aliases[i],j); 326 }
330 } 327 ret->h_length = a->h_length;
331 ret->h_length=a->h_length; 328 ret->h_addrtype = a->h_addrtype;
332 ret->h_addrtype=a->h_addrtype; 329 for (i = 0; a->h_addr_list[i] != NULL; i++) {
333 for (i=0; a->h_addr_list[i] != NULL; i++) 330 if ((ret->h_addr_list[i] = OPENSSL_malloc(a->h_length)) == NULL)
334 {
335 if ((ret->h_addr_list[i]=OPENSSL_malloc(a->h_length)) == NULL)
336 goto err; 331 goto err;
337 memcpy(ret->h_addr_list[i],a->h_addr_list[i],a->h_length); 332 memcpy(ret->h_addr_list[i], a->h_addr_list[i], a->h_length);
338 } 333 }
339 if (0) 334 if (0) {
340 { 335err:
341err:
342 if (ret != NULL) 336 if (ret != NULL)
343 ghbn_free(ret); 337 ghbn_free(ret);
344 ret=NULL; 338 ret = NULL;
345 }
346 MemCheck_on();
347 return(ret);
348 } 339 }
340 MemCheck_on();
341 return (ret);
342}
349 343
350static void ghbn_free(struct hostent *a) 344static void
351 { 345ghbn_free(struct hostent *a)
346{
352 int i; 347 int i;
353 348
354 if(a == NULL) 349 if (a == NULL)
355 return; 350 return;
356 351
357 if (a->h_aliases != NULL) 352 if (a->h_aliases != NULL) {
358 { 353 for (i = 0; a->h_aliases[i] != NULL; i++)
359 for (i=0; a->h_aliases[i] != NULL; i++)
360 OPENSSL_free(a->h_aliases[i]); 354 OPENSSL_free(a->h_aliases[i]);
361 OPENSSL_free(a->h_aliases); 355 OPENSSL_free(a->h_aliases);
362 } 356 }
363 if (a->h_addr_list != NULL) 357 if (a->h_addr_list != NULL) {
364 { 358 for (i = 0; a->h_addr_list[i] != NULL; i++)
365 for (i=0; a->h_addr_list[i] != NULL; i++)
366 OPENSSL_free(a->h_addr_list[i]); 359 OPENSSL_free(a->h_addr_list[i]);
367 OPENSSL_free(a->h_addr_list); 360 OPENSSL_free(a->h_addr_list);
368 }
369 if (a->h_name != NULL) OPENSSL_free(a->h_name);
370 OPENSSL_free(a);
371 } 361 }
362 if (a->h_name != NULL)
363 OPENSSL_free(a->h_name);
364 OPENSSL_free(a);
365}
372 366
373#endif 367#endif
374 368
375struct hostent *BIO_gethostbyname(const char *name) 369struct hostent
376 { 370*BIO_gethostbyname(const char *name) {
377#if 1 371#if 1
378 /* Caching gethostbyname() results forever is wrong, 372 /* Caching gethostbyname() results forever is wrong,
379 * so we have to let the true gethostbyname() worry about this */ 373 * so we have to let the true gethostbyname() worry about this */
@@ -384,8 +378,8 @@ struct hostent *BIO_gethostbyname(const char *name)
384#endif 378#endif
385#else 379#else
386 struct hostent *ret; 380 struct hostent *ret;
387 int i,lowi=0,j; 381 int i, lowi = 0, j;
388 unsigned long low= (unsigned long)-1; 382 unsigned long low = (unsigned long) - 1;
389 383
390 384
391# if 0 385# if 0
@@ -395,42 +389,37 @@ struct hostent *BIO_gethostbyname(const char *name)
395 */ 389 */
396 CRYPTO_w_lock(CRYPTO_LOCK_GETHOSTBYNAME); 390 CRYPTO_w_lock(CRYPTO_LOCK_GETHOSTBYNAME);
397# endif 391# endif
398 j=strlen(name); 392 j = strlen(name);
399 if (j < 128) 393 if (j < 128) {
400 { 394 for (i = 0; i < GHBN_NUM; i++) {
401 for (i=0; i<GHBN_NUM; i++) 395 if (low > ghbn_cache[i].order) {
402 { 396 low = ghbn_cache[i].order;
403 if (low > ghbn_cache[i].order) 397 lowi = i;
404 { 398 }
405 low=ghbn_cache[i].order; 399 if (ghbn_cache[i].order > 0) {
406 lowi=i; 400 if (strncmp(name, ghbn_cache[i].name, 128) == 0)
407 }
408 if (ghbn_cache[i].order > 0)
409 {
410 if (strncmp(name,ghbn_cache[i].name,128) == 0)
411 break; 401 break;
412 }
413 } 402 }
414 } 403 }
415 else 404 } else
416 i=GHBN_NUM; 405 i = GHBN_NUM;
417 406
418 if (i == GHBN_NUM) /* no hit*/ 407 if (i == GHBN_NUM) /* no hit*/
419 { 408 {
420 BIO_ghbn_miss++; 409 BIO_ghbn_miss++;
421 /* Note: under VMS with SOCKETSHR, it seems like the first 410 /* Note: under VMS with SOCKETSHR, it seems like the first
422 * parameter is 'char *', instead of 'const char *' 411 * parameter is 'char *', instead of 'const char *'
423 */ 412 */
424# ifndef CONST_STRICT 413# ifndef CONST_STRICT
425 ret=gethostbyname((char *)name); 414 ret = gethostbyname((char *)name);
426# else 415# else
427 ret=gethostbyname(name); 416 ret = gethostbyname(name);
428# endif 417# endif
429 418
430 if (ret == NULL) 419 if (ret == NULL)
431 goto end; 420 goto end;
432 if (j > 128) /* too big to cache */ 421 if (j > 128) /* too big to cache */
433 { 422 {
434# if 0 423# if 0
435 /* If we were trying to make this function thread-safe (which 424 /* If we were trying to make this function thread-safe (which
436 * is bound to fail), we'd have to give up in this case 425 * is bound to fail), we'd have to give up in this case
@@ -438,118 +427,113 @@ struct hostent *BIO_gethostbyname(const char *name)
438 ret = NULL; 427 ret = NULL;
439# endif 428# endif
440 goto end; 429 goto end;
441 } 430 }
442 431
443 /* else add to cache */ 432 /* else add to cache */
444 if (ghbn_cache[lowi].ent != NULL) 433 if (ghbn_cache[lowi].ent != NULL)
445 ghbn_free(ghbn_cache[lowi].ent); /* XXX not thread-safe */ 434 ghbn_free(ghbn_cache[lowi].ent); /* XXX not thread-safe */
446 ghbn_cache[lowi].name[0] = '\0'; 435 ghbn_cache[lowi].name[0] = '\0';
447 436
448 if((ret=ghbn_cache[lowi].ent=ghbn_dup(ret)) == NULL) 437 if ((ret = ghbn_cache[lowi].ent = ghbn_dup(ret)) == NULL) {
449 { 438 BIOerr(BIO_F_BIO_GETHOSTBYNAME, ERR_R_MALLOC_FAILURE);
450 BIOerr(BIO_F_BIO_GETHOSTBYNAME,ERR_R_MALLOC_FAILURE);
451 goto end; 439 goto end;
452 }
453 strncpy(ghbn_cache[lowi].name,name,128);
454 ghbn_cache[lowi].order=BIO_ghbn_miss+BIO_ghbn_hits;
455 } 440 }
456 else 441 strncpy(ghbn_cache[lowi].name, name, 128);
457 { 442 ghbn_cache[lowi].order = BIO_ghbn_miss + BIO_ghbn_hits;
443 } else {
458 BIO_ghbn_hits++; 444 BIO_ghbn_hits++;
459 ret= ghbn_cache[i].ent; 445 ret = ghbn_cache[i].ent;
460 ghbn_cache[i].order=BIO_ghbn_miss+BIO_ghbn_hits; 446 ghbn_cache[i].order = BIO_ghbn_miss + BIO_ghbn_hits;
461 } 447 }
462end: 448end:
463# if 0 449# if 0
464 CRYPTO_w_unlock(CRYPTO_LOCK_GETHOSTBYNAME); 450 CRYPTO_w_unlock(CRYPTO_LOCK_GETHOSTBYNAME);
465# endif 451# endif
466 return(ret); 452 return (ret);
467#endif 453#endif
468 } 454}
469 455
470 456
471int BIO_sock_init(void) 457int
472 { 458BIO_sock_init(void)
459{
473#ifdef OPENSSL_SYS_WINDOWS 460#ifdef OPENSSL_SYS_WINDOWS
474 static struct WSAData wsa_state; 461 static struct WSAData wsa_state;
475 462
476 if (!wsa_init_done) 463 if (!wsa_init_done) {
477 {
478 int err; 464 int err;
479 465
480 wsa_init_done=1; 466 wsa_init_done = 1;
481 memset(&wsa_state,0,sizeof(wsa_state)); 467 memset(&wsa_state, 0, sizeof(wsa_state));
482 /* Not making wsa_state available to the rest of the 468 /* Not making wsa_state available to the rest of the
483 * code is formally wrong. But the structures we use 469 * code is formally wrong. But the structures we use
484 * are [beleived to be] invariable among Winsock DLLs, 470 * are [beleived to be] invariable among Winsock DLLs,
485 * while API availability is [expected to be] probed 471 * while API availability is [expected to be] probed
486 * at run-time with DSO_global_lookup. */ 472 * at run-time with DSO_global_lookup. */
487 if (WSAStartup(0x0202,&wsa_state)!=0) 473 if (WSAStartup(0x0202, &wsa_state) != 0) {
488 { 474 err = WSAGetLastError();
489 err=WSAGetLastError(); 475 SYSerr(SYS_F_WSASTARTUP, err);
490 SYSerr(SYS_F_WSASTARTUP,err); 476 BIOerr(BIO_F_BIO_SOCK_INIT, BIO_R_WSASTARTUP);
491 BIOerr(BIO_F_BIO_SOCK_INIT,BIO_R_WSASTARTUP); 477 return (-1);
492 return(-1);
493 }
494 } 478 }
479 }
495#endif /* OPENSSL_SYS_WINDOWS */ 480#endif /* OPENSSL_SYS_WINDOWS */
496#ifdef WATT32 481#ifdef WATT32
497 extern int _watt_do_exit; 482 extern int _watt_do_exit;
498 _watt_do_exit = 0; /* don't make sock_init() call exit() */ 483 _watt_do_exit = 0;
484 /* don't make sock_init() call exit() */
499 if (sock_init()) 485 if (sock_init())
500 return (-1); 486 return (-1);
501#endif 487#endif
502 488
503#if defined(OPENSSL_SYS_NETWARE) && !defined(NETWARE_BSDSOCK) 489#if defined(OPENSSL_SYS_NETWARE) && !defined(NETWARE_BSDSOCK)
504 WORD wVerReq; 490 WORD wVerReq;
505 WSADATA wsaData; 491 WSADATA wsaData;
506 int err; 492 int err;
507 493
508 if (!wsa_init_done) 494 if (!wsa_init_done) {
509 { 495 wsa_init_done = 1;
510 wsa_init_done=1; 496 wVerReq = MAKEWORD( 2, 0 );
511 wVerReq = MAKEWORD( 2, 0 ); 497 err = WSAStartup(wVerReq, &wsaData);
512 err = WSAStartup(wVerReq,&wsaData); 498 if (err != 0) {
513 if (err != 0) 499 SYSerr(SYS_F_WSASTARTUP, err);
514 { 500 BIOerr(BIO_F_BIO_SOCK_INIT, BIO_R_WSASTARTUP);
515 SYSerr(SYS_F_WSASTARTUP,err); 501 return (-1);
516 BIOerr(BIO_F_BIO_SOCK_INIT,BIO_R_WSASTARTUP);
517 return(-1);
518 }
519 } 502 }
503 }
520#endif 504#endif
521 505
522 return(1); 506 return (1);
523 } 507}
524 508
525void BIO_sock_cleanup(void) 509void
526 { 510BIO_sock_cleanup(void)
511{
527#ifdef OPENSSL_SYS_WINDOWS 512#ifdef OPENSSL_SYS_WINDOWS
528 if (wsa_init_done) 513 if (wsa_init_done) {
529 { 514 wsa_init_done = 0;
530 wsa_init_done=0;
531#if 0 /* this call is claimed to be non-present in Winsock2 */ 515#if 0 /* this call is claimed to be non-present in Winsock2 */
532 WSACancelBlockingCall(); 516 WSACancelBlockingCall();
533#endif 517#endif
534 WSACleanup(); 518 WSACleanup();
535 } 519 }
536#elif defined(OPENSSL_SYS_NETWARE) && !defined(NETWARE_BSDSOCK) 520#elif defined(OPENSSL_SYS_NETWARE) && !defined(NETWARE_BSDSOCK)
537 if (wsa_init_done) 521 if (wsa_init_done) {
538 { 522 wsa_init_done = 0;
539 wsa_init_done=0; 523 WSACleanup();
540 WSACleanup();
541 }
542#endif
543 } 524 }
525#endif
526}
544 527
545#if !defined(OPENSSL_SYS_VMS) || __VMS_VER >= 70000000 528#if !defined(OPENSSL_SYS_VMS) || __VMS_VER >= 70000000
546 529
547int BIO_socket_ioctl(int fd, long type, void *arg) 530int
548 { 531BIO_socket_ioctl(int fd, long type, void *arg)
532{
549 int i; 533 int i;
550 534
551#ifdef __DJGPP__ 535#ifdef __DJGPP__
552 i=ioctl(fd,type,(char *)arg); 536 i = ioctl(fd, type,(char *)arg);
553#else 537#else
554# if defined(OPENSSL_SYS_VMS) 538# if defined(OPENSSL_SYS_VMS)
555 /* 2011-02-18 SMS. 539 /* 2011-02-18 SMS.
@@ -574,402 +558,399 @@ int BIO_socket_ioctl(int fd, long type, void *arg)
574# define ARG arg 558# define ARG arg
575# endif /* defined(OPENSSL_SYS_VMS) [else] */ 559# endif /* defined(OPENSSL_SYS_VMS) [else] */
576 560
577 i=ioctl(fd,type,ARG); 561 i = ioctl(fd, type, ARG);
578#endif /* __DJGPP__ */ 562#endif /* __DJGPP__ */
579 if (i < 0) 563 if (i < 0)
580 SYSerr(SYS_F_IOCTLSOCKET,errno); 564 SYSerr(SYS_F_IOCTLSOCKET, errno);
581 return(i); 565 return (i);
582 } 566}
583#endif /* __VMS_VER */ 567#endif /* __VMS_VER */
584 568
585/* The reason I have implemented this instead of using sscanf is because 569/* The reason I have implemented this instead of using sscanf is because
586 * Visual C 1.52c gives an unresolved external when linking a DLL :-( */ 570 * Visual C 1.52c gives an unresolved external when linking a DLL :-( */
587static int get_ip(const char *str, unsigned char ip[4]) 571static int
588 { 572get_ip(const char *str, unsigned char ip[4])
573{
589 unsigned int tmp[4]; 574 unsigned int tmp[4];
590 int num=0,c,ok=0; 575 int num = 0, c, ok = 0;
591 576
592 tmp[0]=tmp[1]=tmp[2]=tmp[3]=0; 577 tmp[0] = tmp[1] = tmp[2] = tmp[3] = 0;
593 578
594 for (;;) 579 for (;;) {
595 {
596 c= *(str++); 580 c= *(str++);
597 if ((c >= '0') && (c <= '9')) 581 if ((c >= '0') && (c <= '9')) {
598 { 582 ok = 1;
599 ok=1; 583 tmp[num] = tmp[num]*10 + c-'0';
600 tmp[num]=tmp[num]*10+c-'0'; 584 if (tmp[num] > 255)
601 if (tmp[num] > 255) return(0); 585 return (0);
602 } 586 } else if (c == '.') {
603 else if (c == '.') 587 if (!ok)
604 { 588 return (-1);
605 if (!ok) return(-1); 589 if (num == 3)
606 if (num == 3) return(0); 590 return (0);
607 num++; 591 num++;
608 ok=0; 592 ok = 0;
609 } 593 } else if (c == '\0' && (num == 3) && ok)
610 else if (c == '\0' && (num == 3) && ok) 594 break;
611 break;
612 else 595 else
613 return(0); 596 return (0);
614 }
615 ip[0]=tmp[0];
616 ip[1]=tmp[1];
617 ip[2]=tmp[2];
618 ip[3]=tmp[3];
619 return(1);
620 } 597 }
621 598 ip[0] = tmp[0];
622int BIO_get_accept_socket(char *host, int bind_mode) 599 ip[1] = tmp[1];
623 { 600 ip[2] = tmp[2];
624 int ret=0; 601 ip[3] = tmp[3];
602 return (1);
603}
604
605int
606BIO_get_accept_socket(char *host, int bind_mode)
607{
608 int ret = 0;
625 union { 609 union {
626 struct sockaddr sa; 610 struct sockaddr sa;
627 struct sockaddr_in sa_in; 611 struct sockaddr_in sa_in;
628#if OPENSSL_USE_IPV6 612#if OPENSSL_USE_IPV6
629 struct sockaddr_in6 sa_in6; 613 struct sockaddr_in6 sa_in6;
630#endif 614#endif
631 } server,client; 615 } server, client;
632 int s=-1,cs,addrlen; 616 int s = -1, cs, addrlen;
633 unsigned char ip[4]; 617 unsigned char ip[4];
634 unsigned short port; 618 unsigned short port;
635 char *str=NULL,*e; 619 char *str = NULL, *e;
636 char *h,*p; 620 char *h, *p;
637 unsigned long l; 621 unsigned long l;
638 int err_num; 622 int err_num;
639 623
640 if (BIO_sock_init() != 1) return(-1); 624 if (BIO_sock_init() != 1)
625 return (-1);
641 626
642 if ((str=BUF_strdup(host)) == NULL) return(-1); 627 if ((str = BUF_strdup(host)) == NULL)
628 return (-1);
643 629
644 h=p=NULL; 630 h = p = NULL;
645 h=str; 631 h = str;
646 for (e=str; *e; e++) 632 for (e = str; *e; e++) {
647 { 633 if (*e == ':') {
648 if (*e == ':') 634 p = e;
649 { 635 } else if (*e == '/') {
650 p=e; 636 *e = '\0';
651 }
652 else if (*e == '/')
653 {
654 *e='\0';
655 break; 637 break;
656 }
657 } 638 }
658 if (p) *p++='\0'; /* points at last ':', '::port' is special [see below] */ 639 }
659 else p=h,h=NULL; 640 if (p)
641 *p++='\0'; /* points at last ':', '::port' is special [see below] */
642 else
643 p = h, h = NULL;
660 644
661#ifdef EAI_FAMILY 645#ifdef EAI_FAMILY
662 do { 646 do {
663 static union { void *p; 647 static union {
664 int (WSAAPI *f)(const char *,const char *, 648 void *p;
665 const struct addrinfo *, 649 int (WSAAPI *f)(const char *, const char *,
666 struct addrinfo **); 650 const struct addrinfo *,
667 } p_getaddrinfo = {NULL}; 651 struct addrinfo **);
668 static union { void *p; 652 } p_getaddrinfo = {NULL};
653 static union {
654 void *p;
669 void (WSAAPI *f)(struct addrinfo *); 655 void (WSAAPI *f)(struct addrinfo *);
670 } p_freeaddrinfo = {NULL}; 656 } p_freeaddrinfo = {NULL};
671 struct addrinfo *res,hint; 657 struct addrinfo *res, hint;
672 658
673 if (p_getaddrinfo.p==NULL) 659 if (p_getaddrinfo.p == NULL) {
674 { 660 if ((p_getaddrinfo.p = DSO_global_lookup("getaddrinfo"))==NULL ||
675 if ((p_getaddrinfo.p=DSO_global_lookup("getaddrinfo"))==NULL || 661 (p_freeaddrinfo.p = DSO_global_lookup("freeaddrinfo"))==NULL)
676 (p_freeaddrinfo.p=DSO_global_lookup("freeaddrinfo"))==NULL) 662 p_getaddrinfo.p = (void*) - 1;
677 p_getaddrinfo.p=(void*)-1; 663 }
678 } 664 if (p_getaddrinfo.p == (void *) - 1) break;
679 if (p_getaddrinfo.p==(void *)-1) break; 665
680 666 /* '::port' enforces IPv6 wildcard listener. Some OSes,
681 /* '::port' enforces IPv6 wildcard listener. Some OSes, 667 * e.g. Solaris, default to IPv6 without any hint. Also
682 * e.g. Solaris, default to IPv6 without any hint. Also 668 * note that commonly IPv6 wildchard socket can service
683 * note that commonly IPv6 wildchard socket can service 669 * IPv4 connections just as well... */
684 * IPv4 connections just as well... */ 670 memset(&hint, 0, sizeof(hint));
685 memset(&hint,0,sizeof(hint)); 671 hint.ai_flags = AI_PASSIVE;
686 hint.ai_flags = AI_PASSIVE; 672 if (h) {
687 if (h) 673 if (strchr(h, ':')) {
688 { 674 if (h[1] == '\0')
689 if (strchr(h,':')) 675 h = NULL;
690 {
691 if (h[1]=='\0') h=NULL;
692#if OPENSSL_USE_IPV6 676#if OPENSSL_USE_IPV6
693 hint.ai_family = AF_INET6; 677 hint.ai_family = AF_INET6;
694#else 678#else
695 h=NULL; 679 h = NULL;
696#endif 680#endif
697 } 681 } else if (h[0] == '*' && h[1] == '\0') {
698 else if (h[0]=='*' && h[1]=='\0') 682 hint.ai_family = AF_INET;
699 { 683 h = NULL;
700 hint.ai_family = AF_INET;
701 h=NULL;
702 } 684 }
703 } 685 }
704 686
705 if ((*p_getaddrinfo.f)(h,p,&hint,&res)) break; 687 if ((*p_getaddrinfo.f)(h, p, &hint, &res))
688 break;
706 689
707 addrlen = res->ai_addrlen<=sizeof(server) ? 690 addrlen = res->ai_addrlen <= sizeof(server) ?
708 res->ai_addrlen : 691 res->ai_addrlen : sizeof(server);
709 sizeof(server); 692 memcpy(&server, res->ai_addr, addrlen);
710 memcpy(&server, res->ai_addr, addrlen);
711 693
712 (*p_freeaddrinfo.f)(res); 694 (*p_freeaddrinfo.f)(res);
713 goto again; 695 goto again;
714 } while (0); 696 } while (0);
715#endif 697#endif
716 698
717 if (!BIO_get_port(p,&port)) goto err; 699 if (!BIO_get_port(p, &port))
700 goto err;
718 701
719 memset((char *)&server,0,sizeof(server)); 702 memset((char *)&server, 0, sizeof(server));
720 server.sa_in.sin_family=AF_INET; 703 server.sa_in.sin_family = AF_INET;
721 server.sa_in.sin_port=htons(port); 704 server.sa_in.sin_port = htons(port);
722 addrlen = sizeof(server.sa_in); 705 addrlen = sizeof(server.sa_in);
723 706
724 if (h == NULL || strcmp(h,"*") == 0) 707 if (h == NULL || strcmp(h, "*") == 0)
725 server.sa_in.sin_addr.s_addr=INADDR_ANY; 708 server.sa_in.sin_addr.s_addr = INADDR_ANY;
726 else 709 else {
727 { 710 if (!BIO_get_host_ip(h, &(ip[0])))
728 if (!BIO_get_host_ip(h,&(ip[0]))) goto err; 711 goto err;
729 l=(unsigned long) 712 l = (unsigned long)
730 ((unsigned long)ip[0]<<24L)| 713 ((unsigned long)ip[0]<<24L)|
731 ((unsigned long)ip[1]<<16L)| 714 ((unsigned long)ip[1]<<16L)|
732 ((unsigned long)ip[2]<< 8L)| 715 ((unsigned long)ip[2]<< 8L)|
733 ((unsigned long)ip[3]); 716 ((unsigned long)ip[3]);
734 server.sa_in.sin_addr.s_addr=htonl(l); 717 server.sa_in.sin_addr.s_addr = htonl(l);
735 } 718 }
736 719
737again: 720again:
738 s=socket(server.sa.sa_family,SOCK_STREAM,SOCKET_PROTOCOL); 721 s = socket(server.sa.sa_family, SOCK_STREAM, SOCKET_PROTOCOL);
739 if (s == -1) 722 if (s == -1) {
740 { 723 SYSerr(SYS_F_SOCKET, errno);
741 SYSerr(SYS_F_SOCKET,errno); 724 ERR_add_error_data(3, "port = '", host, "'");
742 ERR_add_error_data(3,"port='",host,"'"); 725 BIOerr(BIO_F_BIO_GET_ACCEPT_SOCKET, BIO_R_UNABLE_TO_CREATE_SOCKET);
743 BIOerr(BIO_F_BIO_GET_ACCEPT_SOCKET,BIO_R_UNABLE_TO_CREATE_SOCKET);
744 goto err; 726 goto err;
745 } 727 }
746 728
747#ifdef SO_REUSEADDR 729#ifdef SO_REUSEADDR
748 if (bind_mode == BIO_BIND_REUSEADDR) 730 if (bind_mode == BIO_BIND_REUSEADDR) {
749 { 731 int i = 1;
750 int i=1;
751 732
752 ret=setsockopt(s,SOL_SOCKET,SO_REUSEADDR,(char *)&i,sizeof(i)); 733 ret = setsockopt(s, SOL_SOCKET, SO_REUSEADDR,(char *)&i, sizeof(i));
753 bind_mode=BIO_BIND_NORMAL; 734 bind_mode = BIO_BIND_NORMAL;
754 } 735 }
755#endif 736#endif
756 if (bind(s,&server.sa,addrlen) == -1) 737 if (bind(s, &server.sa, addrlen) == -1) {
757 {
758#ifdef SO_REUSEADDR 738#ifdef SO_REUSEADDR
759 err_num=errno; 739 err_num = errno;
760 if ((bind_mode == BIO_BIND_REUSEADDR_IF_UNUSED) && 740 if ((bind_mode == BIO_BIND_REUSEADDR_IF_UNUSED) &&
761#ifdef OPENSSL_SYS_WINDOWS 741#ifdef OPENSSL_SYS_WINDOWS
762 /* Some versions of Windows define EADDRINUSE to 742 /* Some versions of Windows define EADDRINUSE to
763 * a dummy value. 743 * a dummy value.
764 */ 744 */
765 (err_num == WSAEADDRINUSE)) 745 (err_num == WSAEADDRINUSE))
766#else 746#else
767 (err_num == EADDRINUSE)) 747 (err_num == EADDRINUSE))
768#endif 748#endif
769 { 749 {
770 client = server; 750 client = server;
771 if (h == NULL || strcmp(h,"*") == 0) 751 if (h == NULL || strcmp(h, "*") == 0) {
772 {
773#if OPENSSL_USE_IPV6 752#if OPENSSL_USE_IPV6
774 if (client.sa.sa_family == AF_INET6) 753 if (client.sa.sa_family == AF_INET6) {
775 { 754 memset(&client.sa_in6.sin6_addr, 0, sizeof(client.sa_in6.sin6_addr));
776 memset(&client.sa_in6.sin6_addr,0,sizeof(client.sa_in6.sin6_addr)); 755 client.sa_in6.sin6_addr.s6_addr[15] = 1;
777 client.sa_in6.sin6_addr.s6_addr[15]=1; 756 } else
778 } 757#endif
779 else 758 if (client.sa.sa_family == AF_INET) {
780#endif 759 client.sa_in.sin_addr.s_addr = htonl(0x7F000001);
781 if (client.sa.sa_family == AF_INET) 760 } else
782 { 761 goto err;
783 client.sa_in.sin_addr.s_addr=htonl(0x7F000001); 762 }
784 } 763 cs = socket(client.sa.sa_family, SOCK_STREAM, SOCKET_PROTOCOL);
785 else goto err; 764 if (cs != -1) {
786 }
787 cs=socket(client.sa.sa_family,SOCK_STREAM,SOCKET_PROTOCOL);
788 if (cs != -1)
789 {
790 int ii; 765 int ii;
791 ii=connect(cs,&client.sa,addrlen); 766 ii = connect(cs, &client.sa, addrlen);
792 close(cs); 767 close(cs);
793 if (ii == -1) 768 if (ii == -1) {
794 { 769 bind_mode = BIO_BIND_REUSEADDR;
795 bind_mode=BIO_BIND_REUSEADDR;
796 close(s); 770 close(s);
797 goto again; 771 goto again;
798 }
799 /* else error */
800 } 772 }
801 /* else error */ 773 /* else error */
802 } 774 }
775 /* else error */
776 }
803#endif 777#endif
804 SYSerr(SYS_F_BIND,err_num); 778 SYSerr(SYS_F_BIND, err_num);
805 ERR_add_error_data(3,"port='",host,"'"); 779 ERR_add_error_data(3, "port = '", host, "'");
806 BIOerr(BIO_F_BIO_GET_ACCEPT_SOCKET,BIO_R_UNABLE_TO_BIND_SOCKET); 780 BIOerr(BIO_F_BIO_GET_ACCEPT_SOCKET, BIO_R_UNABLE_TO_BIND_SOCKET);
807 goto err; 781 goto err;
808 } 782 }
809 if (listen(s,MAX_LISTEN) == -1) 783 if (listen(s, MAX_LISTEN) == -1) {
810 { 784 SYSerr(SYS_F_BIND, errno);
811 SYSerr(SYS_F_BIND,errno); 785 ERR_add_error_data(3, "port = '", host, "'");
812 ERR_add_error_data(3,"port='",host,"'"); 786 BIOerr(BIO_F_BIO_GET_ACCEPT_SOCKET, BIO_R_UNABLE_TO_LISTEN_SOCKET);
813 BIOerr(BIO_F_BIO_GET_ACCEPT_SOCKET,BIO_R_UNABLE_TO_LISTEN_SOCKET);
814 goto err; 787 goto err;
815 } 788 }
816 ret=1; 789 ret = 1;
817err: 790err:
818 if (str != NULL) OPENSSL_free(str); 791 if (str != NULL)
819 if ((ret == 0) && (s != -1)) 792 OPENSSL_free(str);
820 { 793 if ((ret == 0) && (s != -1)) {
821 close(s); 794 close(s);
822 s= -1; 795 s = -1;
823 }
824 return(s);
825 } 796 }
797 return (s);
798}
826 799
827int BIO_accept(int sock, char **addr) 800int
828 { 801BIO_accept(int sock, char **addr)
829 int ret=-1; 802{
803 int ret = -1;
830 unsigned long l; 804 unsigned long l;
831 unsigned short port; 805 unsigned short port;
832 char *p; 806 char *p;
833 807
834 struct { 808 struct {
835 /* 809 /*
836 * As for following union. Trouble is that there are platforms 810 * As for following union. Trouble is that there are platforms
837 * that have socklen_t and there are platforms that don't, on 811 * that have socklen_t and there are platforms that don't, on
838 * some platforms socklen_t is int and on some size_t. So what 812 * some platforms socklen_t is int and on some size_t. So what
839 * one can do? One can cook #ifdef spaghetti, which is nothing 813 * one can do? One can cook #ifdef spaghetti, which is nothing
840 * but masochistic. Or one can do union between int and size_t. 814 * but masochistic. Or one can do union between int and size_t.
841 * One naturally does it primarily for 64-bit platforms where 815 * One naturally does it primarily for 64-bit platforms where
842 * sizeof(int) != sizeof(size_t). But would it work? Note that 816 * sizeof(int) != sizeof(size_t). But would it work? Note that
843 * if size_t member is initialized to 0, then later int member 817 * if size_t member is initialized to 0, then later int member
844 * assignment naturally does the job on little-endian platforms 818 * assignment naturally does the job on little-endian platforms
845 * regardless accept's expectations! What about big-endians? 819 * regardless accept's expectations! What about big-endians?
846 * If accept expects int*, then it works, and if size_t*, then 820 * If accept expects int*, then it works, and if size_t*, then
847 * length value would appear as unreasonably large. But this 821 * length value would appear as unreasonably large. But this
848 * won't prevent it from filling in the address structure. The 822 * won't prevent it from filling in the address structure. The
849 * trouble of course would be if accept returns more data than 823 * trouble of course would be if accept returns more data than
850 * actual buffer can accomodate and overwrite stack... That's 824 * actual buffer can accomodate and overwrite stack... That's
851 * where early OPENSSL_assert comes into picture. Besides, the 825 * where early OPENSSL_assert comes into picture. Besides, the
852 * only 64-bit big-endian platform found so far that expects 826 * only 64-bit big-endian platform found so far that expects
853 * size_t* is HP-UX, where stack grows towards higher address. 827 * size_t* is HP-UX, where stack grows towards higher address.
854 * <appro> 828 * <appro>
855 */ 829 */
856 union { size_t s; int i; } len; 830 union {
857 union { 831 size_t s;
858 struct sockaddr sa; 832 int i;
859 struct sockaddr_in sa_in; 833 } len;
834 union {
835 struct sockaddr sa;
836 struct sockaddr_in sa_in;
860#if OPENSSL_USE_IPV6 837#if OPENSSL_USE_IPV6
861 struct sockaddr_in6 sa_in6; 838 struct sockaddr_in6 sa_in6;
862#endif 839#endif
863 } from; 840 } from;
864 } sa; 841 } sa;
865 842
866 sa.len.s=0; 843 sa.len.s = 0;
867 sa.len.i=sizeof(sa.from); 844 sa.len.i = sizeof(sa.from);
868 memset(&sa.from,0,sizeof(sa.from)); 845 memset(&sa.from, 0, sizeof(sa.from));
869 ret=accept(sock,&sa.from.sa,(void *)&sa.len); 846 ret = accept(sock, &sa.from.sa,(void *)&sa.len);
870 if (sizeof(sa.len.i)!=sizeof(sa.len.s) && sa.len.i==0) 847 if (sizeof(sa.len.i) != sizeof(sa.len.s) && sa.len.i == 0) {
871 { 848 OPENSSL_assert(sa.len.s <= sizeof(sa.from));
872 OPENSSL_assert(sa.len.s<=sizeof(sa.from));
873 sa.len.i = (int)sa.len.s; 849 sa.len.i = (int)sa.len.s;
874 /* use sa.len.i from this point */ 850 /* use sa.len.i from this point */
875 } 851 }
876 if (ret == -1) 852 if (ret == -1) {
877 { 853 if (BIO_sock_should_retry(ret)) return -2;
878 if(BIO_sock_should_retry(ret)) return -2; 854 SYSerr(SYS_F_ACCEPT, errno);
879 SYSerr(SYS_F_ACCEPT,errno); 855 BIOerr(BIO_F_BIO_ACCEPT, BIO_R_ACCEPT_ERROR);
880 BIOerr(BIO_F_BIO_ACCEPT,BIO_R_ACCEPT_ERROR);
881 goto end; 856 goto end;
882 } 857 }
883 858
884 if (addr == NULL) goto end; 859 if (addr == NULL)
860 goto end;
885 861
886#ifdef EAI_FAMILY 862#ifdef EAI_FAMILY
887 do { 863 do {
888 char h[NI_MAXHOST],s[NI_MAXSERV]; 864 char h[NI_MAXHOST], s[NI_MAXSERV];
889 size_t nl; 865 size_t nl;
890 static union { void *p; 866 static union {
891 int (WSAAPI *f)(const struct sockaddr *,size_t/*socklen_t*/, 867 void *p;
892 char *,size_t,char *,size_t,int); 868 int (WSAAPI *f)(const struct sockaddr *,
893 } p_getnameinfo = {NULL}; 869 size_t/*socklen_t*/, char *, size_t,
894 /* 2nd argument to getnameinfo is specified to 870 char *, size_t, int);
895 * be socklen_t. Unfortunately there is a number 871 } p_getnameinfo = {NULL};
896 * of environments where socklen_t is not defined. 872 /* 2nd argument to getnameinfo is specified to
897 * As it's passed by value, it's safe to pass it 873 * be socklen_t. Unfortunately there is a number
898 * as size_t... <appro> */ 874 * of environments where socklen_t is not defined.
899 875 * As it's passed by value, it's safe to pass it
900 if (p_getnameinfo.p==NULL) 876 * as size_t... <appro> */
901 { 877
902 if ((p_getnameinfo.p=DSO_global_lookup("getnameinfo"))==NULL) 878 if (p_getnameinfo.p == NULL) {
903 p_getnameinfo.p=(void*)-1; 879 if ((p_getnameinfo.p = DSO_global_lookup("getnameinfo")) == NULL)
880 p_getnameinfo.p = (void*) - 1;
881 }
882 if (p_getnameinfo.p == (void *) - 1)
883 break;
884
885 if ((*p_getnameinfo.f)(&sa.from.sa, sa.len.i, h, sizeof(h),
886 s, sizeof(s), NI_NUMERICHOST|NI_NUMERICSERV))
887 break;
888 nl = strlen(h) + strlen(s) + 2;
889 p = *addr;
890 if (p) {
891 *p = '\0';
892 p = OPENSSL_realloc(p, nl);
893 } else {
894 p = OPENSSL_malloc(nl);
895 }
896 if (p == NULL) {
897 BIOerr(BIO_F_BIO_ACCEPT, ERR_R_MALLOC_FAILURE);
898 goto end;
904 } 899 }
905 if (p_getnameinfo.p==(void *)-1) break; 900 *addr = p;
906 901 (void) snprintf(*addr, nl, "%s:%s", h, s);
907 if ((*p_getnameinfo.f)(&sa.from.sa,sa.len.i,h,sizeof(h),s,sizeof(s),
908 NI_NUMERICHOST|NI_NUMERICSERV)) break;
909 nl = strlen(h)+strlen(s)+2;
910 p = *addr;
911 if (p) { *p = '\0'; p = OPENSSL_realloc(p,nl); }
912 else { p = OPENSSL_malloc(nl); }
913 if (p==NULL)
914 {
915 BIOerr(BIO_F_BIO_ACCEPT,ERR_R_MALLOC_FAILURE);
916 goto end; 902 goto end;
917 } 903 } while (0);
918 *addr = p; 904#endif
919 (void) snprintf(*addr,nl,"%s:%s",h,s); 905 if (sa.from.sa.sa_family != AF_INET)
920 goto end; 906 goto end;
921 } while(0); 907 l = ntohl(sa.from.sa_in.sin_addr.s_addr);
922#endif 908 port = ntohs(sa.from.sa_in.sin_port);
923 if (sa.from.sa.sa_family != AF_INET) goto end; 909 if (*addr == NULL) {
924 l=ntohl(sa.from.sa_in.sin_addr.s_addr); 910 if ((p = OPENSSL_malloc(24)) == NULL) {
925 port=ntohs(sa.from.sa_in.sin_port); 911 BIOerr(BIO_F_BIO_ACCEPT, ERR_R_MALLOC_FAILURE);
926 if (*addr == NULL)
927 {
928 if ((p=OPENSSL_malloc(24)) == NULL)
929 {
930 BIOerr(BIO_F_BIO_ACCEPT,ERR_R_MALLOC_FAILURE);
931 goto end; 912 goto end;
932 }
933 *addr=p;
934 } 913 }
935 (void) snprintf(*addr,24,"%d.%d.%d.%d:%d", 914 *addr = p;
936 (unsigned char)(l>>24L)&0xff,
937 (unsigned char)(l>>16L)&0xff,
938 (unsigned char)(l>> 8L)&0xff,
939 (unsigned char)(l )&0xff,
940 port);
941end:
942 return(ret);
943 } 915 }
916 (void) snprintf(*addr, 24, "%d.%d.%d.%d:%d",
917 (unsigned char)(l >> 24L) & 0xff, (unsigned char)(l >> 16L) & 0xff,
918 (unsigned char)(l >> 8L) & 0xff, (unsigned char)(l) & 0xff, port);
944 919
945int BIO_set_tcp_ndelay(int s, int on) 920end:
946 { 921 return (ret);
947 int ret=0; 922}
923
924int
925BIO_set_tcp_ndelay(int s, int on)
926{
927 int ret = 0;
948#if defined(TCP_NODELAY) && (defined(IPPROTO_TCP) || defined(SOL_TCP)) 928#if defined(TCP_NODELAY) && (defined(IPPROTO_TCP) || defined(SOL_TCP))
949 int opt; 929 int opt;
950 930
951#ifdef SOL_TCP 931#ifdef SOL_TCP
952 opt=SOL_TCP; 932 opt = SOL_TCP;
953#else 933#else
954#ifdef IPPROTO_TCP 934#ifdef IPPROTO_TCP
955 opt=IPPROTO_TCP; 935 opt = IPPROTO_TCP;
956#endif 936#endif
957#endif 937#endif
958 938
959 ret=setsockopt(s,opt,TCP_NODELAY,(char *)&on,sizeof(on)); 939 ret = setsockopt(s, opt, TCP_NODELAY,(char *)&on, sizeof(on));
960#endif 940#endif
961 return(ret == 0); 941 return (ret == 0);
962 } 942}
963 943
964int BIO_socket_nbio(int s, int mode) 944int
965 { 945BIO_socket_nbio(int s, int mode)
966 int ret= -1; 946{
947 int ret = -1;
967 int l; 948 int l;
968 949
969 l=mode; 950 l = mode;
970#ifdef FIONBIO 951#ifdef FIONBIO
971 ret=BIO_socket_ioctl(s,FIONBIO,&l); 952 ret = BIO_socket_ioctl(s, FIONBIO, &l);
972#endif 953#endif
973 return(ret == 0); 954 return (ret == 0);
974 } 955}
975#endif 956#endif
generated by cgit v1.2.3-55-g6feb (git 2.39.1) at 2025-12-09 04:34:46 +0000