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