Upgrade to CPAN-1.80_57
[perl.git] / reentr.c
1 /* -*- buffer-read-only: t -*-
2  *
3  *    reentr.c
4  *
5  *    Copyright (C) 2002, 2003, 2005 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 == -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 == -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 == -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 #ifdef USE_REENTRANT_API
317 #  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)
318     void *p0;
319 #  endif
320 #  if defined(USE_SERVENT_BUFFER)
321     void *p1;
322 #  endif
323 #  if defined(USE_HOSTENT_BUFFER)
324     size_t asize;
325 #  endif
326 #  if defined(USE_HOSTENT_BUFFER) || defined(USE_NETENT_BUFFER) || defined(USE_PROTOENT_BUFFER) || defined(USE_SERVENT_BUFFER)
327     int anint;
328 #  endif
329     va_list ap;
330
331     va_start(ap, f);
332
333     switch (PL_op->op_type) {
334 #ifdef USE_HOSTENT_BUFFER
335     case OP_GHBYADDR:
336     case OP_GHBYNAME:
337     case OP_GHOSTENT:
338         {
339 #ifdef PERL_REENTRANT_MAXSIZE
340             if (PL_reentrant_buffer->_hostent_size <=
341                 PERL_REENTRANT_MAXSIZE / 2)
342 #endif
343             {
344                 PL_reentrant_buffer->_hostent_size *= 2;
345                 Renew(PL_reentrant_buffer->_hostent_buffer,
346                       PL_reentrant_buffer->_hostent_size, char);
347                 switch (PL_op->op_type) {
348                 case OP_GHBYADDR:
349                     p0    = va_arg(ap, void *);
350                     asize = va_arg(ap, size_t);
351                     anint  = va_arg(ap, int);
352                     retptr = gethostbyaddr(p0, asize, anint); break;
353                 case OP_GHBYNAME:
354                     p0 = va_arg(ap, void *);
355                     retptr = gethostbyname((char *)p0); break;
356                 case OP_GHOSTENT:
357                     retptr = gethostent(); break;
358                 default:
359                     SETERRNO(ERANGE, LIB_INVARG);
360                     break;
361                 }
362             }
363         }
364         break;
365 #endif
366 #ifdef USE_GRENT_BUFFER
367     case OP_GGRNAM:
368     case OP_GGRGID:
369     case OP_GGRENT:
370         {
371 #ifdef PERL_REENTRANT_MAXSIZE
372             if (PL_reentrant_buffer->_grent_size <=
373                 PERL_REENTRANT_MAXSIZE / 2)
374 #endif
375             {
376                 Gid_t gid;
377                 PL_reentrant_buffer->_grent_size *= 2;
378                 Renew(PL_reentrant_buffer->_grent_buffer,
379                       PL_reentrant_buffer->_grent_size, char);
380                 switch (PL_op->op_type) {
381                 case OP_GGRNAM:
382                     p0 = va_arg(ap, void *);
383                     retptr = getgrnam((char *)p0); break;
384                 case OP_GGRGID:
385 #if Gid_t_size < INTSIZE
386                     gid = (Gid_t)va_arg(ap, int);
387 #else
388                     gid = va_arg(ap, Gid_t);
389 #endif
390                     retptr = getgrgid(gid); break;
391                 case OP_GGRENT:
392                     retptr = getgrent(); break;
393                 default:
394                     SETERRNO(ERANGE, LIB_INVARG);
395                     break;
396                 }
397             }
398         }
399         break;
400 #endif
401 #ifdef USE_NETENT_BUFFER
402     case OP_GNBYADDR:
403     case OP_GNBYNAME:
404     case OP_GNETENT:
405         {
406 #ifdef PERL_REENTRANT_MAXSIZE
407             if (PL_reentrant_buffer->_netent_size <=
408                 PERL_REENTRANT_MAXSIZE / 2)
409 #endif
410             {
411                 Netdb_net_t net;
412                 PL_reentrant_buffer->_netent_size *= 2;
413                 Renew(PL_reentrant_buffer->_netent_buffer,
414                       PL_reentrant_buffer->_netent_size, char);
415                 switch (PL_op->op_type) {
416                 case OP_GNBYADDR:
417                     net = va_arg(ap, Netdb_net_t);
418                     anint = va_arg(ap, int);
419                     retptr = getnetbyaddr(net, anint); break;
420                 case OP_GNBYNAME:
421                     p0 = va_arg(ap, void *);
422                     retptr = getnetbyname((char *)p0); break;
423                 case OP_GNETENT:
424                     retptr = getnetent(); break;
425                 default:
426                     SETERRNO(ERANGE, LIB_INVARG);
427                     break;
428                 }
429             }
430         }
431         break;
432 #endif
433 #ifdef USE_PWENT_BUFFER
434     case OP_GPWNAM:
435     case OP_GPWUID:
436     case OP_GPWENT:
437         {
438 #ifdef PERL_REENTRANT_MAXSIZE
439             if (PL_reentrant_buffer->_pwent_size <=
440                 PERL_REENTRANT_MAXSIZE / 2)
441 #endif
442             {
443                 Uid_t uid;
444                 PL_reentrant_buffer->_pwent_size *= 2;
445                 Renew(PL_reentrant_buffer->_pwent_buffer,
446                       PL_reentrant_buffer->_pwent_size, char);
447                 switch (PL_op->op_type) {
448                 case OP_GPWNAM:
449                     p0 = va_arg(ap, void *);
450                     retptr = getpwnam((char *)p0); break;
451                 case OP_GPWUID:
452 #if Uid_t_size < INTSIZE
453                     uid = (Uid_t)va_arg(ap, int);
454 #else
455                     uid = va_arg(ap, Uid_t);
456 #endif
457                     retptr = getpwuid(uid); break;
458                 case OP_GPWENT:
459                     retptr = getpwent(); break;
460                 default:
461                     SETERRNO(ERANGE, LIB_INVARG);
462                     break;
463                 }
464             }
465         }
466         break;
467 #endif
468 #ifdef USE_PROTOENT_BUFFER
469     case OP_GPBYNAME:
470     case OP_GPBYNUMBER:
471     case OP_GPROTOENT:
472         {
473 #ifdef PERL_REENTRANT_MAXSIZE
474             if (PL_reentrant_buffer->_protoent_size <=
475                 PERL_REENTRANT_MAXSIZE / 2)
476 #endif
477             {
478                 PL_reentrant_buffer->_protoent_size *= 2;
479                 Renew(PL_reentrant_buffer->_protoent_buffer,
480                       PL_reentrant_buffer->_protoent_size, char);
481                 switch (PL_op->op_type) {
482                 case OP_GPBYNAME:
483                     p0 = va_arg(ap, void *);
484                     retptr = getprotobyname((char *)p0); break;
485                 case OP_GPBYNUMBER:
486                     anint = va_arg(ap, int);
487                     retptr = getprotobynumber(anint); break;
488                 case OP_GPROTOENT:
489                     retptr = getprotoent(); break;
490                 default:
491                     SETERRNO(ERANGE, LIB_INVARG);
492                     break;
493                 }
494             }
495         }
496         break;
497 #endif
498 #ifdef USE_SERVENT_BUFFER
499     case OP_GSBYNAME:
500     case OP_GSBYPORT:
501     case OP_GSERVENT:
502         {
503 #ifdef PERL_REENTRANT_MAXSIZE
504             if (PL_reentrant_buffer->_servent_size <=
505                 PERL_REENTRANT_MAXSIZE / 2)
506 #endif
507             {
508                 PL_reentrant_buffer->_servent_size *= 2;
509                 Renew(PL_reentrant_buffer->_servent_buffer,
510                       PL_reentrant_buffer->_servent_size, char);
511                 switch (PL_op->op_type) {
512                 case OP_GSBYNAME:
513                     p0 = va_arg(ap, void *);
514                     p1 = va_arg(ap, void *);
515                     retptr = getservbyname((char *)p0, (char *)p1); break;
516                 case OP_GSBYPORT:
517                     anint = va_arg(ap, int);
518                     p0 = va_arg(ap, void *);
519                     retptr = getservbyport(anint, (char *)p0); break;
520                 case OP_GSERVENT:
521                     retptr = getservent(); break;
522                 default:
523                     SETERRNO(ERANGE, LIB_INVARG);
524                     break;
525                 }
526             }
527         }
528         break;
529 #endif
530     default:
531         /* Not known how to retry, so just fail. */
532         break;
533     }
534
535     va_end(ap);
536 #endif
537     return retptr;
538 }
539
540 /* ex: set ro: */