1 /* -*- buffer-read-only: t -*- 2 * 3 * reentr.c 4 * 5 * Copyright (C) 2002, 2003, 2005, 2006, 2007 by Larry Wall and others 6 * 7 * You may distribute under the terms of either the GNU General Public 8 * License or the Artistic License, as specified in the README file. 9 * 10 * !!!!!!! DO NOT EDIT THIS FILE !!!!!!! 11 * This file is built by reentr.pl from data in reentr.pl. 12 * 13 * "Saruman," I said, standing away from him, "only one hand at a time can 14 * wield the One, and you know that well, so do not trouble to say we!" 15 * 16 * This file contains a collection of automatically created wrappers 17 * (created by running reentr.pl) for reentrant (thread-safe) versions of 18 * various library calls, such as getpwent_r. The wrapping is done so 19 * that other files like pp_sys.c calling those library functions need not 20 * care about the differences between various platforms' idiosyncrasies 21 * regarding these reentrant interfaces. 22 */ 23 24 #include "EXTERN.h" 25 #define PERL_IN_REENTR_C 26 #include "perl.h" 27 #include "reentr.h" 28 29 void 30 Perl_reentrant_size(pTHX) { 31 #ifdef USE_REENTRANT_API 32 #define REENTRANTSMALLSIZE 256 /* Make something up. */ 33 #define REENTRANTUSUALSIZE 4096 /* Make something up. */ 34 #ifdef HAS_ASCTIME_R 35 PL_reentrant_buffer->_asctime_size = REENTRANTSMALLSIZE; 36 #endif /* HAS_ASCTIME_R */ 37 #ifdef HAS_CRYPT_R 38 #endif /* HAS_CRYPT_R */ 39 #ifdef HAS_CTIME_R 40 PL_reentrant_buffer->_ctime_size = REENTRANTSMALLSIZE; 41 #endif /* HAS_CTIME_R */ 42 #ifdef HAS_DRAND48_R 43 #endif /* HAS_DRAND48_R */ 44 #ifdef HAS_GETGRNAM_R 45 # if defined(HAS_SYSCONF) && defined(_SC_GETGR_R_SIZE_MAX) && !defined(__GLIBC__) 46 PL_reentrant_buffer->_grent_size = sysconf(_SC_GETGR_R_SIZE_MAX); 47 if (PL_reentrant_buffer->_grent_size == (size_t) -1) 48 PL_reentrant_buffer->_grent_size = REENTRANTUSUALSIZE; 49 # else 50 # if defined(__osf__) && defined(__alpha) && defined(SIABUFSIZ) 51 PL_reentrant_buffer->_grent_size = SIABUFSIZ; 52 # else 53 # ifdef __sgi 54 PL_reentrant_buffer->_grent_size = BUFSIZ; 55 # else 56 PL_reentrant_buffer->_grent_size = REENTRANTUSUALSIZE; 57 # endif 58 # endif 59 # endif 60 #endif /* HAS_GETGRNAM_R */ 61 #ifdef HAS_GETHOSTBYNAME_R 62 #if !(GETHOSTBYNAME_R_PROTO == REENTRANT_PROTO_I_CSD) 63 PL_reentrant_buffer->_hostent_size = REENTRANTUSUALSIZE; 64 #endif 65 #endif /* HAS_GETHOSTBYNAME_R */ 66 #ifdef HAS_GETLOGIN_R 67 PL_reentrant_buffer->_getlogin_size = REENTRANTSMALLSIZE; 68 #endif /* HAS_GETLOGIN_R */ 69 #ifdef HAS_GETNETBYNAME_R 70 #if !(GETNETBYNAME_R_PROTO == REENTRANT_PROTO_I_CSD) 71 PL_reentrant_buffer->_netent_size = REENTRANTUSUALSIZE; 72 #endif 73 #endif /* HAS_GETNETBYNAME_R */ 74 #ifdef HAS_GETPROTOBYNAME_R 75 #if !(GETPROTOBYNAME_R_PROTO == REENTRANT_PROTO_I_CSD) 76 PL_reentrant_buffer->_protoent_size = REENTRANTUSUALSIZE; 77 #endif 78 #endif /* HAS_GETPROTOBYNAME_R */ 79 #ifdef HAS_GETPWNAM_R 80 # if defined(HAS_SYSCONF) && defined(_SC_GETPW_R_SIZE_MAX) && !defined(__GLIBC__) 81 PL_reentrant_buffer->_pwent_size = sysconf(_SC_GETPW_R_SIZE_MAX); 82 if (PL_reentrant_buffer->_pwent_size == (size_t) -1) 83 PL_reentrant_buffer->_pwent_size = REENTRANTUSUALSIZE; 84 # else 85 # if defined(__osf__) && defined(__alpha) && defined(SIABUFSIZ) 86 PL_reentrant_buffer->_pwent_size = SIABUFSIZ; 87 # else 88 # ifdef __sgi 89 PL_reentrant_buffer->_pwent_size = BUFSIZ; 90 # else 91 PL_reentrant_buffer->_pwent_size = REENTRANTUSUALSIZE; 92 # endif 93 # endif 94 # endif 95 #endif /* HAS_GETPWNAM_R */ 96 #ifdef HAS_GETSERVBYNAME_R 97 #if !(GETSERVBYNAME_R_PROTO == REENTRANT_PROTO_I_CCSD) 98 PL_reentrant_buffer->_servent_size = REENTRANTUSUALSIZE; 99 #endif 100 #endif /* HAS_GETSERVBYNAME_R */ 101 #ifdef HAS_GETSPNAM_R 102 # if defined(HAS_SYSCONF) && defined(_SC_GETPW_R_SIZE_MAX) && !defined(__GLIBC__) 103 PL_reentrant_buffer->_spent_size = sysconf(_SC_GETPW_R_SIZE_MAX); 104 if (PL_reentrant_buffer->_spent_size == (size_t) -1) 105 PL_reentrant_buffer->_spent_size = REENTRANTUSUALSIZE; 106 # else 107 # if defined(__osf__) && defined(__alpha) && defined(SIABUFSIZ) 108 PL_reentrant_buffer->_spent_size = SIABUFSIZ; 109 # else 110 # ifdef __sgi 111 PL_reentrant_buffer->_spent_size = BUFSIZ; 112 # else 113 PL_reentrant_buffer->_spent_size = REENTRANTUSUALSIZE; 114 # endif 115 # endif 116 # endif 117 #endif /* HAS_GETSPNAM_R */ 118 #ifdef HAS_GMTIME_R 119 #endif /* HAS_GMTIME_R */ 120 #ifdef HAS_LOCALTIME_R 121 #endif /* HAS_LOCALTIME_R */ 122 #ifdef HAS_RANDOM_R 123 #endif /* HAS_RANDOM_R */ 124 #ifdef HAS_READDIR_R 125 /* This is the size Solaris recommends. 126 * (though we go static, should use pathconf() instead) */ 127 PL_reentrant_buffer->_readdir_size = sizeof(struct dirent) + MAXPATHLEN + 1; 128 #endif /* HAS_READDIR_R */ 129 #ifdef HAS_READDIR64_R 130 /* This is the size Solaris recommends. 131 * (though we go static, should use pathconf() instead) */ 132 PL_reentrant_buffer->_readdir64_size = sizeof(struct dirent64) + MAXPATHLEN + 1; 133 #endif /* HAS_READDIR64_R */ 134 #ifdef HAS_SETLOCALE_R 135 PL_reentrant_buffer->_setlocale_size = REENTRANTSMALLSIZE; 136 #endif /* HAS_SETLOCALE_R */ 137 #ifdef HAS_SRANDOM_R 138 #endif /* HAS_SRANDOM_R */ 139 #ifdef HAS_STRERROR_R 140 PL_reentrant_buffer->_strerror_size = REENTRANTSMALLSIZE; 141 #endif /* HAS_STRERROR_R */ 142 #ifdef HAS_TTYNAME_R 143 PL_reentrant_buffer->_ttyname_size = REENTRANTSMALLSIZE; 144 #endif /* HAS_TTYNAME_R */ 145 146 #endif /* USE_REENTRANT_API */ 147 } 148 149 void 150 Perl_reentrant_init(pTHX) { 151 #ifdef USE_REENTRANT_API 152 Newx(PL_reentrant_buffer, 1, REENTR); 153 Perl_reentrant_size(aTHX); 154 #ifdef HAS_ASCTIME_R 155 Newx(PL_reentrant_buffer->_asctime_buffer, PL_reentrant_buffer->_asctime_size, char); 156 #endif /* HAS_ASCTIME_R */ 157 #ifdef HAS_CRYPT_R 158 #if CRYPT_R_PROTO != REENTRANT_PROTO_B_CCD 159 PL_reentrant_buffer->_crypt_struct_buffer = 0; 160 #endif 161 #endif /* HAS_CRYPT_R */ 162 #ifdef HAS_CTIME_R 163 Newx(PL_reentrant_buffer->_ctime_buffer, PL_reentrant_buffer->_ctime_size, char); 164 #endif /* HAS_CTIME_R */ 165 #ifdef HAS_DRAND48_R 166 #endif /* HAS_DRAND48_R */ 167 #ifdef HAS_GETGRNAM_R 168 # ifdef USE_GRENT_FPTR 169 PL_reentrant_buffer->_grent_fptr = NULL; 170 # endif 171 Newx(PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size, char); 172 #endif /* HAS_GETGRNAM_R */ 173 #ifdef HAS_GETHOSTBYNAME_R 174 #if !(GETHOSTBYNAME_R_PROTO == REENTRANT_PROTO_I_CSD) 175 Newx(PL_reentrant_buffer->_hostent_buffer, PL_reentrant_buffer->_hostent_size, char); 176 #endif 177 #endif /* HAS_GETHOSTBYNAME_R */ 178 #ifdef HAS_GETLOGIN_R 179 Newx(PL_reentrant_buffer->_getlogin_buffer, PL_reentrant_buffer->_getlogin_size, char); 180 #endif /* HAS_GETLOGIN_R */ 181 #ifdef HAS_GETNETBYNAME_R 182 #if !(GETNETBYNAME_R_PROTO == REENTRANT_PROTO_I_CSD) 183 Newx(PL_reentrant_buffer->_netent_buffer, PL_reentrant_buffer->_netent_size, char); 184 #endif 185 #endif /* HAS_GETNETBYNAME_R */ 186 #ifdef HAS_GETPROTOBYNAME_R 187 #if !(GETPROTOBYNAME_R_PROTO == REENTRANT_PROTO_I_CSD) 188 Newx(PL_reentrant_buffer->_protoent_buffer, PL_reentrant_buffer->_protoent_size, char); 189 #endif 190 #endif /* HAS_GETPROTOBYNAME_R */ 191 #ifdef HAS_GETPWNAM_R 192 # ifdef USE_PWENT_FPTR 193 PL_reentrant_buffer->_pwent_fptr = NULL; 194 # endif 195 Newx(PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size, char); 196 #endif /* HAS_GETPWNAM_R */ 197 #ifdef HAS_GETSERVBYNAME_R 198 #if !(GETSERVBYNAME_R_PROTO == REENTRANT_PROTO_I_CCSD) 199 Newx(PL_reentrant_buffer->_servent_buffer, PL_reentrant_buffer->_servent_size, char); 200 #endif 201 #endif /* HAS_GETSERVBYNAME_R */ 202 #ifdef HAS_GETSPNAM_R 203 # ifdef USE_SPENT_FPTR 204 PL_reentrant_buffer->_spent_fptr = NULL; 205 # endif 206 Newx(PL_reentrant_buffer->_spent_buffer, PL_reentrant_buffer->_spent_size, char); 207 #endif /* HAS_GETSPNAM_R */ 208 #ifdef HAS_GMTIME_R 209 #endif /* HAS_GMTIME_R */ 210 #ifdef HAS_LOCALTIME_R 211 #endif /* HAS_LOCALTIME_R */ 212 #ifdef HAS_RANDOM_R 213 #endif /* HAS_RANDOM_R */ 214 #ifdef HAS_READDIR_R 215 PL_reentrant_buffer->_readdir_struct = (struct dirent*)safemalloc(PL_reentrant_buffer->_readdir_size); 216 #endif /* HAS_READDIR_R */ 217 #ifdef HAS_READDIR64_R 218 PL_reentrant_buffer->_readdir64_struct = (struct dirent64*)safemalloc(PL_reentrant_buffer->_readdir64_size); 219 #endif /* HAS_READDIR64_R */ 220 #ifdef HAS_SETLOCALE_R 221 Newx(PL_reentrant_buffer->_setlocale_buffer, PL_reentrant_buffer->_setlocale_size, char); 222 #endif /* HAS_SETLOCALE_R */ 223 #ifdef HAS_SRANDOM_R 224 #endif /* HAS_SRANDOM_R */ 225 #ifdef HAS_STRERROR_R 226 Newx(PL_reentrant_buffer->_strerror_buffer, PL_reentrant_buffer->_strerror_size, char); 227 #endif /* HAS_STRERROR_R */ 228 #ifdef HAS_TTYNAME_R 229 Newx(PL_reentrant_buffer->_ttyname_buffer, PL_reentrant_buffer->_ttyname_size, char); 230 #endif /* HAS_TTYNAME_R */ 231 232 #endif /* USE_REENTRANT_API */ 233 } 234 235 void 236 Perl_reentrant_free(pTHX) { 237 #ifdef USE_REENTRANT_API 238 #ifdef HAS_ASCTIME_R 239 Safefree(PL_reentrant_buffer->_asctime_buffer); 240 #endif /* HAS_ASCTIME_R */ 241 #ifdef HAS_CRYPT_R 242 #if CRYPT_R_PROTO != REENTRANT_PROTO_B_CCD 243 Safefree(PL_reentrant_buffer->_crypt_struct_buffer); 244 #endif 245 #endif /* HAS_CRYPT_R */ 246 #ifdef HAS_CTIME_R 247 Safefree(PL_reentrant_buffer->_ctime_buffer); 248 #endif /* HAS_CTIME_R */ 249 #ifdef HAS_DRAND48_R 250 #endif /* HAS_DRAND48_R */ 251 #ifdef HAS_GETGRNAM_R 252 Safefree(PL_reentrant_buffer->_grent_buffer); 253 #endif /* HAS_GETGRNAM_R */ 254 #ifdef HAS_GETHOSTBYNAME_R 255 #if !(GETHOSTBYNAME_R_PROTO == REENTRANT_PROTO_I_CSD) 256 Safefree(PL_reentrant_buffer->_hostent_buffer); 257 #endif 258 #endif /* HAS_GETHOSTBYNAME_R */ 259 #ifdef HAS_GETLOGIN_R 260 Safefree(PL_reentrant_buffer->_getlogin_buffer); 261 #endif /* HAS_GETLOGIN_R */ 262 #ifdef HAS_GETNETBYNAME_R 263 #if !(GETNETBYNAME_R_PROTO == REENTRANT_PROTO_I_CSD) 264 Safefree(PL_reentrant_buffer->_netent_buffer); 265 #endif 266 #endif /* HAS_GETNETBYNAME_R */ 267 #ifdef HAS_GETPROTOBYNAME_R 268 #if !(GETPROTOBYNAME_R_PROTO == REENTRANT_PROTO_I_CSD) 269 Safefree(PL_reentrant_buffer->_protoent_buffer); 270 #endif 271 #endif /* HAS_GETPROTOBYNAME_R */ 272 #ifdef HAS_GETPWNAM_R 273 Safefree(PL_reentrant_buffer->_pwent_buffer); 274 #endif /* HAS_GETPWNAM_R */ 275 #ifdef HAS_GETSERVBYNAME_R 276 #if !(GETSERVBYNAME_R_PROTO == REENTRANT_PROTO_I_CCSD) 277 Safefree(PL_reentrant_buffer->_servent_buffer); 278 #endif 279 #endif /* HAS_GETSERVBYNAME_R */ 280 #ifdef HAS_GETSPNAM_R 281 Safefree(PL_reentrant_buffer->_spent_buffer); 282 #endif /* HAS_GETSPNAM_R */ 283 #ifdef HAS_GMTIME_R 284 #endif /* HAS_GMTIME_R */ 285 #ifdef HAS_LOCALTIME_R 286 #endif /* HAS_LOCALTIME_R */ 287 #ifdef HAS_RANDOM_R 288 #endif /* HAS_RANDOM_R */ 289 #ifdef HAS_READDIR_R 290 Safefree(PL_reentrant_buffer->_readdir_struct); 291 #endif /* HAS_READDIR_R */ 292 #ifdef HAS_READDIR64_R 293 Safefree(PL_reentrant_buffer->_readdir64_struct); 294 #endif /* HAS_READDIR64_R */ 295 #ifdef HAS_SETLOCALE_R 296 Safefree(PL_reentrant_buffer->_setlocale_buffer); 297 #endif /* HAS_SETLOCALE_R */ 298 #ifdef HAS_SRANDOM_R 299 #endif /* HAS_SRANDOM_R */ 300 #ifdef HAS_STRERROR_R 301 Safefree(PL_reentrant_buffer->_strerror_buffer); 302 #endif /* HAS_STRERROR_R */ 303 #ifdef HAS_TTYNAME_R 304 Safefree(PL_reentrant_buffer->_ttyname_buffer); 305 #endif /* HAS_TTYNAME_R */ 306 307 Safefree(PL_reentrant_buffer); 308 #endif /* USE_REENTRANT_API */ 309 } 310 311 void* 312 Perl_reentrant_retry(const char *f, ...) 313 { 314 dTHX; 315 void *retptr = NULL; 316 va_list ap; 317 #ifdef USE_REENTRANT_API 318 /* Easier to special case this here than in embed.pl. (Look at what it 319 generates for proto.h) */ 320 PERL_ARGS_ASSERT_REENTRANT_RETRY; 321 #endif 322 va_start(ap, f); 323 { 324 #ifdef USE_REENTRANT_API 325 # if defined(USE_HOSTENT_BUFFER) || defined(USE_GRENT_BUFFER) || defined(USE_NETENT_BUFFER) || defined(USE_PWENT_BUFFER) || defined(USE_PROTOENT_BUFFER) || defined(USE_SERVENT_BUFFER) 326 void *p0; 327 # endif 328 # if defined(USE_SERVENT_BUFFER) 329 void *p1; 330 # endif 331 # if defined(USE_HOSTENT_BUFFER) 332 size_t asize; 333 # endif 334 # if defined(USE_HOSTENT_BUFFER) || defined(USE_NETENT_BUFFER) || defined(USE_PROTOENT_BUFFER) || defined(USE_SERVENT_BUFFER) 335 int anint; 336 # endif 337 338 switch (PL_op->op_type) { 339 #ifdef USE_HOSTENT_BUFFER 340 case OP_GHBYADDR: 341 case OP_GHBYNAME: 342 case OP_GHOSTENT: 343 { 344 #ifdef PERL_REENTRANT_MAXSIZE 345 if (PL_reentrant_buffer->_hostent_size <= 346 PERL_REENTRANT_MAXSIZE / 2) 347 #endif 348 { 349 PL_reentrant_buffer->_hostent_size *= 2; 350 Renew(PL_reentrant_buffer->_hostent_buffer, 351 PL_reentrant_buffer->_hostent_size, char); 352 switch (PL_op->op_type) { 353 case OP_GHBYADDR: 354 p0 = va_arg(ap, void *); 355 asize = va_arg(ap, size_t); 356 anint = va_arg(ap, int); 357 retptr = gethostbyaddr(p0, asize, anint); break; 358 case OP_GHBYNAME: 359 p0 = va_arg(ap, void *); 360 retptr = gethostbyname((char *)p0); break; 361 case OP_GHOSTENT: 362 retptr = gethostent(); break; 363 default: 364 SETERRNO(ERANGE, LIB_INVARG); 365 break; 366 } 367 } 368 } 369 break; 370 #endif 371 #ifdef USE_GRENT_BUFFER 372 case OP_GGRNAM: 373 case OP_GGRGID: 374 case OP_GGRENT: 375 { 376 #ifdef PERL_REENTRANT_MAXSIZE 377 if (PL_reentrant_buffer->_grent_size <= 378 PERL_REENTRANT_MAXSIZE / 2) 379 #endif 380 { 381 Gid_t gid; 382 PL_reentrant_buffer->_grent_size *= 2; 383 Renew(PL_reentrant_buffer->_grent_buffer, 384 PL_reentrant_buffer->_grent_size, char); 385 switch (PL_op->op_type) { 386 case OP_GGRNAM: 387 p0 = va_arg(ap, void *); 388 retptr = getgrnam((char *)p0); break; 389 case OP_GGRGID: 390 #if Gid_t_size < INTSIZE 391 gid = (Gid_t)va_arg(ap, int); 392 #else 393 gid = va_arg(ap, Gid_t); 394 #endif 395 retptr = getgrgid(gid); break; 396 case OP_GGRENT: 397 retptr = getgrent(); break; 398 default: 399 SETERRNO(ERANGE, LIB_INVARG); 400 break; 401 } 402 } 403 } 404 break; 405 #endif 406 #ifdef USE_NETENT_BUFFER 407 case OP_GNBYADDR: 408 case OP_GNBYNAME: 409 case OP_GNETENT: 410 { 411 #ifdef PERL_REENTRANT_MAXSIZE 412 if (PL_reentrant_buffer->_netent_size <= 413 PERL_REENTRANT_MAXSIZE / 2) 414 #endif 415 { 416 Netdb_net_t net; 417 PL_reentrant_buffer->_netent_size *= 2; 418 Renew(PL_reentrant_buffer->_netent_buffer, 419 PL_reentrant_buffer->_netent_size, char); 420 switch (PL_op->op_type) { 421 case OP_GNBYADDR: 422 net = va_arg(ap, Netdb_net_t); 423 anint = va_arg(ap, int); 424 retptr = getnetbyaddr(net, anint); break; 425 case OP_GNBYNAME: 426 p0 = va_arg(ap, void *); 427 retptr = getnetbyname((char *)p0); break; 428 case OP_GNETENT: 429 retptr = getnetent(); break; 430 default: 431 SETERRNO(ERANGE, LIB_INVARG); 432 break; 433 } 434 } 435 } 436 break; 437 #endif 438 #ifdef USE_PWENT_BUFFER 439 case OP_GPWNAM: 440 case OP_GPWUID: 441 case OP_GPWENT: 442 { 443 #ifdef PERL_REENTRANT_MAXSIZE 444 if (PL_reentrant_buffer->_pwent_size <= 445 PERL_REENTRANT_MAXSIZE / 2) 446 #endif 447 { 448 Uid_t uid; 449 PL_reentrant_buffer->_pwent_size *= 2; 450 Renew(PL_reentrant_buffer->_pwent_buffer, 451 PL_reentrant_buffer->_pwent_size, char); 452 switch (PL_op->op_type) { 453 case OP_GPWNAM: 454 p0 = va_arg(ap, void *); 455 retptr = getpwnam((char *)p0); break; 456 case OP_GPWUID: 457 #if Uid_t_size < INTSIZE 458 uid = (Uid_t)va_arg(ap, int); 459 #else 460 uid = va_arg(ap, Uid_t); 461 #endif 462 retptr = getpwuid(uid); break; 463 case OP_GPWENT: 464 retptr = getpwent(); break; 465 default: 466 SETERRNO(ERANGE, LIB_INVARG); 467 break; 468 } 469 } 470 } 471 break; 472 #endif 473 #ifdef USE_PROTOENT_BUFFER 474 case OP_GPBYNAME: 475 case OP_GPBYNUMBER: 476 case OP_GPROTOENT: 477 { 478 #ifdef PERL_REENTRANT_MAXSIZE 479 if (PL_reentrant_buffer->_protoent_size <= 480 PERL_REENTRANT_MAXSIZE / 2) 481 #endif 482 { 483 PL_reentrant_buffer->_protoent_size *= 2; 484 Renew(PL_reentrant_buffer->_protoent_buffer, 485 PL_reentrant_buffer->_protoent_size, char); 486 switch (PL_op->op_type) { 487 case OP_GPBYNAME: 488 p0 = va_arg(ap, void *); 489 retptr = getprotobyname((char *)p0); break; 490 case OP_GPBYNUMBER: 491 anint = va_arg(ap, int); 492 retptr = getprotobynumber(anint); break; 493 case OP_GPROTOENT: 494 retptr = getprotoent(); break; 495 default: 496 SETERRNO(ERANGE, LIB_INVARG); 497 break; 498 } 499 } 500 } 501 break; 502 #endif 503 #ifdef USE_SERVENT_BUFFER 504 case OP_GSBYNAME: 505 case OP_GSBYPORT: 506 case OP_GSERVENT: 507 { 508 #ifdef PERL_REENTRANT_MAXSIZE 509 if (PL_reentrant_buffer->_servent_size <= 510 PERL_REENTRANT_MAXSIZE / 2) 511 #endif 512 { 513 PL_reentrant_buffer->_servent_size *= 2; 514 Renew(PL_reentrant_buffer->_servent_buffer, 515 PL_reentrant_buffer->_servent_size, char); 516 switch (PL_op->op_type) { 517 case OP_GSBYNAME: 518 p0 = va_arg(ap, void *); 519 p1 = va_arg(ap, void *); 520 retptr = getservbyname((char *)p0, (char *)p1); break; 521 case OP_GSBYPORT: 522 anint = va_arg(ap, int); 523 p0 = va_arg(ap, void *); 524 retptr = getservbyport(anint, (char *)p0); break; 525 case OP_GSERVENT: 526 retptr = getservent(); break; 527 default: 528 SETERRNO(ERANGE, LIB_INVARG); 529 break; 530 } 531 } 532 } 533 break; 534 #endif 535 default: 536 /* Not known how to retry, so just fail. */ 537 break; 538 } 539 #else 540 PERL_UNUSED_ARG(f); 541 #endif 542 } 543 va_end(ap); 544 return retptr; 545 } 546 547 /* ex: set ro: */ 548