This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
amigaos4: minimized config.sh
[perl5.git] / amigaos4 / amigaos.c
1 /* amigaos.c uses only amigaos APIs,
2  * as opposed to amigaio.c which mixes amigaos and perl APIs */
3
4 #include <string.h>
5
6 #include <sys/stat.h>
7 #include <unistd.h>
8 #include <assert.h>
9
10 #include <errno.h>
11 #include <stdio.h>
12 #include <stdlib.h>
13 #if defined(__CLIB2__)
14 #  include <dos.h>
15 #endif
16 #if defined(__NEWLIB__)
17 #  include <amiga_platform.h>
18 #endif
19 #include <fcntl.h>
20 #include <ctype.h>
21 #include <stdarg.h>
22
23 #include <dos/dos.h>
24 #include <proto/dos.h>
25 #include <proto/exec.h>
26 #include <proto/utility.h>
27
28 #include "amigaos.h"
29
30 struct UtilityIFace *IUtility = NULL;
31
32 /***************************************************************************/
33
34 struct Interface *OpenInterface(CONST_STRPTR libname, uint32 libver)
35 {
36         struct Library *base = IExec->OpenLibrary(libname, libver);
37         struct Interface *iface = IExec->GetInterface(base, "main", 1, NULL);
38         if (iface == NULL)
39         {
40                 // We should probably post some kind of error message here.
41
42                 IExec->CloseLibrary(base);
43         }
44
45         return iface;
46 }
47
48 /***************************************************************************/
49
50 void CloseInterface(struct Interface *iface)
51 {
52         if (iface != NULL)
53         {
54                 struct Library *base = iface->Data.LibBase;
55                 IExec->DropInterface(iface);
56                 IExec->CloseLibrary(base);
57         }
58 }
59
60 BOOL __unlink_retries = FALSE;
61
62 void ___makeenviron() __attribute__((constructor));
63 void ___freeenviron() __attribute__((destructor));
64
65 void ___openinterfaces() __attribute__((constructor));
66 void ___closeinterfaces() __attribute__((destructor));
67
68 void ___openinterfaces()
69 {
70         if (!IDOS)
71                 IDOS = (struct DOSIFace *)OpenInterface("dos.library", 53);
72         if (!IUtility)
73                 IUtility =
74                     (struct UtilityIFace *)OpenInterface("utility.library", 53);
75 }
76
77 void ___closeinterfaces()
78 {
79         CloseInterface((struct Interface *)IDOS);
80         CloseInterface((struct Interface *)IUtility);
81 }
82 int VARARGS68K araddebug(UBYTE *fmt, ...);
83 int VARARGS68K adebug(UBYTE *fmt, ...);
84
85 #define __USE_RUNCOMMAND__
86
87 char **myenviron = NULL;
88 char **origenviron = NULL;
89
90 int myexecve(const char *path, char *argv[], char *envp[]);
91 static void createvars(char **envp);
92
93 struct args
94 {
95         BPTR seglist;
96         int stack;
97         char *command;
98         int length;
99         int result;
100         char **envp;
101 };
102
103 int __myrc(char *arg)
104 {
105         struct Task *thisTask = IExec->FindTask(0);
106         struct args *myargs = (struct args *)thisTask->tc_UserData;
107         if (myargs->envp)
108                 createvars(myargs->envp);
109         // adebug("%s %ld %s \n",__FUNCTION__,__LINE__,myargs->command);
110         myargs->result = IDOS->RunCommand(myargs->seglist, myargs->stack,
111                                           myargs->command, myargs->length);
112         return 0;
113 }
114
115 int32 myruncommand(
116     BPTR seglist, int stack, char *command, int length, char **envp)
117 {
118         struct args myargs;
119         struct Task *thisTask = IExec->FindTask(0);
120         struct Process *proc;
121
122         // adebug("%s %ld  %s\n",__FUNCTION__,__LINE__,command?command:"NULL");
123
124         myargs.seglist = seglist;
125         myargs.stack = stack;
126         myargs.command = command;
127         myargs.length = length;
128         myargs.result = -1;
129         myargs.envp = envp;
130
131         if ((proc = IDOS->CreateNewProcTags(
132                  NP_Entry, __myrc, NP_Child, TRUE, NP_Input, IDOS->Input(),
133                  NP_Output, IDOS->Output(), NP_Error, IDOS->ErrorOutput(),
134                  NP_CloseInput, FALSE, NP_CloseOutput, FALSE, NP_CloseError,
135                  FALSE, NP_CopyVars, FALSE,
136
137                  //           NP_StackSize,           ((struct Process
138                  //           *)myargs.parent)->pr_StackSize,
139                  NP_Cli, TRUE, NP_UserData, (int)&myargs,
140                  NP_NotifyOnDeathSigTask, thisTask, TAG_DONE)))
141
142         {
143                 IExec->Wait(SIGF_CHILD);
144         }
145         return myargs.result;
146 }
147
148 static char *mystrdup(const char *s)
149 {
150         char *result = NULL;
151         size_t size;
152
153         size = strlen(s) + 1;
154
155         if ((result = (char *)IExec->AllocVec(size, MEMF_ANY)))
156         {
157                 memmove(result, s, size);
158         }
159         return result;
160 }
161
162 static int pipenum = 0;
163
164 int pipe(int filedes[2])
165 {
166         char pipe_name[1024];
167
168 //   adebug("%s %ld \n",__FUNCTION__,__LINE__);
169 #ifdef USE_TEMPFILES
170         sprintf(pipe_name, "/T/%x.%08lx", pipenum++, IUtility->GetUniqueID());
171 #else
172         sprintf(pipe_name, "/PIPE/%x%08lx/4096/0", pipenum++,
173                 IUtility->GetUniqueID());
174 #endif
175
176         /*      printf("pipe: %s \n", pipe_name);*/
177
178         filedes[1] = open(pipe_name, O_WRONLY | O_CREAT);
179         filedes[0] = open(pipe_name, O_RDONLY);
180         if (filedes[0] == -1 || filedes[1] == -1)
181         {
182                 if (filedes[0] != -1)
183                         close(filedes[0]);
184                 if (filedes[1] != -1)
185                         close(filedes[1]);
186                 return -1;
187         }
188         /*      printf("filedes %d %d\n", filedes[0],
189          * filedes[1]);fflush(stdout);*/
190
191         return 0;
192 }
193
194 int fork(void)
195 {
196         fprintf(stderr, "Can not bloody fork\n");
197         errno = ENOMEM;
198         return -1;
199 }
200
201 int wait(int *status)
202 {
203         fprintf(stderr, "No wait try waitpid instead\n");
204         errno = ECHILD;
205         return -1;
206 }
207
208 char *convert_path_a2u(const char *filename)
209 {
210         struct NameTranslationInfo nti;
211
212         if (!filename)
213         {
214                 return 0;
215         }
216
217         __translate_amiga_to_unix_path_name(&filename, &nti);
218
219         return mystrdup(filename);
220 }
221 char *convert_path_u2a(const char *filename)
222 {
223         struct NameTranslationInfo nti;
224
225         if (!filename)
226         {
227                 return 0;
228         }
229
230         if (strcmp(filename, "/dev/tty") == 0)
231         {
232                 return mystrdup("CONSOLE:");
233                 ;
234         }
235
236         __translate_unix_to_amiga_path_name(&filename, &nti);
237
238         return mystrdup(filename);
239 }
240
241 static struct SignalSemaphore environ_sema;
242
243 void amigaos4_init_environ_sema() { IExec->InitSemaphore(&environ_sema); }
244
245 void amigaos4_obtain_environ() { IExec->ObtainSemaphore(&environ_sema); }
246
247 void amigaos4_release_environ() { IExec->ReleaseSemaphore(&environ_sema); }
248
249 static void createvars(char **envp)
250 {
251         if (envp)
252         {
253                 /* Set a local var to indicate to any subsequent sh that it is
254                 * not
255                 * the top level shell and so should only inherit local amigaos
256                 * vars */
257                 IDOS->SetVar("ABCSH_IMPORT_LOCAL", "TRUE", 5, GVF_LOCAL_ONLY);
258
259                 amigaos4_obtain_environ();
260
261                 envp = myenviron;
262
263                 while ((envp != NULL) && (*envp != NULL))
264                 {
265                         int len;
266                         char *var;
267                         char *val;
268                         if ((len = strlen(*envp)))
269                         {
270                                 if ((var = (char *)IExec->AllocVec(
271                                          len + 1, MEMF_ANY | MEMF_CLEAR)))
272                                 {
273                                         strcpy(var, *envp);
274
275                                         val = strchr(var, '=');
276                                         if (val)
277                                         {
278                                                 *val++ = '\0';
279                                                 if (*val)
280                                                 {
281                                                         IDOS->SetVar(
282                                                             var, val,
283                                                             strlen(val) + 1,
284                                                             GVF_LOCAL_ONLY);
285                                                 }
286                                         }
287                                         IExec->FreeVec(var);
288                                 }
289                         }
290                         envp++;
291                 }
292                 amigaos4_release_environ();
293         }
294 }
295
296 static BOOL contains_whitespace(char *string)
297 {
298
299         if (string)
300         {
301
302                 if (strchr(string, ' '))
303                         return TRUE;
304                 if (strchr(string, '\t'))
305                         return TRUE;
306                 if (strchr(string, '\n'))
307                         return TRUE;
308                 if (strchr(string, 0xA0))
309                         return TRUE;
310                 if (strchr(string, '"'))
311                         return TRUE;
312         }
313         return FALSE;
314 }
315
316 static int no_of_escapes(char *string)
317 {
318         int cnt = 0;
319         char *p;
320         for (p = string; p < string + strlen(string); p++)
321         {
322                 if (*p == '"')
323                         cnt++;
324                 if (*p == '*')
325                         cnt++;
326                 if (*p == '\n')
327                         cnt++;
328                 if (*p == '\t')
329                         cnt++;
330         }
331         return cnt;
332 }
333
334 struct command_data
335 {
336         STRPTR args;
337         BPTR seglist;
338         struct Task *parent;
339 };
340
341 int myexecvp(const char *filename, char *argv[])
342 {
343         //      adebug("%s %ld
344         //%s\n",__FUNCTION__,__LINE__,filename?filename:"NULL");
345         /* if there's a slash or a colon consider filename a path and skip
346          * search */
347         int res;
348         if ((strchr(filename, '/') == NULL) && (strchr(filename, ':') == NULL))
349         {
350                 char *path;
351                 char *name;
352                 char *pathpart;
353                 char *p;
354                 size_t len;
355                 struct stat st;
356
357                 if (!(path = getenv("PATH")))
358                 {
359                         path = ".:/bin:/usr/bin:/c";
360                 }
361
362                 len = strlen(filename) + 1;
363                 name = (char *)alloca(strlen(path) + len);
364                 pathpart = (char *)alloca(strlen(path) + 1);
365                 p = path;
366                 do
367                 {
368                         path = p;
369
370                         if (!(p = strchr(path, ':')))
371                         {
372                                 p = strchr(path, '\0');
373                         }
374
375                         memcpy(pathpart, path, p - path);
376                         pathpart[p - path] = '\0';
377                         if (!(strlen(pathpart) == 0))
378                         {
379                                 sprintf(name, "%s/%s", pathpart, filename);
380                         }
381                         else
382                                 sprintf(name, "%s", filename);
383
384                         if ((stat(name, &st) == 0) && (S_ISREG(st.st_mode)))
385                         {
386                                 /* we stated it and it's a regular file */
387                                 /* let's boogie! */
388                                 filename = name;
389                                 break;
390                         }
391
392                 } while (*p++ != '\0');
393         }
394         res = myexecve(filename, argv, myenviron);
395         return res;
396 }
397
398 int myexecv(const char *path, char *argv[])
399 {
400         return myexecve(path, argv, myenviron);
401 }
402
403 int myexecl(const char *path, ...)
404 {
405         va_list va;
406         char *argv[1024]; /* 1024 enough? let's hope so! */
407         int i = 0;
408         // adebug("%s %ld\n",__FUNCTION__,__LINE__);
409
410         va_start(va, path);
411         i = 0;
412
413         do
414         {
415                 argv[i] = va_arg(va, char *);
416         } while (argv[i++] != NULL);
417
418         va_end(va);
419         return myexecve(path, argv, myenviron);
420 }
421
422 int myexecve(const char *filename, char *argv[], char *envp[])
423 {
424         FILE *fh;
425         char buffer[1000];
426         int size = 0;
427         char **cur;
428         char *interpreter = 0;
429         char *interpreter_args = 0;
430         char *full = 0;
431         char *filename_conv = 0;
432         char *interpreter_conv = 0;
433         //        char *tmp = 0;
434         char *fname;
435         //        int tmpint;
436         //        struct Task *thisTask = IExec->FindTask(0);
437         int result = -1;
438
439         // adebug("%s %ld %s\n",__FUNCTION__,__LINE__,filename?filename:"NULL");
440
441         /* Calculate the size of filename and all args, including spaces and
442          * quotes */
443         size = 0; // strlen(filename) + 1;
444         for (cur = (char **)argv /* +1 */; *cur; cur++)
445         {
446                 size +=
447                     strlen(*cur) + 1 +
448                     (contains_whitespace(*cur) ? (2 + no_of_escapes(*cur)) : 0);
449         }
450         /* Check if it's a script file */
451
452         fh = fopen(filename, "r");
453         if (fh)
454         {
455                 if (fgetc(fh) == '#' && fgetc(fh) == '!')
456                 {
457                         char *p;
458                         char *q;
459                         fgets(buffer, 999, fh);
460                         p = buffer;
461                         while (*p == ' ' || *p == '\t')
462                                 p++;
463                         if (buffer[strlen(buffer) - 1] == '\n')
464                                 buffer[strlen(buffer) - 1] = '\0';
465                         if ((q = strchr(p, ' ')))
466                         {
467                                 *q++ = '\0';
468                                 if (*q != '\0')
469                                 {
470                                         interpreter_args = mystrdup(q);
471                                 }
472                         }
473                         else
474                                 interpreter_args = mystrdup("");
475
476                         interpreter = mystrdup(p);
477                         size += strlen(interpreter) + 1;
478                         size += strlen(interpreter_args) + 1;
479                 }
480
481                 fclose(fh);
482         }
483         else
484         {
485                 /* We couldn't open this why not? */
486                 if (errno == ENOENT)
487                 {
488                         /* file didn't exist! */
489                         return -1;
490                 }
491         }
492
493         /* Allocate the command line */
494         filename_conv = convert_path_u2a(filename);
495
496         if (filename_conv)
497                 size += strlen(filename_conv);
498         size += 1;
499         full = (char *)IExec->AllocVec(size + 10, MEMF_ANY | MEMF_CLEAR);
500         if (full)
501         {
502                 if (interpreter)
503                 {
504                         interpreter_conv = convert_path_u2a(interpreter);
505 #if !defined(__USE_RUNCOMMAND__)
506 #warning(using system!)
507                         sprintf(full, "%s %s %s ", interpreter_conv,
508                                 interpreter_args, filename_conv);
509 #else
510                         sprintf(full, "%s %s ", interpreter_args,
511                                 filename_conv);
512 #endif
513                         IExec->FreeVec(interpreter);
514                         IExec->FreeVec(interpreter_args);
515
516                         if (filename_conv)
517                                 IExec->FreeVec(filename_conv);
518                         fname = mystrdup(interpreter_conv);
519
520                         if (interpreter_conv)
521                                 IExec->FreeVec(interpreter_conv);
522                 }
523                 else
524                 {
525 #ifndef __USE_RUNCOMMAND__
526                         sprintf(full, "%s ", filename_conv);
527 #else
528                         sprintf(full, "");
529 #endif
530                         fname = mystrdup(filename_conv);
531                         if (filename_conv)
532                                 IExec->FreeVec(filename_conv);
533                 }
534
535                 for (cur = (char **)(argv + 1); *cur != 0; cur++)
536                 {
537                         if (contains_whitespace(*cur))
538                         {
539                                 int esc = no_of_escapes(*cur);
540
541                                 if (esc > 0)
542                                 {
543                                         char *buff = IExec->AllocVec(
544                                             strlen(*cur) + 4 + esc,
545                                             MEMF_ANY | MEMF_CLEAR);
546                                         char *p = *cur;
547                                         char *q = buff;
548
549                                         *q++ = '"';
550                                         while (*p != '\0')
551                                         {
552
553                                                 if (*p == '\n')
554                                                 {
555                                                         *q++ = '*';
556                                                         *q++ = 'N';
557                                                         p++;
558                                                         continue;
559                                                 }
560                                                 else if (*p == '"')
561                                                 {
562                                                         *q++ = '*';
563                                                         *q++ = '"';
564                                                         p++;
565                                                         continue;
566                                                 }
567                                                 else if (*p == '*')
568                                                 {
569                                                         *q++ = '*';
570                                                 }
571                                                 *q++ = *p++;
572                                         }
573                                         *q++ = '"';
574                                         *q++ = ' ';
575                                         *q = '\0';
576                                         strcat(full, buff);
577                                         IExec->FreeVec(buff);
578                                 }
579                                 else
580                                 {
581                                         strcat(full, "\"");
582                                         strcat(full, *cur);
583                                         strcat(full, "\" ");
584                                 }
585                         }
586                         else
587                         {
588                                 strcat(full, *cur);
589                                 strcat(full, " ");
590                         }
591                 }
592                 strcat(full, "\n");
593
594 //            if(envp)
595 //                 createvars(envp);
596
597 #ifndef __USE_RUNCOMMAND__
598                 result = IDOS->SystemTags(
599                     full, SYS_UserShell, TRUE, NP_StackSize,
600                     ((struct Process *)thisTask)->pr_StackSize, SYS_Input,
601                     ((struct Process *)thisTask)->pr_CIS, SYS_Output,
602                     ((struct Process *)thisTask)->pr_COS, SYS_Error,
603                     ((struct Process *)thisTask)->pr_CES, TAG_DONE);
604 #else
605
606                 if (fname)
607                 {
608                         BPTR seglist = IDOS->LoadSeg(fname);
609                         if (seglist)
610                         {
611                                 /* check if we have an executable! */
612                                 struct PseudoSegList *ps = NULL;
613                                 if (!IDOS->GetSegListInfoTags(
614                                         seglist, GSLI_Native, &ps, TAG_DONE))
615                                 {
616                                         IDOS->GetSegListInfoTags(
617                                             seglist, GSLI_68KPS, &ps, TAG_DONE);
618                                 }
619                                 if (ps != NULL)
620                                 {
621                                         //                    adebug("%s %ld %s
622                                         //                    %s\n",__FUNCTION__,__LINE__,fname,full);
623                                         IDOS->SetCliProgramName(fname);
624                                         //                        result=RunCommand(seglist,8*1024,full,strlen(full));
625                                         //                        result=myruncommand(seglist,8*1024,full,strlen(full),envp);
626                                         result = myruncommand(seglist, 8 * 1024,
627                                                               full, -1, envp);
628                                         errno = 0;
629                                 }
630                                 else
631                                 {
632                                         errno = ENOEXEC;
633                                 }
634                                 IDOS->UnLoadSeg(seglist);
635                         }
636                         else
637                         {
638                                 errno = ENOEXEC;
639                         }
640                         IExec->FreeVec(fname);
641                 }
642
643 #endif /* USE_RUNCOMMAND */
644
645                 IExec->FreeVec(full);
646                 if (errno == ENOEXEC)
647                         return -1;
648                 return result;
649         }
650
651         if (interpreter)
652                 IExec->FreeVec(interpreter);
653         if (filename_conv)
654                 IExec->FreeVec(filename_conv);
655
656         errno = ENOMEM;
657
658         return -1;
659 }
660
661 int pause(void)
662 {
663         fprintf(stderr, "Pause not implemented\n");
664
665         errno = EINTR;
666         return -1;
667 }
668
669 uint32 size_env(struct Hook *hook, APTR userdata, struct ScanVarsMsg *message)
670 {
671         if (strlen(message->sv_GDir) <= 4)
672         {
673                 hook->h_Data = (APTR)(((uint32)hook->h_Data) + 1);
674         }
675         return 0;
676 }
677
678 uint32 copy_env(struct Hook *hook, APTR userdata, struct ScanVarsMsg *message)
679 {
680         if (strlen(message->sv_GDir) <= 4)
681         {
682                 char **env = (char **)hook->h_Data;
683                 uint32 size =
684                     strlen(message->sv_Name) + 1 + message->sv_VarLen + 1 + 1;
685                 char *buffer = (char *)IExec->AllocVec((uint32)size,
686                                                        MEMF_ANY | MEMF_CLEAR);
687
688                 snprintf(buffer, size - 1, "%s=%s", message->sv_Name,
689                          message->sv_Var);
690
691                 *env = buffer;
692                 env++;
693                 hook->h_Data = env;
694         }
695         return 0;
696 }
697
698 void ___makeenviron()
699 {
700         struct Hook hook;
701
702         char varbuf[8];
703         uint32 flags = 0;
704
705         struct DOSIFace *myIDOS =
706             (struct DOSIFace *)OpenInterface("dos.library", 53);
707         if (myIDOS)
708         {
709                 if (myIDOS->GetVar("ABCSH_IMPORT_LOCAL", varbuf, 8,
710                                    GVF_LOCAL_ONLY) > 0)
711                 {
712                         flags = GVF_LOCAL_ONLY;
713                 }
714                 else
715                 {
716                         flags = GVF_GLOBAL_ONLY;
717                 }
718
719                 hook.h_Entry = size_env;
720                 hook.h_Data = 0;
721
722                 myIDOS->ScanVars(&hook, flags, 0);
723                 hook.h_Data = (APTR)(((uint32)hook.h_Data) + 1);
724
725                 myenviron = (char **)IExec->AllocVec((uint32)hook.h_Data *
726                                                          sizeof(char **),
727                                                      MEMF_ANY | MEMF_CLEAR);
728                 origenviron = myenviron;
729                 if (!myenviron)
730                 {
731                         return;
732                 }
733                 hook.h_Entry = copy_env;
734                 hook.h_Data = myenviron;
735
736                 myIDOS->ScanVars(&hook, flags, 0);
737                 CloseInterface((struct Interface *)myIDOS);
738         }
739 }
740
741 void ___freeenviron()
742 {
743         char **i;
744         /* perl might change environ, it puts it back except for ctrl-c */
745         /* so restore our own copy here */
746         struct DOSIFace *myIDOS =
747             (struct DOSIFace *)OpenInterface("dos.library", 53);
748         if (myIDOS)
749         {
750                 myenviron = origenviron;
751
752                 if (myenviron)
753                 {
754                         for (i = myenviron; *i != NULL; i++)
755                         {
756                                 IExec->FreeVec(*i);
757                         }
758                         IExec->FreeVec(myenviron);
759                         myenviron = NULL;
760                 }
761                 CloseInterface((struct Interface *)myIDOS);
762         }
763 }
764
765 /* reimplementation of popen, clib2's doesn't do all we want */
766
767 static BOOL is_final_quote_character(const char *str)
768 {
769         BOOL result;
770
771         result = (BOOL)(str[0] == '\"' && (str[1] == '\0' || isspace(str[1])));
772
773         return (result);
774 }
775
776 static BOOL is_final_squote_character(const char *str)
777 {
778         BOOL result;
779
780         result = (BOOL)(str[0] == '\'' && (str[1] == '\0' || isspace(str[1])));
781
782         return (result);
783 }
784
785 int popen_child()
786 {
787         struct Task *thisTask = IExec->FindTask(0);
788
789         char *command = (char *)thisTask->tc_UserData;
790         size_t len;
791         char *str;
792         int argc;
793         int number_of_arguments;
794         char *argv[4];
795
796         argv[0] = "sh";
797         argv[1] = "-c";
798         argv[2] = command ? command : NULL;
799         argv[3] = NULL;
800
801         // adebug("%s %ld  %s\n",__FUNCTION__,__LINE__,command?command:"NULL");
802
803         /* We need to give this to sh via execvp, execvp expects filename,
804          * argv[]
805          */
806
807         myexecvp(argv[0], argv);
808         if (command)
809                 IExec->FreeVec(command);
810
811         IExec->Forbid();
812         return 0;
813 }
814
815 FILE *amigaos_popen(const char *cmd, const char *mode)
816 {
817         FILE *result = NULL;
818         char pipe_name[50];
819         char unix_pipe[50];
820         char ami_pipe[50];
821         char *cmd_copy;
822         BPTR input = 0;
823         BPTR output = 0;
824         struct Process *proc = NULL;
825         struct Task *thisTask = IExec->FindTask(0);
826
827         /* First we need to check the mode
828          * We can only have unidirectional pipes
829          */
830         //    adebug("%s %ld cmd %s mode %s \n",__FUNCTION__,__LINE__,cmd,
831         //    mode);
832
833         switch (mode[0])
834         {
835         case 'r':
836         case 'w':
837                 break;
838
839         default:
840
841                 errno = EINVAL;
842                 return result;
843         }
844
845         /* Make a unique pipe name
846          * we need a unix one and an amigaos version (of the same pipe!)
847          * as were linking with libunix.
848          */
849
850         sprintf(pipe_name, "%x%08lx/4096/0", pipenum++,
851                 IUtility->GetUniqueID());
852         sprintf(unix_pipe, "/PIPE/%s", pipe_name);
853         sprintf(ami_pipe, "PIPE:%s", pipe_name);
854
855         /* Now we open the AmigaOs Filehandles That we wil pass to our
856          * Sub process
857          */
858
859         if (mode[0] == 'r')
860         {
861                 /* A read mode pipe: Output from pipe input from NIL:*/
862                 input = IDOS->Open("NIL:", MODE_NEWFILE);
863                 if (input != 0)
864                 {
865                         output = IDOS->Open(ami_pipe, MODE_NEWFILE);
866                 }
867         }
868         else
869         {
870
871                 input = IDOS->Open(ami_pipe, MODE_NEWFILE);
872                 if (input != 0)
873                 {
874                         output = IDOS->Open("NIL:", MODE_NEWFILE);
875                 }
876         }
877         if ((input == 0) || (output == 0))
878         {
879                 /* Ouch stream opening failed */
880                 /* Close and bail */
881                 if (input)
882                         IDOS->Close(input);
883                 if (output)
884                         IDOS->Close(output);
885                 return result;
886         }
887
888         /* We have our streams now start our new process
889          * We're using a new process so that execve can modify the environment
890          * with messing things up for the shell that launched perl
891          * Copy cmd before we launch the subprocess as perl seems to waste
892          * no time in overwriting it! The subprocess will free the copy.
893          */
894
895         if ((cmd_copy = mystrdup(cmd)))
896         {
897                 // adebug("%s %ld
898                 // %s\n",__FUNCTION__,__LINE__,cmd_copy?cmd_copy:"NULL");
899                 proc = IDOS->CreateNewProcTags(
900                     NP_Entry, popen_child, NP_Child, TRUE, NP_StackSize,
901                     ((struct Process *)thisTask)->pr_StackSize, NP_Input, input,
902                     NP_Output, output, NP_Error, IDOS->ErrorOutput(),
903                     NP_CloseError, FALSE, NP_Cli, TRUE, NP_Name,
904                     "Perl: popen process", NP_UserData, (int)cmd_copy,
905                     TAG_DONE);
906         }
907         if (!proc)
908         {
909                 /* New Process Failed to start
910                  * Close and bail out
911                  */
912                 if (input)
913                         IDOS->Close(input);
914                 if (output)
915                         IDOS->Close(output);
916                 if (cmd_copy)
917                         IExec->FreeVec(cmd_copy);
918         }
919
920         /* Our new process is running and will close it streams etc
921          * once its done. All we need to is open the pipe via stdio
922          */
923
924         return fopen(unix_pipe, mode);
925 }
926
927 /* Work arround for clib2 fstat */
928 #ifndef S_IFCHR
929 #define S_IFCHR 0x0020000
930 #endif
931
932 #define SET_FLAG(u, v) ((void)((u) |= (v)))
933
934 int afstat(int fd, struct stat *statb)
935 {
936         int result;
937         BPTR fh;
938         int mode;
939         BOOL input;
940         /* In the first instance pass it to fstat */
941         // adebug("fd %ld ad %ld\n",fd,amigaos_get_file(fd));
942
943         if ((result = fstat(fd, statb) >= 0))
944                 return result;
945
946 /* Now we've got a file descriptor but we failed to stat it */
947 /* Could be a nil: or could be a std#? */
948
949 /* if get_default_file fails we had a dud fd so return failure */
950 #if !defined(__CLIB2__)
951
952         fh = amigaos_get_file(fd);
953
954         /* if nil: return failure*/
955         if (fh == 0)
956                 return -1;
957
958         /* Now compare with our process Input() Output() etc */
959         /* if these were regular files sockets or pipes we had already
960          * succeeded */
961         /* so we can guess they a character special console.... I hope */
962
963         struct ExamineData *data;
964         char name[120];
965         name[0] = '\0';
966
967         data = IDOS->ExamineObjectTags(EX_FileHandleInput, fh, TAG_END);
968         if (data != NULL)
969         {
970
971                 IUtility->Strlcpy(name, data->Name, sizeof(name));
972
973                 IDOS->FreeDosObject(DOS_EXAMINEDATA, data);
974         }
975
976         // adebug("ad %ld '%s'\n",amigaos_get_file(fd),name);
977         mode = S_IFCHR;
978
979         if (fh == IDOS->Input())
980         {
981                 input = TRUE;
982                 SET_FLAG(mode, S_IRUSR);
983                 SET_FLAG(mode, S_IRGRP);
984                 SET_FLAG(mode, S_IROTH);
985         }
986         else if (fh == IDOS->Output() || fh == IDOS->ErrorOutput())
987         {
988                 input = FALSE;
989                 SET_FLAG(mode, S_IWUSR);
990                 SET_FLAG(mode, S_IWGRP);
991                 SET_FLAG(mode, S_IWOTH);
992         }
993         else
994         {
995                 /* we got a filehandle not handle by fstat or the above */
996                 /* most likely it's NIL: but lets check */
997                 struct ExamineData *exd = NULL;
998                 if ((exd = IDOS->ExamineObjectTags(EX_FileHandleInput, fh,
999                                                    TAG_DONE)))
1000                 {
1001                         BOOL isnil = FALSE;
1002                         if (exd->Type ==
1003                             (20060920)) // Ugh yes I know nasty.....
1004                         {
1005                                 isnil = TRUE;
1006                         }
1007                         IDOS->FreeDosObject(DOS_EXAMINEDATA, exd);
1008                         if (isnil)
1009                         {
1010                                 /* yep we got NIL: */
1011                                 SET_FLAG(mode, S_IRUSR);
1012                                 SET_FLAG(mode, S_IRGRP);
1013                                 SET_FLAG(mode, S_IROTH);
1014                                 SET_FLAG(mode, S_IWUSR);
1015                                 SET_FLAG(mode, S_IWGRP);
1016                                 SET_FLAG(mode, S_IWOTH);
1017                         }
1018                         else
1019                         {
1020                                 IExec->DebugPrintF(
1021                                     "unhandled filehandle in afstat()\n");
1022                                 return -1;
1023                         }
1024                 }
1025         }
1026
1027         memset(statb, 0, sizeof(statb));
1028
1029         statb->st_mode = mode;
1030
1031 #endif
1032         return 0;
1033 }
1034
1035 BPTR amigaos_get_file(int fd)
1036 {
1037         BPTR fh = (BPTR)NULL;
1038         if (!(fh = _get_osfhandle(fd)))
1039         {
1040                 switch (fd)
1041                 {
1042                 case 0:
1043                         fh = IDOS->Input();
1044                         break;
1045                 case 1:
1046                         fh = IDOS->Output();
1047                         break;
1048                 case 2:
1049                         fh = IDOS->ErrorOutput();
1050                         break;
1051                 default:
1052                         break;
1053                 }
1054         }
1055         return fh;
1056 }