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