reentr.c

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