This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
NetWare changeover from Watcom to Codewarrior, from C Aditya.
[perl5.git] / NetWare / Nwmain.c
1
2 /*
3  * Copyright © 2001 Novell, Inc. All Rights Reserved.
4  *
5  * You may distribute under the terms of either the GNU General Public
6  * License or the Artistic License, as specified in the README file.
7  *
8  */
9
10 /*
11  * FILENAME             :       NWMain.c
12  * DESCRIPTION  :       Main function, Commandline handlers and shutdown for NetWare implementation of Perl.
13  * Author               :       HYAK, SGP
14  * Date                 :       January 2001.
15  *
16  */
17
18
19
20 #ifdef NLM
21 #define N_PLAT_NLM
22 #endif
23
24 #undef BYTE
25 #define BYTE char
26
27
28 #include <nwadv.h>
29 #include <signal.h>
30 #include <nwdsdefs.h>
31
32 #include "perl.h"
33 #include "nwutil.h"
34 #include "stdio.h"
35 #include "clibstuf.h"
36
37 #ifdef MPK_ON
38         #include <mpktypes.h>
39         #include <mpkapis.h>
40 #endif  //MPK_ON
41
42
43 // Thread group ID for this NLM. Set only by main when the NLM is initially loaded,
44 // so it should be okay for this to be global.
45 //
46 #ifdef MPK_ON
47         THREAD  gThreadHandle;
48 #else
49         int gThreadGroupID = -1;
50 #endif  //MPK_ON
51
52
53 // Global to kill all running scripts during NLM unload.
54 //
55 bool gKillAll = FALSE;
56
57
58 // Global structure needed by OS to register command parser.
59 // fnRegisterCommandLineHandler gets called only when the NLM is initially loaded,
60 // so it should be okay for this structure to be a global.
61 //
62 static struct commandParserStructure gCmdParser = {0,0,0};
63
64
65 // True if the command-line parsing procedure has been registered with the OS.
66 // Altered only during initial NLM loading or unloading so it should be okay as a global.
67 //
68 BOOL gCmdProcInit = FALSE;
69
70
71 // Array to hold the screen name for all new screens.
72 //
73 char sPerlScreenName[MAX_DN_BYTES * sizeof(char)] = {'\0'};
74
75
76 // Structure to pass data when spawning new threadgroups to run scripts.
77 //
78 typedef struct tagScriptData
79 {
80         char *m_commandLine;
81         BOOL m_fromConsole;
82 }ScriptData;
83
84
85 #define  CS_CMD_NOT_FOUND       -1              // Console command not found
86 #define  CS_CMD_FOUND           0               // Console command found
87
88 /**
89   The stack size is make 256k from the earlier 64k since complex scripts (charnames.t and complex.t)
90   were failing with the lower stack size. In fact, we tested with 128k and it also failed
91   for the complexity of the script used. In case the complexity of a script is increased,
92   then this might warrant an increase in the stack size. But instead of simply giving  a very large stack,
93   a trade off was required and we stopped at 256k!
94 **/
95 #define PERL_COMMAND_STACK_SIZE (256*1024L)     // Stack size of thread that runs a perl script from command line
96
97 #define MAX_COMMAND_SIZE 512
98
99
100 #define kMaxValueLen 1024       // Size of the Environment variable value limited/truncated to 1024 characters.
101 #define kMaxVariableNameLen 256         // Size of the Environment variable name.
102
103
104 typedef void (*PFUSEACCURATECASEFORPATHS) (int);
105 typedef LONG (*PFGETFILESERVERMAJORVERSIONNUMBER) (void);
106 typedef void (*PFUCSTERMINATE) ();              // For ucs terminate.
107 typedef void (*PFUNAUGMENTASTERISK)(BOOL);              // For longfile support.
108 typedef int (*PFFSETMODE) (FILE *, char *);
109
110
111 // local function prototypes
112 //
113 void fnSigTermHandler(int sig);
114 void fnRegisterCommandLineHandler(void);
115 void fnLaunchPerl(void* context);
116 void fnSetUpEnvBlock(char*** penv);
117 void fnDestroyEnvBlock(char** env);
118 int fnFpSetMode(FILE* fp, int mode, int *err);
119
120 void fnGetPerlScreenName(char *sPerlScreenName);
121
122 void fnGetPerlScreenName(char *sPerlScreenName);
123 void fnSetupNamespace(void); 
124 char *getcwd(char [], int); 
125 void fnRunScript(ScriptData* psdata);
126 void nw_freeenviron();
127
128
129 /*============================================================================================
130
131  Function               :       main
132
133  Description    :       Called when the NLM is first loaded. Registers the command-line handler
134                                                                 and then terminates-stay-resident.
135
136  Parameters             :       argc    (IN)    -       No of  Input  strings.
137                                                                 argv    (IN)    -       Array of  Input  strings.
138
139  Returns                :       Nothing.
140
141 ==============================================================================================*/
142
143 void main(int argc, char *argv[]) 
144 {
145         char sysCmdLine[MAX_COMMAND_SIZE] = {'\0'};
146         char cmdLineCopy[sizeof(PERL_COMMAND_NAME)+sizeof(sysCmdLine)+2] = {'\0'};
147
148         ScriptData* psdata = NULL;
149
150
151         // Keep this thread alive, since we use the thread group id of this thread to allocate memory on.
152         // When we unload the NLM, clib will tear the thread down.
153         //
154         #ifdef MPK_ON
155                 gThreadHandle = kCurrentThread();
156         #else
157                 gThreadGroupID = GetThreadGroupID ();
158         #endif  //MPK_ON
159
160         signal (SIGTERM, fnSigTermHandler);
161         fnInitGpfGlobals();             // For importing the CLIB calls in place of the Watcom calls
162         fnInitializeThreadInfo();
163
164
165 //      Ensure that we have a "temp" directory
166         fnSetupNamespace();
167         if (access(NWDEFPERLTEMP, 0) != 0)
168                 mkdir(NWDEFPERLTEMP);
169
170         // Create the file NUL if not present. This is done only once per NLM load.
171         // This is required for -e.
172         // Earlier verions were creating temporary files (in perl.c file) for -e.
173         // Now, the technique of creating temporary files are removed since they were
174         // fragile or insecure or slow. It now uses the memory by setting
175         // the BIT_BUCKET to "nul" on Win32, which is equivalent to /dev/nul of Unix.
176         // Since there is no equivalent of /dev/nul on NetWare, the work-around is that
177         // we create a file called "nul" and the BIT_BUCKET is set to "nul".
178         // This makes sure that -e works on NetWare too without the creation of temporary files
179         // in -e code in perl.c
180         {
181                 char sNUL[MAX_DN_BYTES] = {'\0'};
182
183                 strcpy(sNUL, NWDEFPERLROOT);
184                 strcat(sNUL, "\\nul");
185                 if (access((const char *)sNUL, 0) != 0)
186                 {
187                         // The file, "nul" is not found and so create the file.
188                         FILE *fp = NULL;
189
190                         fp = fopen((const char *)sNUL, (const char *)"w");
191                         fclose(fp);
192                 }
193         }
194
195         fnRegisterCommandLineHandler();         // Register the command line handler
196         SynchronizeStart();             // Restart the NLM startup process when using synchronization mode.
197
198         fnGetPerlScreenName(sPerlScreenName);   // Get the screen name. Done only once per NLM load.
199
200
201         // If the command line has two strings, then the first has to be "Perl" and the second is assumed
202         // to be a script to be run. If only one string (i.e., Perl) is input, then there is nothing to do!
203         //
204         if ((argc > 1) && getcmd(sysCmdLine))
205         {
206                 strcpy(cmdLineCopy, PERL_COMMAND_NAME);
207                 strcat(cmdLineCopy, (char *)" ");       // Space between the Perl Command and the input script name.
208                 strcat(cmdLineCopy, sysCmdLine);        // The command line parameters built into 
209
210                 // Create a safe copy of the command line and pass it to the
211                 // new thread for parsing. The new thread will be responsible
212                 // to delete it when it is finished with it.
213                 //
214                 psdata = (ScriptData *) malloc(sizeof(ScriptData));
215                 if (psdata)
216                 {
217                         psdata->m_commandLine = NULL;
218                         psdata->m_commandLine = (char *) malloc(MAX_DN_BYTES * sizeof(char));
219                         if(psdata->m_commandLine)
220                         {
221                                 strcpy(psdata->m_commandLine, cmdLineCopy);
222                                 psdata->m_fromConsole = TRUE;
223
224                                 #ifdef MPK_ON
225 //                                      kStartThread((char *)"ConsoleHandlerThread", fnLaunchPerl, NULL, PERL_COMMAND_STACK_SIZE, (void *)psdata);
226                                         // Establish a new thread within a new thread group.
227                                         BeginThreadGroup(fnLaunchPerl, NULL, PERL_COMMAND_STACK_SIZE, (void*)psdata);
228                                 #else
229                                         // Start a new thread in its own thread group
230                                         BeginThreadGroup(fnLaunchPerl, NULL, PERL_COMMAND_STACK_SIZE, (void*)psdata);
231                                 #endif  //MPK_ON
232                         }
233                         else
234                         {
235                                 free(psdata);
236                                 psdata = NULL;
237                                 return;
238                         }
239                 }
240                 else
241                         return;
242         }
243
244
245         // Keep this thread alive, since we use the thread group id of this thread to allocate memory on.
246         // When we unload the NLM, clib will tear the thread down.
247         //
248         #ifdef MPK_ON
249                 kSuspendThread(gThreadHandle);
250         #else
251                 SuspendThread(GetThreadID());
252         #endif  //MPK_ON
253
254
255         return;
256 }
257
258
259
260 /*============================================================================================
261
262  Function               :       fnSigTermHandler
263
264  Description    :       Called when the NLM is unloaded; used to unregister the console command handler.
265
266  Parameters             :       sig             (IN)
267
268  Returns                :       Nothing.
269
270 ==============================================================================================*/
271
272 void fnSigTermHandler(int sig)
273 {
274         int k = 0;
275
276
277         #ifdef MPK_ON
278                 kResumeThread(gThreadHandle);
279         #endif  //MPK_ON
280
281         // Unregister the command line handler.
282         //
283         if (gCmdProcInit)
284         {
285                 UnRegisterConsoleCommand (&gCmdParser);
286                 gCmdProcInit = FALSE;
287         }
288
289         // Free the global environ buffer
290         nw_freeenviron();
291
292         // Kill running scripts.
293         //
294         if (!fnTerminateThreadInfo())
295         {
296                 ConsolePrintf("Terminating Perl scripts...\n");
297                 gKillAll = TRUE;
298
299                 // fnTerminateThreadInfo will be run for 5 threads. If more threads/scripts are run,
300                 // then the NLM will unload without terminating the thread info and leaks more memory.
301                 // If this number is increased to reduce memory leaks, then it will unnecessarily take more time
302                 // to unload when there are a smaller no of threads. Since this is a rare case, the no is kept as 5.
303                 //
304                 while (!fnTerminateThreadInfo() && k < 5)
305                 {
306                         nw_sleep(1);
307                         k++;
308                 }
309         }
310
311         // Delete the file, "nul" if present since the NLM is unloaded.
312         {
313                 char sNUL[MAX_DN_BYTES] = {'\0'};
314
315                 strcpy(sNUL, NWDEFPERLROOT);
316                 strcat(sNUL, "\\nul");
317                 if (access((const char *)sNUL, 0) == 0)
318                 {
319                         // The file, "nul" is found and so delete it.
320                         unlink((const char *)sNUL);
321                 }
322         }
323 }
324
325
326
327 /*============================================================================================
328
329  Function               :       fnCommandLineHandler
330
331  Description    :       Gets called by OS when someone enters an unknown command at the system console,
332                                         after this routine is registered by RegisterConsoleCommand.
333                                         For the valid command we just spawn     a thread with enough stack space
334                                         to actually run the script.
335
336  Parameters             :       screenID        (IN)    -       id for the screen.
337                                                                 cmdLine         (IN)    -       Command line string.
338
339  Returns                :       Long.
340
341 ==============================================================================================*/
342
343 LONG  fnCommandLineHandler (LONG screenID, BYTE * cmdLine)
344 {
345         ScriptData* psdata=NULL;
346         int OsThrdGrpID = -1;
347         LONG retCode = CS_CMD_FOUND;
348         char* cptr = NULL;
349
350
351         #ifdef MPK_ON
352                 // Initialisation for MPK_ON
353         #else
354                 OsThrdGrpID = -1;
355         #endif  //MPK_ON
356
357
358         #ifdef MPK_ON
359                 // For MPK_ON
360         #else
361                 if (gThreadGroupID != -1)
362                         OsThrdGrpID = SetThreadGroupID (gThreadGroupID);
363         #endif  //MPK_ON
364
365
366         cptr = fnSkipWhite(cmdLine);    // Skip white spaces.
367         if ((strnicmp(cptr, PERL_COMMAND_NAME, strlen(PERL_COMMAND_NAME)) == 0) &&
368                  ((cptr[strlen(PERL_COMMAND_NAME)] == ' ') ||
369                  (cptr[strlen(PERL_COMMAND_NAME)] == '\t') ||
370                  (cptr[strlen(PERL_COMMAND_NAME)] == '\0')))
371         {
372                 // Create a safe copy of the command line and pass it to the new thread for parsing.
373                 // The new thread will be responsible to delete it when it is finished with it.
374                 //
375                 psdata = (ScriptData *) malloc(sizeof(ScriptData));
376                 if (psdata)
377                 {
378                         psdata->m_commandLine = NULL;
379                         psdata->m_commandLine = (char *) malloc(MAX_DN_BYTES * sizeof(char));
380                         if(psdata->m_commandLine)
381                         {
382                                 strcpy(psdata->m_commandLine, (char *)cmdLine);
383                                 psdata->m_fromConsole = TRUE;
384
385                                 #ifdef MPK_ON
386 //                                      kStartThread((char *)"ConsoleHandlerThread", fnLaunchPerl, NULL, PERL_COMMAND_STACK_SIZE, (void *)psdata);
387                                         // Establish a new thread within a new thread group.
388                                         BeginThreadGroup(fnLaunchPerl, NULL, PERL_COMMAND_STACK_SIZE, (void*)psdata);
389                                 #else
390                                         // Start a new thread in its own thread group
391                                         BeginThreadGroup(fnLaunchPerl, NULL, PERL_COMMAND_STACK_SIZE, (void*)psdata);
392                                 #endif  //MPK_ON
393                         }
394                         else
395                         {
396                                 free(psdata);
397                                 psdata = NULL;
398                                 retCode = CS_CMD_NOT_FOUND;
399                         }
400                 }
401                 else
402                         retCode = CS_CMD_NOT_FOUND;
403         }
404         else
405                 retCode = CS_CMD_NOT_FOUND;
406
407
408         #ifdef MPK_ON
409                 // For MPK_ON
410         #else
411                 if (OsThrdGrpID != -1)
412                         SetThreadGroupID (OsThrdGrpID);
413         #endif  //MPK_ON
414
415
416         return retCode;
417 }
418
419
420
421 /*============================================================================================
422
423  Function               :       fnRegisterCommandLineHandler
424
425  Description    :       Registers the console command-line parsing function with the OS.
426
427  Parameters             :       None.
428
429  Returns                :       Nothing.
430
431 ==============================================================================================*/
432
433 void fnRegisterCommandLineHandler(void)
434 {
435         // Allocates resource tag for Console Command
436         if ((gCmdParser.RTag =
437                 AllocateResourceTag (GetNLMHandle(), (char *)"Console Command", ConsoleCommandSignature)) != 0)
438         {
439                 gCmdParser.parseRoutine = fnCommandLineHandler;         // Set the Console Command parsing routine.
440                 RegisterConsoleCommand (&gCmdParser);           // Registers the Console Command parsing function
441                 gCmdProcInit = TRUE;
442         }
443
444         return;
445 }
446
447
448
449 /*============================================================================================
450
451  Function               :       fnSetupNamespace
452
453  Description    :       Sets the name space of the current threadgroup to the long name space.
454
455  Parameters             :       None.
456
457  Returns                :       Nothing.
458
459 ==============================================================================================*/
460
461 void fnSetupNamespace(void)
462 {
463         SetCurrentNameSpace(NWOS2_NAME_SPACE);
464
465
466         //LATER: call SetTargetNameSpace(NWOS2_NAME_SPACE)? Currently, if
467         // I make this call, then CPerlExe::Rename fails in certain cases,
468         // and it isn't clear why. Looks like a CLIB bug...
469 //      SetTargetNameSpace(NWOS2_NAME_SPACE); 
470
471         //Uncommented that above call, retaining the comment so that it will be easy 
472         //to revert back if there is any problem - sgp - 10th May 2000
473
474         //Commented again, since Perl debugger had some problems because of
475         //the above call - sgp - 20th June 2000
476
477         {
478                 // if running on Moab, call UseAccurateCaseForPaths. This API
479                 // does bad things on 4.11 so we call only for Moab.
480                 PFGETFILESERVERMAJORVERSIONNUMBER pf_getfileservermajorversionnumber = NULL;
481                 pf_getfileservermajorversionnumber = (PFGETFILESERVERMAJORVERSIONNUMBER) 
482                 ImportSymbol(GetNLMHandle(), (char *)"GetFileServerMajorVersionNumber");
483                 if (pf_getfileservermajorversionnumber && ((*pf_getfileservermajorversionnumber)() > 4))
484                 {
485                         PFUSEACCURATECASEFORPATHS pf_useaccuratecaseforpaths = NULL;
486                         pf_useaccuratecaseforpaths = (PFUSEACCURATECASEFORPATHS) 
487                         ImportSymbol(GetNLMHandle(), (char *)"UseAccurateCaseForPaths");
488                         if (pf_useaccuratecaseforpaths)
489                                 (*pf_useaccuratecaseforpaths)(TRUE);
490                         {
491                                 PFUNAUGMENTASTERISK pf_unaugmentasterisk = NULL;
492                                 pf_unaugmentasterisk = (PFUNAUGMENTASTERISK)
493                                 ImportSymbol(GetNLMHandle(), (char *)"UnAugmentAsterisk");
494                                 if (pf_unaugmentasterisk)
495                                         (*pf_unaugmentasterisk)(TRUE);
496                         }
497                 }
498         }
499
500         return;
501 }
502
503
504
505 /*============================================================================================
506
507  Function               :       fnLaunchPerl
508
509  Description    :       Parse the command line into argc/argv style parameters and then run the script.
510
511  Parameters             :       context (IN)    -       void* that will be typecasted to ScriptDate structure.
512
513  Returns                :       Nothing.
514
515 ==============================================================================================*/
516
517 void fnLaunchPerl(void* context)
518 {
519         char* defaultDir = NULL;
520         char curdir[_MAX_PATH] = {'\0'};
521         ScriptData* psdata = (ScriptData *) context;
522
523         unsigned int moduleHandle = 0;
524         int currentThreadGroupID = -1;
525
526         #ifdef MPK_ON
527                 kExitNetWare();
528         #endif  //MPK_ON
529
530         errno = 0;
531
532
533         if (psdata->m_fromConsole)
534         {
535                 // get the default working directory name
536                 //
537                 defaultDir = fnNwGetEnvironmentStr("PERL_ROOT", NWDEFPERLROOT);
538         }
539         else
540                 defaultDir = getcwd(curdir, sizeof(curdir)-1);
541
542         // set long name space
543         //
544         fnSetupNamespace();
545
546         // make the working directory the current directory if from console
547         //
548         if (psdata->m_fromConsole)
549                 chdir(defaultDir);
550
551
552         // run the script
553         //
554         fnRunScript(psdata);
555
556
557         // May have to check this, I am blindly calling UCSTerminate, irrespective of
558         // whether it is initialized or not
559         // Copied from the previous Perl - sgp - 31st Oct 2000
560         moduleHandle = FindNLMHandle("UCSCORE.NLM");
561         if (moduleHandle)
562         {
563                 PFUCSTERMINATE ucsterminate = (PFUCSTERMINATE)ImportSymbol(moduleHandle, "therealUCSTerminate");
564                 if (ucsterminate!=NULL)
565                         (*ucsterminate)();
566         }
567
568
569         if (psdata->m_fromConsole)
570         {
571                 // change thread groups for the call to free the memory
572                 // allocated before the new thread group was started
573                 #ifdef MPK_ON
574                         // For MPK_ON
575                 #else
576                         if (gThreadGroupID != -1)
577                                 currentThreadGroupID = SetThreadGroupID (gThreadGroupID);
578                 #endif  //MPK_ON
579         }
580
581         // Free memory
582         if (psdata)
583         {
584                 if(psdata->m_commandLine)
585                 {
586                         free(psdata->m_commandLine);
587                         psdata->m_commandLine = NULL;
588                 }
589
590                 free(psdata);
591                 psdata = NULL;
592                 context = NULL;
593         }
594
595         #ifdef MPK_ON
596                 // For MPK_ON
597         #else
598                 if (currentThreadGroupID != -1)
599                         SetThreadGroupID (currentThreadGroupID);
600         #endif  //MPK_ON
601
602         #ifdef MPK_ON
603 //              kExitThread(NULL);
604         #else
605                 // just let the thread terminate by falling off the end of the
606                 // function started by BeginThreadGroup
607 //              ExitThread(EXIT_THREAD, 0);
608         #endif
609
610
611         return;
612 }
613
614
615
616 /*============================================================================================
617
618  Function               :       fnRunScript
619
620  Description    :       Parses and runs a perl script.
621
622  Parameters             :       psdata  (IN)    -       ScriptData structure.
623
624  Returns                :       Nothing.
625
626 ==============================================================================================*/
627
628 void fnRunScript(ScriptData* psdata)
629 {
630         char **av=NULL;
631         char **en=NULL;
632         int exitstatus = 1;
633         int i=0, j=0;
634         int *dummy = 0;
635
636         PCOMMANDLINEPARSER pclp = NULL;
637
638         // Set up the environment block. This will only work on
639         // on Moab; on 4.11 the environment block will be empty.
640         char** env = NULL;
641
642         BOOL use_system_console = TRUE;
643         BOOL newscreen = FALSE;
644         int newscreenhandle = 0;
645
646         // redirect stdin or stdout and run the script
647         FILE* redirOut = NULL;
648         FILE* redirIn = NULL;
649         FILE* redirErr = NULL;
650         FILE* stderr_fp = NULL;
651
652         int stdin_fd=-1, stdin_fd_dup=-1;
653         int stdout_fd=-1, stdout_fd_dup=-1;
654         int stderr_fd=-1, stderr_fd_dup=-1;
655
656
657
658         // Main callback instance
659         //
660         if (fnRegisterWithThreadTable() == FALSE)
661                 return;
662
663
664         // parse the command line into argc/argv style:
665         // number of params and char array of params
666         //
667         pclp = (PCOMMANDLINEPARSER) malloc(sizeof(COMMANDLINEPARSER));
668         if (!pclp)
669         {
670                 fnUnregisterWithThreadTable();
671                 return;
672         }
673
674
675         // Initialise the variables
676         pclp->m_isValid = TRUE;
677         pclp->m_redirInName = NULL;
678         pclp->m_redirOutName = NULL;
679         pclp->m_redirErrName = NULL;
680         pclp->m_redirBothName = NULL;
681         pclp->nextarg = NULL;
682         pclp->sSkippedToken = NULL;
683         pclp->m_argv = NULL;
684         pclp->new_argv = NULL;
685
686         #ifdef MPK_ON
687                 pclp->m_qSemaphore = NULL;
688         #else
689                 pclp->m_qSemaphore = 0L;
690         #endif  //MPK_ON
691
692         pclp->m_noScreen = 0;
693         pclp->m_AutoDestroy = 0;
694         pclp->m_argc = 0;
695         pclp->m_argv_len = 1;
696
697
698         // Allocate memory
699         pclp->m_argv = (char **) malloc(pclp->m_argv_len * sizeof(char *));
700         if (pclp->m_argv == NULL)
701         {
702                 free(pclp);
703                 pclp = NULL;
704
705                 fnUnregisterWithThreadTable();
706                 return;
707         }
708
709         pclp->m_argv[0] = (char *) malloc(MAX_DN_BYTES * sizeof(char));
710         if (pclp->m_argv[0] == NULL)
711         {
712                 free(pclp->m_argv);
713                 pclp->m_argv=NULL;
714
715                 free(pclp);
716                 pclp = NULL;
717
718                 fnUnregisterWithThreadTable();
719                 return;
720         }
721
722
723         // Parse the command line
724         fnCommandLineParser(pclp, (char *)psdata->m_commandLine, FALSE);
725         if (!pclp->m_isValid)
726         {
727                 if(pclp->m_argv)
728                 {
729                         for(i=0; i<pclp->m_argv_len; i++)
730                         {
731                                 if(pclp->m_argv[i] != NULL)
732                                 {
733                                         free(pclp->m_argv[i]);
734                                         pclp->m_argv[i] = NULL;
735                                 }
736                         }
737
738                         free(pclp->m_argv);
739                         pclp->m_argv = NULL;
740                 }
741
742                 if(pclp->nextarg)
743                 {
744                         free(pclp->nextarg);
745                         pclp->nextarg = NULL;
746                 }
747                 if(pclp->sSkippedToken != NULL)
748                 {
749                         free(pclp->sSkippedToken);
750                         pclp->sSkippedToken = NULL;
751                 }
752
753                 if(pclp->m_redirInName)
754                 {
755                         free(pclp->m_redirInName);
756                         pclp->m_redirInName = NULL;
757                 }
758                 if(pclp->m_redirOutName)
759                 {
760                         free(pclp->m_redirOutName);
761                         pclp->m_redirOutName = NULL;
762                 }
763                 if(pclp->m_redirErrName)
764                 {
765                         free(pclp->m_redirErrName);
766                         pclp->m_redirErrName = NULL;
767                 }
768                 if(pclp->m_redirBothName)
769                 {
770                         free(pclp->m_redirBothName);
771                         pclp->m_redirBothName = NULL;
772                 }
773
774
775                 // Signal a semaphore, if indicated by "-{" option, to indicate that
776                 // the script has terminated and files are closed
777                 //
778                 if (pclp->m_qSemaphore != 0)
779                 {
780                         #ifdef MPK_ON
781                                 kSemaphoreSignal(pclp->m_qSemaphore);
782                         #else
783                                 SignalLocalSemaphore(pclp->m_qSemaphore);
784                         #endif  //MPK_ON
785                 }
786
787                 free(pclp);
788                 pclp = NULL;
789
790                 fnUnregisterWithThreadTable();
791                 return;
792         }
793
794
795         // Simulating a shell on NetWare can be difficult. If you don't
796         // create a new screen for the script to run in, you can output to
797         // the console but you can't get any input from the console. Therefore,
798         // every invocation of perl potentially needs its own screen unless
799         // you are running either "perl -h" or "perl -v" or you are redirecting
800         // stdin from a file.
801         //
802         // So we need to create a new screen and set that screen as the current
803         // screen when running any script launched from the console that is not
804         // "perl -h" or "perl -v" and is not redirecting stdin from a file.
805         //
806         // But it would be a little weird if we didn't create a new screen only
807         // in the case when redirecting stdin from a file; in only that case,
808         // stdout would be the console instead of a new screen.
809         //
810         // There is also the issue of standard err. In short, we might as well
811         // create a new screen no matter what is going on with redirection, just
812         // for the sake of consistency.
813         //
814         // In summary, we should a create a new screen and make that screen the
815         // current screen unless one of the following is true:
816         //  * The command is "perl -h"
817         //  * The command is "perl -v"
818         //  * The script was launched by another perl script. In this case,
819         //        the screen belonging to the parent perl script should probably be
820         //    the same screen for this process. And it will be if use BeginThread
821         //    instead of BeginThreadGroup when launching Perl from within a Perl
822         //    script.
823         //
824         // In those cases where we create a new screen we should probably also display
825         // that screen.
826         //
827
828         use_system_console = pclp->m_noScreen  ||
829                                 ((pclp->m_argc == 2) && (strcmp(pclp->m_argv[1], (char *)"-h") == 0))  ||
830                                 ((pclp->m_argc == 2) && (strcmp(pclp->m_argv[1], (char *)"-v") == 0));
831
832         newscreen = (!use_system_console) && psdata->m_fromConsole;
833
834         if (newscreen)
835         {
836                 newscreenhandle = CreateScreen(sPerlScreenName, 0);
837                 if (newscreenhandle)
838                         DisplayScreen(newscreenhandle);
839         }
840         else if (use_system_console)
841           CreateScreen((char *)"System Console", 0);
842
843
844         if (pclp->m_redirInName)
845         {
846                 if ((stdin_fd = fileno(stdin)) != -1)
847                 {
848                         stdin_fd_dup = dup(stdin_fd);
849                         if (stdin_fd_dup != -1)
850                         {
851                                 redirIn = fdopen (stdin_fd_dup, (char const *)"r");
852                                 if (redirIn)
853                                         stdin = freopen (pclp->m_redirInName, (char const *)"r", redirIn);
854                                 if (!stdin)
855                                 {
856                                         redirIn = NULL;
857                                         // undo the redirect, if possible
858                                         stdin = fdopen(stdin_fd, (char const *)"r");
859                                 }
860                         }
861                 }
862         }
863
864         /**
865         The below code stores the handle for the existing stdout to be used later and the existing stdout is closed.
866         stdout is then initialised to the new File pointer where the operations are done onto that.
867         Later (look below for the code), the saved stdout is restored back.
868         **/
869         if (pclp->m_redirOutName)
870         {
871                 if ((stdout_fd = fileno(stdout)) != -1)         // Handle of the existing stdout.
872                 {
873                         stdout_fd_dup = dup(stdout_fd);
874                         if (stdout_fd_dup != -1)
875                         {
876                                 // Close the existing stdout.
877                                 fflush(stdout);         // Write any unwritten data to the file.
878
879                                 // New stdout
880                                 redirOut = fdopen (stdout_fd_dup, (char const *)"w");
881                                 if (redirOut)
882                                         stdout = freopen (pclp->m_redirOutName, (char const *)"w", redirOut);
883                                 if (!stdout)
884                                 {
885                                         redirOut = NULL;
886                                         // Undo the redirection.
887                                         stdout = fdopen(stdout_fd, (char const *)"w");
888                                 }
889                                 setbuf(stdout, NULL);   // Unbuffered file pointer.
890                         }
891                 }
892         }
893
894         if (pclp->m_redirErrName)
895         {
896                 if ((stderr_fd = fileno(stderr)) != -1)
897                 {
898                         stderr_fd_dup = dup(stderr_fd);
899                         if (stderr_fd_dup != -1)
900                         {
901                                 fflush(stderr);
902
903                                 redirErr = fdopen (stderr_fd_dup, (char const *)"w");
904                                 if (redirErr)
905                                         stderr = freopen (pclp->m_redirErrName, (char const *)"w", redirErr);
906                                 if (!stderr)
907                                 {
908                                         redirErr = NULL;
909                                         // undo the redirect, if possible
910                                         stderr = fdopen(stderr_fd, (char const *)"w");
911                                 }
912                                 setbuf(stderr, NULL);   // Unbuffered file pointer.
913                         }
914                 }
915         }
916
917         if (pclp->m_redirBothName)
918         {
919                 if ((stdout_fd = fileno(stdout)) != -1)
920                 {
921                         stdout_fd_dup = dup(stdout_fd);
922                         if (stdout_fd_dup != -1)
923                         {
924                                 fflush(stdout);
925
926                                 redirOut = fdopen (stdout_fd_dup, (char const *)"w");
927                                 if (redirOut)
928                                         stdout = freopen (pclp->m_redirBothName, (char const *)"w", redirOut);
929                                 if (!stdout)
930                                 {
931                                         redirOut = NULL;
932                                         // undo the redirect, if possible
933                                         stdout = fdopen(stdout_fd, (char const *)"w");
934                                 }
935                                 setbuf(stdout, NULL);   // Unbuffered file pointer.
936                         }
937                 }
938                 if ((stderr_fd = fileno(stderr)) != -1)
939                 {
940                 stderr_fp = stderr;
941                         stderr = stdout;
942                 }
943         }
944
945
946         env = NULL;
947         fnSetUpEnvBlock(&env);  // Set up the ENV block
948
949         // Run the Perl script
950         exitstatus = RunPerl(pclp->m_argc, pclp->m_argv, env);
951
952
953         // clean up any redirection
954         //
955         if (pclp->m_redirInName && redirIn)
956         {
957                 fclose(stdin);
958                 stdin = fdopen(stdin_fd, (char const *)"r");            // Put back the old handle for stdin.
959         }
960
961         if (pclp->m_redirOutName && redirOut)
962         {
963                 // Close the new stdout.
964                 fflush(stdout);
965                 fclose(stdout);
966
967                 // Put back the old handle for stdout.
968                 stdout = fdopen(stdout_fd, (char const *)"w");
969                 setbuf(stdout, NULL);   // Unbuffered file pointer.
970         }
971
972         if (pclp->m_redirErrName && redirErr)
973         {
974                 fflush(stderr);
975                 fclose(stderr);
976
977                 stderr = fdopen(stderr_fd, (char const *)"w");          // Put back the old handle for stderr.
978                 setbuf(stderr, NULL);   // Unbuffered file pointer.
979         }
980
981         if (pclp->m_redirBothName && redirOut)
982         {
983                 stderr = stderr_fp;
984
985                 fflush(stdout);
986                 fclose(stdout);
987
988                 stdout = fdopen(stdout_fd, (char const *)"w");          // Put back the old handle for stdout.
989                 setbuf(stdout, NULL);   // Unbuffered file pointer.
990         }
991
992
993         if (newscreen && newscreenhandle)
994         {
995                 //added for --autodestroy switch
996                 if(!pclp->m_AutoDestroy)
997                 {
998                         if ((redirOut == NULL) && (redirIn == NULL) && (!gKillAll))
999                         {
1000                                 printf((char *)"\n\nPress any key to exit\n");
1001                                 getch();
1002                         }
1003                 }
1004                 DestroyScreen(newscreenhandle);
1005         }
1006
1007         // Set the mode for stdin and stdout
1008         fnFpSetMode(stdin, O_TEXT, dummy);
1009         fnFpSetMode(stdout, O_TEXT, dummy);
1010
1011         // Cleanup
1012         if(pclp->m_argv)
1013         {
1014                 for(i=0; i<pclp->m_argv_len; i++)
1015                 {
1016                         if(pclp->m_argv[i] != NULL)
1017                         {
1018                                 free(pclp->m_argv[i]);
1019                                 pclp->m_argv[i] = NULL;
1020                         }
1021                 }
1022
1023                 free(pclp->m_argv);
1024                 pclp->m_argv = NULL;
1025         }
1026
1027         if(pclp->nextarg)
1028         {
1029                 free(pclp->nextarg);
1030                 pclp->nextarg = NULL;
1031         }
1032         if(pclp->sSkippedToken != NULL)
1033         {
1034                 free(pclp->sSkippedToken);
1035                 pclp->sSkippedToken = NULL;
1036         }
1037
1038         if(pclp->m_redirInName)
1039         {
1040                 free(pclp->m_redirInName);
1041                 pclp->m_redirInName = NULL;
1042         }
1043         if(pclp->m_redirOutName)
1044         {
1045                 free(pclp->m_redirOutName);
1046                 pclp->m_redirOutName = NULL;
1047         }
1048         if(pclp->m_redirErrName)
1049         {
1050                 free(pclp->m_redirErrName);
1051                 pclp->m_redirErrName = NULL;
1052         }
1053         if(pclp->m_redirBothName)
1054         {
1055                 free(pclp->m_redirBothName);
1056                 pclp->m_redirBothName = NULL;
1057         }
1058
1059
1060         // Signal a semaphore, if indicated by -{ option, to indicate that
1061         // the script has terminated and files are closed
1062         //
1063         if (pclp->m_qSemaphore != 0)
1064         {
1065                 #ifdef MPK_ON
1066                         kSemaphoreSignal(pclp->m_qSemaphore);
1067                 #else
1068                         SignalLocalSemaphore(pclp->m_qSemaphore);
1069                 #endif  //MPK_ON
1070         }
1071
1072         if(pclp)
1073         {
1074                 free(pclp);
1075                 pclp = NULL;
1076         }
1077
1078         if(env)
1079                 fnDestroyEnvBlock(env);
1080         fnUnregisterWithThreadTable();
1081         // Remove the thread context set during Perl_set_context
1082         Remove_Thread_Ctx();
1083
1084
1085         return;
1086 }
1087
1088
1089
1090 /*============================================================================================
1091
1092  Function               :       fnSetUpEnvBlock
1093
1094  Description    :       Sets up the initial environment block.
1095
1096  Parameters             :       penv    (IN)    -       ENV variable as char***.
1097
1098  Returns                :       Nothing.
1099
1100 ==============================================================================================*/
1101
1102 void fnSetUpEnvBlock(char*** penv)
1103 {
1104         char** env = NULL;
1105
1106         int sequence = 0;
1107         char var[kMaxVariableNameLen+1] = {'\0'};
1108         char val[kMaxValueLen+1] = {'\0'};
1109         char both[kMaxVariableNameLen + kMaxValueLen + 5] = {'\0'};
1110         size_t len  = kMaxValueLen;
1111         int totalcnt = 0;
1112
1113         while(scanenv( &sequence, var, &len, val ))
1114         {
1115                 totalcnt++;
1116                 len  = kMaxValueLen;
1117         }
1118         // add one for null termination
1119         totalcnt++;
1120
1121
1122         env = (char **) malloc (totalcnt * sizeof(char *));
1123         if (env)
1124         {
1125                 int cnt = 0;
1126                 int i = 0;
1127
1128                 sequence = 0;
1129                 len  = kMaxValueLen;
1130
1131                 while( (cnt < (totalcnt-1)) && scanenv( &sequence, var, &len, val ) )
1132                 {
1133                         val[len] = '\0';
1134                         strcpy( both, var );
1135                         strcat( both, (char *)"=" );
1136                         strcat( both, val );
1137
1138                         env[cnt] = (char *) malloc((sizeof(both)+1) * sizeof(char));
1139                         if (env[cnt])
1140                         {
1141                                 strcpy(env[cnt], both);
1142                                 cnt++;
1143                         }
1144                         else
1145                         {
1146                                 for(i=0; i<cnt; i++)
1147                                 {
1148                                         if(env[i])
1149                                         {
1150                                                 free(env[i]);
1151                                                 env[i] = NULL;
1152                                         }
1153                                 }
1154
1155                                 free(env);
1156                                 env = NULL;
1157
1158                                 return;
1159                         }
1160
1161                         len  = kMaxValueLen;
1162                 }
1163
1164                 for(i=cnt; i<=(totalcnt-1); i++)
1165                         env[i] = NULL;
1166         }
1167         else
1168                 return;
1169
1170         *penv = env;
1171
1172         return;
1173 }
1174
1175
1176
1177 /*============================================================================================
1178
1179  Function               :       fnDestroyEnvBlock
1180
1181  Description    :       Frees resources used by the ENV block.
1182
1183  Parameters             :       env     (IN)    -       ENV variable as char**.
1184
1185  Returns                :       Nothing.
1186
1187 ==============================================================================================*/
1188
1189 void fnDestroyEnvBlock(char** env)
1190 {
1191         // It is assumed that this block is entered only if env is TRUE. So, the calling function
1192         // must check for this condition before calling fnDestroyEnvBlock.
1193         // If no check is made by the calling function, then the server abends.
1194         int k = 0;
1195         while (env[k] != NULL)
1196         {
1197                 free(env[k]);
1198                 env[k] = NULL;
1199                 k++;
1200         }
1201
1202         free(env);
1203         env = NULL;
1204
1205         return;
1206 }
1207
1208
1209
1210 /*============================================================================================
1211
1212  Function               :       fnFpSetMode
1213
1214  Description    :       Sets the mode for a file.
1215
1216  Parameters             :       fp      (IN)    -       FILE pointer for the input file.
1217                                         mode    (IN)    -       Mode to be set
1218                                         e       (OUT)   -       Error.
1219
1220  Returns                :       Integer which is the set value.
1221
1222 ==============================================================================================*/
1223
1224 int fnFpSetMode(FILE* fp, int mode, int *err)
1225 {
1226         int ret = -1;
1227
1228         PFFSETMODE pf_fsetmode;
1229
1230
1231         if (mode == O_BINARY || mode == O_TEXT)
1232         {
1233                 if (fp)
1234                 {
1235                         errno = 0;
1236                         // the setmode call is not implemented (correctly) on NetWare,
1237                         // but the CLIB guys were kind enough to provide another
1238                         // call, fsetmode, which does a similar thing. It only works
1239                         // on Moab
1240                         pf_fsetmode = (PFFSETMODE) ImportSymbol(GetNLMHandle(), (char *)"fsetmode");
1241                         if (pf_fsetmode)
1242                                 ret = (*pf_fsetmode) (fp, ((mode == O_BINARY) ? "b" : "t"));
1243                         else
1244                         {
1245                                 // we are on 4.11 instead of Moab, so we just return an error
1246                                 errno = ESERVER;
1247                                 err = &errno;
1248                         }
1249                         if (errno)
1250                                 err = &errno;
1251
1252                 }
1253                 else
1254                 {
1255                         errno = EBADF;
1256                         err = &errno;
1257                 }
1258         }
1259         else
1260         {
1261                 errno = EINVAL;
1262                 err = &errno;
1263         }
1264
1265
1266         return ret;
1267 }
1268
1269
1270
1271 /*============================================================================================
1272
1273  Function               :       fnInternalPerlLaunchHandler
1274
1275  Description    :       Gets called by perl to spawn a new instance of perl.
1276
1277  Parameters             :       cndLine (IN)    -       Command Line string.
1278
1279  Returns                :       Nothing.
1280
1281 ==============================================================================================*/
1282
1283 void fnInternalPerlLaunchHandler(char* cmdLine)
1284 {
1285         int currentThreadGroup = -1;
1286
1287         ScriptData* psdata=NULL;
1288
1289
1290         // Create a safe copy of the command line and pass it to the
1291         // new thread for parsing. The new thread will be responsible
1292         // to delete it when it is finished with it.
1293         psdata = (ScriptData *) malloc(sizeof(ScriptData));
1294         if (psdata)
1295         {
1296                 psdata->m_commandLine = NULL;
1297                 psdata->m_commandLine = (char *) malloc(MAX_DN_BYTES * sizeof(char));
1298
1299                 if(psdata->m_commandLine)
1300                 {
1301                         strcpy(psdata->m_commandLine, cmdLine);
1302                         psdata->m_fromConsole = FALSE;
1303
1304                         #ifdef MPK_ON
1305                                 BeginThread(fnLaunchPerl, NULL, PERL_COMMAND_STACK_SIZE, (void*)psdata);
1306                         #else
1307                                 // Start a new thread in its own thread group
1308                                 BeginThread(fnLaunchPerl, NULL, PERL_COMMAND_STACK_SIZE, (void*)psdata);
1309                         #endif  //MPK_ON
1310                 }
1311                 else
1312                 {
1313                         free(psdata);
1314                         psdata = NULL;
1315                         return;
1316                 }
1317         }
1318         else
1319                 return;
1320
1321         return;
1322 }
1323
1324
1325
1326 /*============================================================================================
1327
1328  Function               :       fnGetPerlScreenName
1329
1330  Description    :       This function creates the Perl screen name.
1331                                         Gets called from main only once when the Perl NLM loads.
1332
1333  Parameters             :       sPerlScreenName (OUT)   -       Resultant Perl screen name.
1334
1335  Returns                :       Nothing.
1336
1337 ==============================================================================================*/
1338
1339 void fnGetPerlScreenName(char *sPerlScreenName)
1340 {
1341         // HYAK:
1342         // The logic for using 32 in the below array sizes is like this:
1343         // The NetWare CLIB SDK documentation says that for base 2 conversion,
1344         // this number must be minimum 8. Also, in the example of the documentation,
1345         // 20 is used as the size and testing is done for bases from 2 upto 16.
1346         // So, to simply chose a number above 20 and also keeping in mind not to reserve
1347         // unnecessary big array sizes, I have chosen 32 !
1348         // Less than that may also suffice.
1349         char sPerlRevision[32 * sizeof(char)] = {'\0'};
1350         char sPerlVersion[32 * sizeof(char)] = {'\0'};
1351         char sPerlSubVersion[32 * sizeof(char)] = {'\0'};
1352
1353         // The defines for PERL_REVISION, PERL_VERSION, PERL_SUBVERSION are available in
1354         // patchlevel.h  under root and gets included when  perl.h  is included.
1355         // The number 10 below indicates base 10.
1356         itoa(PERL_REVISION, sPerlRevision, 10);
1357         itoa(PERL_VERSION, sPerlVersion, 10);
1358         itoa(PERL_SUBVERSION, sPerlSubVersion, 10);
1359
1360         // Concatenate substrings to get a string like Perl5.6.1 which is used as the screen name.
1361         sprintf(sPerlScreenName, "%s%s.%s.%s", PERL_COMMAND_NAME,
1362                                                                         sPerlRevision, sPerlVersion, sPerlSubVersion);
1363
1364         return;
1365 }
1366
1367
1368
1369 // Global variable to hold the environ information.
1370 // First time it is accessed, it will be created and initialized and 
1371 // next time onwards, the pointer will be returned.
1372
1373 // Improvements - Dynamically read env everytime a request comes - Is this required?
1374 char** genviron = NULL;
1375
1376
1377 /*============================================================================================
1378
1379  Function               :       nw_getenviron
1380
1381  Description    :       Gets the environment information.
1382
1383  Parameters             :       None.
1384
1385  Returns                :       Nothing.
1386
1387 ==============================================================================================*/
1388
1389 char ***
1390 nw_getenviron()
1391 {
1392         if (genviron)
1393                 return (&genviron);     // This might leak memory upto 11736 bytes on some versions of NetWare.
1394 //              return genviron;        // Abending on some versions of NetWare.
1395         else
1396                 fnSetUpEnvBlock(&genviron);
1397
1398         return (&genviron);
1399 }
1400
1401
1402
1403 /*============================================================================================
1404
1405  Function               :       nw_freeenviron
1406
1407  Description    :       Frees the environment information.
1408
1409  Parameters             :       None.
1410
1411  Returns                :       Nothing.
1412
1413 ==============================================================================================*/
1414
1415 void
1416 nw_freeenviron()
1417 {
1418         if (genviron)
1419         {
1420                 fnDestroyEnvBlock(genviron);
1421                 genviron=NULL;
1422         }
1423 }
1424