Move non-constant folding parts of fold_constants into a separate functions.
[perl.git] / cygwin / cygwin.c
1 /*
2  * Cygwin extras
3  */
4
5 #include "EXTERN.h"
6 #include "perl.h"
7 #undef USE_DYNAMIC_LOADING
8 #include "XSUB.h"
9
10 #include <unistd.h>
11 #include <process.h>
12 #include <sys/cygwin.h>
13 #include <mntent.h>
14 #include <alloca.h>
15 #include <dlfcn.h>
16
17 /*
18  * pp_system() implemented via spawn()
19  * - more efficient and useful when embedding Perl in non-Cygwin apps
20  * - code mostly borrowed from djgpp.c
21  */
22 static int
23 do_spawnvp (const char *path, const char * const *argv)
24 {
25     dTHX;
26     Sigsave_t ihand,qhand;
27     int childpid, result, status;
28
29     rsignal_save(SIGINT, (Sighandler_t) SIG_IGN, &ihand);
30     rsignal_save(SIGQUIT, (Sighandler_t) SIG_IGN, &qhand);
31     childpid = spawnvp(_P_NOWAIT,path,argv);
32     if (childpid < 0) {
33         status = -1;
34         if(ckWARN(WARN_EXEC))
35             Perl_warner(aTHX_ packWARN(WARN_EXEC),"Can't spawn \"%s\": %s",
36                     path,Strerror (errno));
37     } else {
38         do {
39             result = wait4pid(childpid, &status, 0);
40         } while (result == -1 && errno == EINTR);
41         if(result < 0)
42             status = -1;
43     }
44     (void)rsignal_restore(SIGINT, &ihand);
45     (void)rsignal_restore(SIGQUIT, &qhand);
46     return status;
47 }
48
49 int
50 do_aspawn (SV *really, void **mark, void **sp)
51 {
52     dTHX;
53     int  rc;
54     char const **a;
55     char *tmps,**argv;
56     STRLEN n_a;
57
58     if (sp<=mark)
59         return -1;
60     argv=(char**) alloca ((sp-mark+3)*sizeof (char*));
61     a=(char const **)argv;
62
63     while (++mark <= sp)
64         if (*mark)
65             *a++ = SvPVx((SV *)*mark, n_a);
66         else
67             *a++ = "";
68     *a = (char*)NULL;
69
70     if (argv[0][0] != '/' && argv[0][0] != '\\'
71         && !(argv[0][0] && argv[0][1] == ':'
72         && (argv[0][2] == '/' || argv[0][2] != '\\'))
73      ) /* will swawnvp use PATH? */
74          TAINT_ENV();   /* testing IFS here is overkill, probably */
75
76     if (really && *(tmps = SvPV(really, n_a)))
77         rc=do_spawnvp (tmps,(const char * const *)argv);
78     else
79         rc=do_spawnvp (argv[0],(const char *const *)argv);
80
81     return rc;
82 }
83
84 int
85 do_spawn (char *cmd)
86 {
87     dTHX;
88     char const **a;
89     char *s;
90     char const *metachars = "$&*(){}[]'\";\\?>|<~`\n";
91     const char *command[4];
92
93     while (*cmd && isSPACE(*cmd))
94         cmd++;
95
96     if (strnEQ (cmd,"/bin/sh",7) && isSPACE (cmd[7]))
97         cmd+=5;
98
99     /* save an extra exec if possible */
100     /* see if there are shell metacharacters in it */
101     if (strstr (cmd,"..."))
102         goto doshell;
103     if (*cmd=='.' && isSPACE (cmd[1]))
104         goto doshell;
105     if (strnEQ (cmd,"exec",4) && isSPACE (cmd[4]))
106         goto doshell;
107     for (s=cmd; *s && isALPHA (*s); s++) ;      /* catch VAR=val gizmo */
108         if (*s=='=')
109             goto doshell;
110
111     for (s=cmd; *s; s++)
112         if (strchr (metachars,*s))
113         {
114             if (*s=='\n' && s[1]=='\0')
115             {
116                 *s='\0';
117                 break;
118             }
119         doshell:
120             command[0] = "sh";
121             command[1] = "-c";
122             command[2] = cmd;
123             command[3] = NULL;
124
125             return do_spawnvp("sh",command);
126         }
127
128     Newx (PL_Argv,(s-cmd)/2+2,const char*);
129     PL_Cmd=savepvn (cmd,s-cmd);
130     a=PL_Argv;
131     for (s=PL_Cmd; *s;) {
132         while (*s && isSPACE (*s)) s++;
133         if (*s)
134             *(a++)=s;
135         while (*s && !isSPACE (*s)) s++;
136         if (*s)
137             *s++='\0';
138     }
139     *a = (char*)NULL;
140     if (!PL_Argv[0])
141         return -1;
142
143     return do_spawnvp(PL_Argv[0],(const char * const *)PL_Argv);
144 }
145
146 /* see also Cwd.pm */
147 XS(Cygwin_cwd)
148 {
149     dXSARGS;
150     char *cwd;
151
152     /* See http://rt.perl.org/rt3/Ticket/Display.html?id=38628 
153        There is Cwd->cwd() usage in the wild, and previous versions didn't die.
154      */
155     if(items > 1)
156         Perl_croak(aTHX_ "Usage: Cwd::cwd()");
157     if((cwd = getcwd(NULL, -1))) {
158         ST(0) = sv_2mortal(newSVpv(cwd, 0));
159         free(cwd);
160 #ifndef INCOMPLETE_TAINTS
161         SvTAINTED_on(ST(0));
162 #endif
163         XSRETURN(1);
164     }
165     XSRETURN_UNDEF;
166 }
167
168 XS(XS_Cygwin_pid_to_winpid)
169 {
170     dXSARGS;
171     dXSTARG;
172     pid_t pid, RETVAL;
173
174     if (items != 1)
175         Perl_croak(aTHX_ "Usage: Cygwin::pid_to_winpid(pid)");
176
177     pid = (pid_t)SvIV(ST(0));
178
179     if ((RETVAL = cygwin_internal(CW_CYGWIN_PID_TO_WINPID, pid)) > 0) {
180         XSprePUSH; PUSHi((IV)RETVAL);
181         XSRETURN(1);
182     }
183     XSRETURN_UNDEF;
184 }
185
186 XS(XS_Cygwin_winpid_to_pid)
187 {
188     dXSARGS;
189     dXSTARG;
190     pid_t pid, RETVAL;
191
192     if (items != 1)
193         Perl_croak(aTHX_ "Usage: Cygwin::winpid_to_pid(pid)");
194
195     pid = (pid_t)SvIV(ST(0));
196
197     if ((RETVAL = cygwin32_winpid_to_pid(pid)) > 0) {
198         XSprePUSH; PUSHi((IV)RETVAL);
199         XSRETURN(1);
200     }
201     XSRETURN_UNDEF;
202 }
203
204 XS(XS_Cygwin_win_to_posix_path)
205 {
206     dXSARGS;
207     int absolute_flag = 0;
208     STRLEN len;
209     int err;
210     char *pathname, *buf;
211
212     if (items < 1 || items > 2)
213         Perl_croak(aTHX_ "Usage: Cygwin::win_to_posix_path(pathname, [absolute])");
214
215     pathname = SvPV(ST(0), len);
216     if (items == 2)
217         absolute_flag = SvTRUE(ST(1));
218
219     if (!len)
220         Perl_croak(aTHX_ "can't convert empty path");
221     buf = (char *) safemalloc (len + 260 + 1001);
222
223     if (absolute_flag)
224         err = cygwin_conv_to_full_posix_path(pathname, buf);
225     else
226         err = cygwin_conv_to_posix_path(pathname, buf);
227     if (!err) {
228         ST(0) = sv_2mortal(newSVpv(buf, 0));
229         safefree(buf);
230        XSRETURN(1);
231     } else {
232         safefree(buf);
233         XSRETURN_UNDEF;
234     }
235 }
236
237 XS(XS_Cygwin_posix_to_win_path)
238 {
239     dXSARGS;
240     int absolute_flag = 0;
241     STRLEN len;
242     int err;
243     char *pathname, *buf;
244
245     if (items < 1 || items > 2)
246         Perl_croak(aTHX_ "Usage: Cygwin::posix_to_win_path(pathname, [absolute])");
247
248     pathname = SvPV(ST(0), len);
249     if (items == 2)
250         absolute_flag = SvTRUE(ST(1));
251
252     if (!len)
253         Perl_croak(aTHX_ "can't convert empty path");
254     buf = (char *) safemalloc(len + 260 + 1001);
255
256     if (absolute_flag)
257         err = cygwin_conv_to_full_win32_path(pathname, buf);
258     else
259         err = cygwin_conv_to_win32_path(pathname, buf);
260     if (!err) {
261         ST(0) = sv_2mortal(newSVpv(buf, 0));
262         safefree(buf);
263        XSRETURN(1);
264     } else {
265         safefree(buf);
266         XSRETURN_UNDEF;
267     }
268 }
269
270 XS(XS_Cygwin_mount_table)
271 {
272     dXSARGS;
273     struct mntent *mnt;
274
275     if (items != 0)
276         Perl_croak(aTHX_ "Usage: Cygwin::mount_table");
277     /* => array of [mnt_dir mnt_fsname mnt_type mnt_opts] */
278
279     setmntent (0, 0);
280     while ((mnt = getmntent (0))) {
281         AV* av = newAV();
282         av_push(av, newSVpvn(mnt->mnt_dir, strlen(mnt->mnt_dir)));
283         av_push(av, newSVpvn(mnt->mnt_fsname, strlen(mnt->mnt_fsname)));
284         av_push(av, newSVpvn(mnt->mnt_type, strlen(mnt->mnt_type)));
285         av_push(av, newSVpvn(mnt->mnt_opts, strlen(mnt->mnt_opts)));
286         XPUSHs(sv_2mortal(newRV_noinc((SV*)av)));
287     }
288     endmntent (0);
289     PUTBACK;
290 }
291
292 XS(XS_Cygwin_mount_flags)
293 {
294     dXSARGS;
295     char *pathname;
296     char flags[260];
297
298     if (items != 1)
299         Perl_croak(aTHX_ "Usage: Cygwin::mount_flags(mnt_dir|'/cygwin')");
300
301     pathname = SvPV_nolen(ST(0));
302
303     /* TODO: Check for cygdrive registry setting,
304      *       and then use CW_GET_CYGDRIVE_INFO
305      */
306     if (!strcmp(pathname, "/cygdrive")) {
307         char user[260];
308         char system[260];
309         char user_flags[260];
310         char system_flags[260];
311
312         cygwin_internal (CW_GET_CYGDRIVE_INFO, user, system, user_flags,
313                          system_flags);
314
315         if (strlen(user) > 0) {
316             sprintf(flags, "%s,cygdrive,%s", user_flags, user);
317         } else {
318             sprintf(flags, "%s,cygdrive,%s", system_flags, system);
319         }
320
321         ST(0) = sv_2mortal(newSVpv(flags, 0));
322         XSRETURN(1);
323
324     } else {
325         struct mntent *mnt;
326         setmntent (0, 0);
327         while ((mnt = getmntent (0))) {
328             if (!strcmp(pathname, mnt->mnt_dir)) {
329                 strcpy(flags, mnt->mnt_type);
330                 if (strlen(mnt->mnt_opts) > 0) {
331                     strcat(flags, ",");
332                     strcat(flags, mnt->mnt_opts);
333                 }
334                 break;
335             }
336         }
337         endmntent (0);
338         ST(0) = sv_2mortal(newSVpv(flags, 0));
339         XSRETURN(1);
340     }
341 }
342
343 XS(XS_Cygwin_is_binmount)
344 {
345     dXSARGS;
346     char *pathname;
347
348     if (items != 1)
349         Perl_croak(aTHX_ "Usage: Cygwin::is_binmount(pathname)");
350
351     pathname = SvPV_nolen(ST(0));
352
353     ST(0) = boolSV(cygwin_internal(CW_GET_BINMODE, pathname));
354     XSRETURN(1);
355 }
356
357 void
358 init_os_extras(void)
359 {
360     dTHX;
361     char const *file = __FILE__;
362     void *handle;
363
364     newXS("Cwd::cwd", Cygwin_cwd, file);
365     newXSproto("Cygwin::winpid_to_pid", XS_Cygwin_winpid_to_pid, file, "$");
366     newXSproto("Cygwin::pid_to_winpid", XS_Cygwin_pid_to_winpid, file, "$");
367     newXSproto("Cygwin::win_to_posix_path", XS_Cygwin_win_to_posix_path, file, "$;$");
368     newXSproto("Cygwin::posix_to_win_path", XS_Cygwin_posix_to_win_path, file, "$;$");
369     newXSproto("Cygwin::mount_table", XS_Cygwin_mount_table, file, "");
370     newXSproto("Cygwin::mount_flags", XS_Cygwin_mount_flags, file, "$");
371     newXSproto("Cygwin::is_binmount", XS_Cygwin_is_binmount, file, "$");
372
373     /* Initialize Win32CORE if it has been statically linked. */
374     handle = dlopen(NULL, RTLD_LAZY);
375     if (handle) {
376         void (*pfn_init)(pTHX);
377         pfn_init = (void (*)(pTHX))dlsym(handle, "init_Win32CORE");
378         if (pfn_init)
379             pfn_init(aTHX);
380         dlclose(handle);
381     }
382 }