gv.c:require_tie_mod: Create namesv only when needed
[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
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 void
37 Perl_reentrant_size(pTHX) {
38         PERL_UNUSED_CONTEXT;
39 #ifdef USE_REENTRANT_API
40 #define REENTRANTSMALLSIZE       256    /* Make something up. */
41 #define REENTRANTUSUALSIZE      4096    /* Make something up. */
42 #ifdef HAS_ASCTIME_R
43         PL_reentrant_buffer->_asctime_size = REENTRANTSMALLSIZE;
44 #endif /* HAS_ASCTIME_R */
45 #ifdef HAS_CRYPT_R
46 #endif /* HAS_CRYPT_R */
47 #ifdef HAS_CTIME_R
48         PL_reentrant_buffer->_ctime_size = REENTRANTSMALLSIZE;
49 #endif /* HAS_CTIME_R */
50 #ifdef HAS_GETGRNAM_R
51 #   if defined(HAS_SYSCONF) && defined(_SC_GETGR_R_SIZE_MAX) && !defined(__GLIBC__)
52         PL_reentrant_buffer->_grent_size = sysconf(_SC_GETGR_R_SIZE_MAX);
53         if (PL_reentrant_buffer->_grent_size == (size_t) -1)
54                 PL_reentrant_buffer->_grent_size = REENTRANTUSUALSIZE;
55 #   else
56 #       if defined(__osf__) && defined(__alpha) && defined(SIABUFSIZ)
57         PL_reentrant_buffer->_grent_size = SIABUFSIZ;
58 #       else
59 #           ifdef __sgi
60         PL_reentrant_buffer->_grent_size = BUFSIZ;
61 #           else
62         PL_reentrant_buffer->_grent_size = REENTRANTUSUALSIZE;
63 #           endif
64 #       endif
65 #   endif 
66 #endif /* HAS_GETGRNAM_R */
67 #ifdef HAS_GETHOSTBYNAME_R
68 #if   !(GETHOSTBYNAME_R_PROTO == REENTRANT_PROTO_I_CSD)
69         PL_reentrant_buffer->_hostent_size = REENTRANTUSUALSIZE;
70 #endif
71 #endif /* HAS_GETHOSTBYNAME_R */
72 #ifdef HAS_GETLOGIN_R
73         PL_reentrant_buffer->_getlogin_size = REENTRANTSMALLSIZE;
74 #endif /* HAS_GETLOGIN_R */
75 #ifdef HAS_GETNETBYNAME_R
76 #if   !(GETNETBYNAME_R_PROTO == REENTRANT_PROTO_I_CSD)
77         PL_reentrant_buffer->_netent_size = REENTRANTUSUALSIZE;
78 #endif
79 #endif /* HAS_GETNETBYNAME_R */
80 #ifdef HAS_GETPROTOBYNAME_R
81 #if   !(GETPROTOBYNAME_R_PROTO == REENTRANT_PROTO_I_CSD)
82         PL_reentrant_buffer->_protoent_size = REENTRANTUSUALSIZE;
83 #endif
84 #endif /* HAS_GETPROTOBYNAME_R */
85 #ifdef HAS_GETPWNAM_R
86 #   if defined(HAS_SYSCONF) && defined(_SC_GETPW_R_SIZE_MAX) && !defined(__GLIBC__)
87         PL_reentrant_buffer->_pwent_size = sysconf(_SC_GETPW_R_SIZE_MAX);
88         if (PL_reentrant_buffer->_pwent_size == (size_t) -1)
89                 PL_reentrant_buffer->_pwent_size = REENTRANTUSUALSIZE;
90 #   else
91 #       if defined(__osf__) && defined(__alpha) && defined(SIABUFSIZ)
92         PL_reentrant_buffer->_pwent_size = SIABUFSIZ;
93 #       else
94 #           ifdef __sgi
95         PL_reentrant_buffer->_pwent_size = BUFSIZ;
96 #           else
97         PL_reentrant_buffer->_pwent_size = REENTRANTUSUALSIZE;
98 #           endif
99 #       endif
100 #   endif 
101 #endif /* HAS_GETPWNAM_R */
102 #ifdef HAS_GETSERVBYNAME_R
103 #if   !(GETSERVBYNAME_R_PROTO == REENTRANT_PROTO_I_CCSD)
104         PL_reentrant_buffer->_servent_size = REENTRANTUSUALSIZE;
105 #endif
106 #endif /* HAS_GETSERVBYNAME_R */
107 #ifdef HAS_GETSPNAM_R
108 #   if defined(HAS_SYSCONF) && defined(_SC_GETPW_R_SIZE_MAX) && !defined(__GLIBC__)
109         PL_reentrant_buffer->_spent_size = sysconf(_SC_GETPW_R_SIZE_MAX);
110         if (PL_reentrant_buffer->_spent_size == (size_t) -1)
111                 PL_reentrant_buffer->_spent_size = REENTRANTUSUALSIZE;
112 #   else
113 #       if defined(__osf__) && defined(__alpha) && defined(SIABUFSIZ)
114         PL_reentrant_buffer->_spent_size = SIABUFSIZ;
115 #       else
116 #           ifdef __sgi
117         PL_reentrant_buffer->_spent_size = BUFSIZ;
118 #           else
119         PL_reentrant_buffer->_spent_size = REENTRANTUSUALSIZE;
120 #           endif
121 #       endif
122 #   endif 
123 #endif /* HAS_GETSPNAM_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_STRERROR_R
138         PL_reentrant_buffer->_strerror_size = REENTRANTSMALLSIZE;
139 #endif /* HAS_STRERROR_R */
140 #ifdef HAS_TTYNAME_R
141         PL_reentrant_buffer->_ttyname_size = REENTRANTSMALLSIZE;
142 #endif /* HAS_TTYNAME_R */
143
144 #endif /* USE_REENTRANT_API */
145 }
146
147 void
148 Perl_reentrant_init(pTHX) {
149         PERL_UNUSED_CONTEXT;
150 #ifdef USE_REENTRANT_API
151         Newx(PL_reentrant_buffer, 1, REENTR);
152         Perl_reentrant_size(aTHX);
153 #ifdef HAS_ASCTIME_R
154         Newx(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         Newx(PL_reentrant_buffer->_ctime_buffer, PL_reentrant_buffer->_ctime_size, char);
163 #endif /* HAS_CTIME_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_READDIR_R
206         PL_reentrant_buffer->_readdir_struct = (struct dirent*)safemalloc(PL_reentrant_buffer->_readdir_size);
207 #endif /* HAS_READDIR_R */
208 #ifdef HAS_READDIR64_R
209         PL_reentrant_buffer->_readdir64_struct = (struct dirent64*)safemalloc(PL_reentrant_buffer->_readdir64_size);
210 #endif /* HAS_READDIR64_R */
211 #ifdef HAS_SETLOCALE_R
212         Newx(PL_reentrant_buffer->_setlocale_buffer, PL_reentrant_buffer->_setlocale_size, char);
213 #endif /* HAS_SETLOCALE_R */
214 #ifdef HAS_STRERROR_R
215         Newx(PL_reentrant_buffer->_strerror_buffer, PL_reentrant_buffer->_strerror_size, char);
216 #endif /* HAS_STRERROR_R */
217 #ifdef HAS_TTYNAME_R
218         Newx(PL_reentrant_buffer->_ttyname_buffer, PL_reentrant_buffer->_ttyname_size, char);
219 #endif /* HAS_TTYNAME_R */
220
221 #endif /* USE_REENTRANT_API */
222 }
223
224 void
225 Perl_reentrant_free(pTHX) {
226         PERL_UNUSED_CONTEXT;
227 #ifdef USE_REENTRANT_API
228 #ifdef HAS_ASCTIME_R
229         Safefree(PL_reentrant_buffer->_asctime_buffer);
230 #endif /* HAS_ASCTIME_R */
231 #ifdef HAS_CRYPT_R
232 #if CRYPT_R_PROTO != REENTRANT_PROTO_B_CCD
233         Safefree(PL_reentrant_buffer->_crypt_struct_buffer);
234 #endif
235 #endif /* HAS_CRYPT_R */
236 #ifdef HAS_CTIME_R
237         Safefree(PL_reentrant_buffer->_ctime_buffer);
238 #endif /* HAS_CTIME_R */
239 #ifdef HAS_GETGRNAM_R
240         Safefree(PL_reentrant_buffer->_grent_buffer);
241 #endif /* HAS_GETGRNAM_R */
242 #ifdef HAS_GETHOSTBYNAME_R
243 #if   !(GETHOSTBYNAME_R_PROTO == REENTRANT_PROTO_I_CSD)
244         Safefree(PL_reentrant_buffer->_hostent_buffer);
245 #endif
246 #endif /* HAS_GETHOSTBYNAME_R */
247 #ifdef HAS_GETLOGIN_R
248         Safefree(PL_reentrant_buffer->_getlogin_buffer);
249 #endif /* HAS_GETLOGIN_R */
250 #ifdef HAS_GETNETBYNAME_R
251 #if   !(GETNETBYNAME_R_PROTO == REENTRANT_PROTO_I_CSD)
252         Safefree(PL_reentrant_buffer->_netent_buffer);
253 #endif
254 #endif /* HAS_GETNETBYNAME_R */
255 #ifdef HAS_GETPROTOBYNAME_R
256 #if   !(GETPROTOBYNAME_R_PROTO == REENTRANT_PROTO_I_CSD)
257         Safefree(PL_reentrant_buffer->_protoent_buffer);
258 #endif
259 #endif /* HAS_GETPROTOBYNAME_R */
260 #ifdef HAS_GETPWNAM_R
261         Safefree(PL_reentrant_buffer->_pwent_buffer);
262 #endif /* HAS_GETPWNAM_R */
263 #ifdef HAS_GETSERVBYNAME_R
264 #if   !(GETSERVBYNAME_R_PROTO == REENTRANT_PROTO_I_CCSD)
265         Safefree(PL_reentrant_buffer->_servent_buffer);
266 #endif
267 #endif /* HAS_GETSERVBYNAME_R */
268 #ifdef HAS_GETSPNAM_R
269         Safefree(PL_reentrant_buffer->_spent_buffer);
270 #endif /* HAS_GETSPNAM_R */
271 #ifdef HAS_READDIR_R
272         Safefree(PL_reentrant_buffer->_readdir_struct);
273 #endif /* HAS_READDIR_R */
274 #ifdef HAS_READDIR64_R
275         Safefree(PL_reentrant_buffer->_readdir64_struct);
276 #endif /* HAS_READDIR64_R */
277 #ifdef HAS_SETLOCALE_R
278         Safefree(PL_reentrant_buffer->_setlocale_buffer);
279 #endif /* HAS_SETLOCALE_R */
280 #ifdef HAS_STRERROR_R
281         Safefree(PL_reentrant_buffer->_strerror_buffer);
282 #endif /* HAS_STRERROR_R */
283 #ifdef HAS_TTYNAME_R
284         Safefree(PL_reentrant_buffer->_ttyname_buffer);
285 #endif /* HAS_TTYNAME_R */
286
287         Safefree(PL_reentrant_buffer);
288 #endif /* USE_REENTRANT_API */
289 }
290
291 void*
292 Perl_reentrant_retry(const char *f, ...)
293 {
294     void *retptr = NULL;
295     va_list ap;
296 #ifdef USE_REENTRANT_API
297     dTHX;
298     /* Easier to special case this here than in embed.pl. (Look at what it
299        generates for proto.h) */
300     PERL_ARGS_ASSERT_REENTRANT_RETRY;
301 #endif
302     va_start(ap, f);
303     {
304 #ifdef USE_REENTRANT_API
305 #  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)
306     void *p0;
307 #  endif
308 #  if defined(USE_SERVENT_BUFFER)
309     void *p1;
310 #  endif
311 #  if defined(USE_HOSTENT_BUFFER)
312     size_t asize;
313 #  endif
314 #  if defined(USE_HOSTENT_BUFFER) || defined(USE_NETENT_BUFFER) || defined(USE_PROTOENT_BUFFER) || defined(USE_SERVENT_BUFFER)
315     int anint;
316 #  endif
317
318     switch (PL_op->op_type) {
319 #ifdef USE_HOSTENT_BUFFER
320     case OP_GHBYADDR:
321     case OP_GHBYNAME:
322     case OP_GHOSTENT:
323         {
324 #ifdef PERL_REENTRANT_MAXSIZE
325             if (PL_reentrant_buffer->_hostent_size <=
326                 PERL_REENTRANT_MAXSIZE / 2)
327 #endif
328             {
329                 PL_reentrant_buffer->_hostent_size *= 2;
330                 Renew(PL_reentrant_buffer->_hostent_buffer,
331                       PL_reentrant_buffer->_hostent_size, char);
332                 switch (PL_op->op_type) {
333                 case OP_GHBYADDR:
334                     p0    = va_arg(ap, void *);
335                     asize = va_arg(ap, size_t);
336                     anint  = va_arg(ap, int);
337                     retptr = gethostbyaddr(p0, asize, anint); break;
338                 case OP_GHBYNAME:
339                     p0 = va_arg(ap, void *);
340                     retptr = gethostbyname((char *)p0); break;
341                 case OP_GHOSTENT:
342                     retptr = gethostent(); break;
343                 default:
344                     SETERRNO(ERANGE, LIB_INVARG);
345                     break;
346                 }
347             }
348         }
349         break;
350 #endif
351 #ifdef USE_GRENT_BUFFER
352     case OP_GGRNAM:
353     case OP_GGRGID:
354     case OP_GGRENT:
355         {
356 #ifdef PERL_REENTRANT_MAXSIZE
357             if (PL_reentrant_buffer->_grent_size <=
358                 PERL_REENTRANT_MAXSIZE / 2)
359 #endif
360             {
361                 Gid_t gid;
362                 PL_reentrant_buffer->_grent_size *= 2;
363                 Renew(PL_reentrant_buffer->_grent_buffer,
364                       PL_reentrant_buffer->_grent_size, char);
365                 switch (PL_op->op_type) {
366                 case OP_GGRNAM:
367                     p0 = va_arg(ap, void *);
368                     retptr = getgrnam((char *)p0); break;
369                 case OP_GGRGID:
370 #if Gid_t_size < INTSIZE
371                     gid = (Gid_t)va_arg(ap, int);
372 #else
373                     gid = va_arg(ap, Gid_t);
374 #endif
375                     retptr = getgrgid(gid); break;
376                 case OP_GGRENT:
377                     retptr = getgrent(); break;
378                 default:
379                     SETERRNO(ERANGE, LIB_INVARG);
380                     break;
381                 }
382             }
383         }
384         break;
385 #endif
386 #ifdef USE_NETENT_BUFFER
387     case OP_GNBYADDR:
388     case OP_GNBYNAME:
389     case OP_GNETENT:
390         {
391 #ifdef PERL_REENTRANT_MAXSIZE
392             if (PL_reentrant_buffer->_netent_size <=
393                 PERL_REENTRANT_MAXSIZE / 2)
394 #endif
395             {
396                 Netdb_net_t net;
397                 PL_reentrant_buffer->_netent_size *= 2;
398                 Renew(PL_reentrant_buffer->_netent_buffer,
399                       PL_reentrant_buffer->_netent_size, char);
400                 switch (PL_op->op_type) {
401                 case OP_GNBYADDR:
402                     net = va_arg(ap, Netdb_net_t);
403                     anint = va_arg(ap, int);
404                     retptr = getnetbyaddr(net, anint); break;
405                 case OP_GNBYNAME:
406                     p0 = va_arg(ap, void *);
407                     retptr = getnetbyname((char *)p0); break;
408                 case OP_GNETENT:
409                     retptr = getnetent(); break;
410                 default:
411                     SETERRNO(ERANGE, LIB_INVARG);
412                     break;
413                 }
414             }
415         }
416         break;
417 #endif
418 #ifdef USE_PWENT_BUFFER
419     case OP_GPWNAM:
420     case OP_GPWUID:
421     case OP_GPWENT:
422         {
423 #ifdef PERL_REENTRANT_MAXSIZE
424             if (PL_reentrant_buffer->_pwent_size <=
425                 PERL_REENTRANT_MAXSIZE / 2)
426 #endif
427             {
428                 Uid_t uid;
429                 PL_reentrant_buffer->_pwent_size *= 2;
430                 Renew(PL_reentrant_buffer->_pwent_buffer,
431                       PL_reentrant_buffer->_pwent_size, char);
432                 switch (PL_op->op_type) {
433                 case OP_GPWNAM:
434                     p0 = va_arg(ap, void *);
435                     retptr = getpwnam((char *)p0); break;
436                 case OP_GPWUID:
437 #if Uid_t_size < INTSIZE
438                     uid = (Uid_t)va_arg(ap, int);
439 #else
440                     uid = va_arg(ap, Uid_t);
441 #endif
442                     retptr = getpwuid(uid); break;
443 #if defined(HAS_GETPWENT) || defined(HAS_GETPWENT_R)
444                 case OP_GPWENT:
445                     retptr = getpwent(); break;
446 #endif
447                 default:
448                     SETERRNO(ERANGE, LIB_INVARG);
449                     break;
450                 }
451             }
452         }
453         break;
454 #endif
455 #ifdef USE_PROTOENT_BUFFER
456     case OP_GPBYNAME:
457     case OP_GPBYNUMBER:
458     case OP_GPROTOENT:
459         {
460 #ifdef PERL_REENTRANT_MAXSIZE
461             if (PL_reentrant_buffer->_protoent_size <=
462                 PERL_REENTRANT_MAXSIZE / 2)
463 #endif
464             {
465                 PL_reentrant_buffer->_protoent_size *= 2;
466                 Renew(PL_reentrant_buffer->_protoent_buffer,
467                       PL_reentrant_buffer->_protoent_size, char);
468                 switch (PL_op->op_type) {
469                 case OP_GPBYNAME:
470                     p0 = va_arg(ap, void *);
471                     retptr = getprotobyname((char *)p0); break;
472                 case OP_GPBYNUMBER:
473                     anint = va_arg(ap, int);
474                     retptr = getprotobynumber(anint); break;
475                 case OP_GPROTOENT:
476                     retptr = getprotoent(); break;
477                 default:
478                     SETERRNO(ERANGE, LIB_INVARG);
479                     break;
480                 }
481             }
482         }
483         break;
484 #endif
485 #ifdef USE_SERVENT_BUFFER
486     case OP_GSBYNAME:
487     case OP_GSBYPORT:
488     case OP_GSERVENT:
489         {
490 #ifdef PERL_REENTRANT_MAXSIZE
491             if (PL_reentrant_buffer->_servent_size <=
492                 PERL_REENTRANT_MAXSIZE / 2)
493 #endif
494             {
495                 PL_reentrant_buffer->_servent_size *= 2;
496                 Renew(PL_reentrant_buffer->_servent_buffer,
497                       PL_reentrant_buffer->_servent_size, char);
498                 switch (PL_op->op_type) {
499                 case OP_GSBYNAME:
500                     p0 = va_arg(ap, void *);
501                     p1 = va_arg(ap, void *);
502                     retptr = getservbyname((char *)p0, (char *)p1); break;
503                 case OP_GSBYPORT:
504                     anint = va_arg(ap, int);
505                     p0 = va_arg(ap, void *);
506                     retptr = getservbyport(anint, (char *)p0); break;
507                 case OP_GSERVENT:
508                     retptr = getservent(); break;
509                 default:
510                     SETERRNO(ERANGE, LIB_INVARG);
511                     break;
512                 }
513             }
514         }
515         break;
516 #endif
517     default:
518         /* Not known how to retry, so just fail. */
519         break;
520     }
521 #else
522     PERL_UNUSED_ARG(f);
523 #endif
524     }
525     va_end(ap);
526     return retptr;
527 }
528
529 /* ex: set ro: */