Further perldelta scrubbing
[perl.git] / NetWare / Nwpipe.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             :       NWPipe.c
12  * DESCRIPTION  :       Functions to implement pipes on NetWare.
13  * Author               :       HYAK
14  * Date                 :       January 2001.
15  *
16  */
17
18
19
20 #include <nwadv.h>
21 #include <nwdsdefs.h>
22
23 #include "win32ish.h"
24 #include "nwpipe.h"
25 #include "nwplglob.h"
26
27
28 // This was added since the compile failed saying "undefined P_WAIT"
29 // when USE_ITHREADS was commented in the makefile
30 #ifndef P_WAIT
31 #define P_WAIT          0
32 #endif
33
34 #ifndef P_NOWAIT
35 #define P_NOWAIT        1
36 #endif
37
38
39
40
41 /*============================================================================================
42
43  Function               :       fnPipeFileMakeArgv
44
45  Description    :       This function makes the argument array.
46
47  Parameters     :       ptpf    (IN)    -       Input structure.
48
49  Returns                :       Boolean.
50
51 ==============================================================================================*/
52
53 BOOL fnPipeFileMakeArgv(PTEMPPIPEFILE ptpf)
54 {
55         int i=0, j=0;
56         int dindex = 0;
57         int sindex = 0;
58
59         ptpf->m_argv_len = 0;
60
61
62         // Below 2 is added for the following reason:
63         //   - The first one is for an additional value that will be added through ptpf->m_redirect.
64         //   - The second one is for a NULL termination of the array.
65         //     This is required for spawnvp API that takes a NULL-terminated array as its 3rd parameter.
66         //     If the array is NOT NULL-terminated, then the server abends at the spawnvp call !!
67         ptpf->m_argv = (char **) malloc((ptpf->m_pipeCommand->m_argc + 2) * sizeof(char*));
68         if (ptpf->m_argv == NULL)
69                 return FALSE;
70
71         // For memory allocation it is just +1 since the last one is only for NULL-termination
72         // and no memory is required to be allocated.
73         for(i=0; i<(ptpf->m_pipeCommand->m_argc + 1); i++)
74         {
75                 ptpf->m_argv[i] = (char *) malloc(MAX_DN_BYTES * sizeof(char));
76                 if (ptpf->m_argv[i] == NULL)
77                 {
78                         for(j=0; j<i; j++)
79                         {
80                                 if(ptpf->m_argv[j])
81                                 {
82                                         free(ptpf->m_argv[j]);
83                                         ptpf->m_argv[j] = NULL;
84                                 }
85                         }
86                         free(ptpf->m_argv);
87                         ptpf->m_argv = NULL;
88
89                         return FALSE;
90                 }
91         }
92
93         // Copy over parsed items, removing "load" keyword if necessary.
94         sindex = ((stricmp(ptpf->m_pipeCommand->m_argv[0], LOAD_COMMAND) == 0) ? 1 : 0);
95         while (sindex < ptpf->m_pipeCommand->m_argc)
96         {
97                 strcpy(ptpf->m_argv[dindex], ptpf->m_pipeCommand->m_argv[sindex]);
98                 dindex++;
99                 sindex++;
100         }
101
102         if (stricmp(ptpf->m_argv[0], PERL_COMMAND_NAME) == 0)   // If Perl is the first command.
103         {
104                 ptpf->m_launchPerl = TRUE;
105
106                 #ifdef MPK_ON
107                         ptpf->m_perlSynchSemaphore = kSemaphoreAlloc((BYTE *)"pipeSemaphore", 0);
108                 #else
109                         ptpf->m_perlSynchSemaphore = OpenLocalSemaphore(0);
110                 #endif  //MPK_ON
111         }
112         else if (stricmp(ptpf->m_argv[0], (char *)"perlglob") == 0)
113                 ptpf->m_doPerlGlob = TRUE;
114
115
116         // Create last argument, which will redirect to or from the temp file
117         if (!ptpf->m_doPerlGlob || ptpf->m_mode)
118         {
119                 if (!ptpf->m_mode)      // If read mode?
120                 {
121                         if (ptpf->m_launchPerl)
122                                 strcpy(ptpf->m_redirect, (char *)">");
123                         else
124                                 strcpy(ptpf->m_redirect, (char *)"(CLIB_OPT)/>");
125                 }
126                 else
127                 {
128                         if (ptpf->m_launchPerl)
129                                 strcpy(ptpf->m_redirect, (char *)"<");
130                         else
131                                 strcpy(ptpf->m_redirect, (char *)"(CLIB_OPT)/<");
132                 }
133                 strcat(ptpf->m_redirect, ptpf->m_fileName);
134
135                 if (ptpf->m_launchPerl)
136                 {
137                         char tbuf[15] = {'\0'};
138                         sprintf(tbuf, (char *)" -{%x", ptpf->m_perlSynchSemaphore);
139                         strcat(ptpf->m_redirect, tbuf);
140                 }
141
142                 strcpy(ptpf->m_argv[dindex], (char*) ptpf->m_redirect);
143                 dindex++;
144         }
145
146         if (dindex < (ptpf->m_pipeCommand->m_argc + 1))
147         {
148                 if(ptpf->m_argv[dindex])
149                 {
150                         free(ptpf->m_argv[dindex]);
151                         ptpf->m_argv[dindex] = NULL;    // NULL termination - required for  spawnvp  call.
152                 }
153         }
154
155         ptpf->m_argv_len = dindex;              // Length of the argv array  OR  number of argv string values.
156         ptpf->m_argv[ptpf->m_argv_len] = NULL;  // NULL termination - required for  spawnvp  call.
157
158
159         return TRUE;
160 }
161
162
163 /*============================================================================================
164
165  Function               :       fnPipeFileOpen
166
167  Description    :       This function opens the pipe file.
168
169  Parameters     :       ptpf    (IN)    -       Input structure.
170                                         command (IN)    -       Input command string.
171                                         mode    (IN)    -       Mode of opening.
172
173  Returns                :       File pointer.
174
175 ==============================================================================================*/
176
177 FILE* fnPipeFileOpen(PTEMPPIPEFILE ptpf, char* command, char* mode)
178 {
179         int i=0, j=0;
180
181         char tempName[_MAX_PATH] = {'\0'};
182
183
184         ptpf->m_fileName = (char *) malloc(_MAX_PATH * sizeof(char));
185         if(ptpf->m_fileName == NULL)
186                 return NULL;
187
188         // The char array is emptied so that there is no junk characters.
189         strncpy(ptpf->m_fileName, "", (_MAX_PATH * sizeof(char)));
190         
191
192         // Save off stuff
193         //
194         if(strchr(mode,'r') != 0)
195                 ptpf->m_mode = FALSE;   // Read mode
196         else if(strchr(mode,'w') != 0)
197                 ptpf->m_mode = TRUE;    // Write mode
198         else
199         {
200                 if(ptpf->m_fileName != NULL)
201                 {
202 //                      if (strlen(ptpf->m_fileName))
203                         if (ptpf->m_fileName)
204                                 unlink(ptpf->m_fileName);
205
206                         free(ptpf->m_fileName);
207                         ptpf->m_fileName = NULL;
208                 }
209
210                 return NULL;
211         }
212
213
214         ptpf->m_pipeCommand = (PCOMMANDLINEPARSER) malloc(sizeof(COMMANDLINEPARSER));
215         if (!ptpf->m_pipeCommand)
216         {
217 //              if (strlen(ptpf->m_fileName))
218                 if (ptpf->m_fileName)
219                         unlink(ptpf->m_fileName);
220
221                 free(ptpf->m_fileName);
222                 ptpf->m_fileName = NULL;
223
224                 return NULL;
225         }
226
227         // Initialise the variables
228         ptpf->m_pipeCommand->m_isValid = TRUE;
229
230 /****
231 // Commented since these are not being used.  Still retained here.
232 // To be removed once things are proved to be working fine to a good confident level,
233
234         ptpf->m_pipeCommand->m_redirInName = NULL;
235         ptpf->m_pipeCommand->m_redirOutName = NULL;
236         ptpf->m_pipeCommand->m_redirErrName = NULL;
237         ptpf->m_pipeCommand->m_redirBothName = NULL;
238         ptpf->m_pipeCommand->nextarg = NULL;
239 ****/
240
241         ptpf->m_pipeCommand->sSkippedToken = NULL;
242         ptpf->m_pipeCommand->m_argv = NULL;
243         ptpf->m_pipeCommand->new_argv = NULL;
244
245         #ifdef MPK_ON
246                 ptpf->m_pipeCommand->m_qSemaphore = NULL;
247         #else
248                 ptpf->m_pipeCommand->m_qSemaphore = 0L;
249         #endif  //MPK_ON
250
251         ptpf->m_pipeCommand->m_noScreen = 0;
252         ptpf->m_pipeCommand->m_AutoDestroy = 0;
253         ptpf->m_pipeCommand->m_argc = 0;
254         ptpf->m_pipeCommand->m_argv_len = 1;
255
256
257         ptpf->m_pipeCommand->m_argv = (char **) malloc(ptpf->m_pipeCommand->m_argv_len * sizeof(char *));
258         if (ptpf->m_pipeCommand->m_argv == NULL)
259         {
260                 free(ptpf->m_pipeCommand);
261                 ptpf->m_pipeCommand = NULL;
262
263 //              if (strlen(ptpf->m_fileName))
264                 if (ptpf->m_fileName)
265                         unlink(ptpf->m_fileName);
266
267                 free(ptpf->m_fileName);
268                 ptpf->m_fileName = NULL;
269
270                 return NULL;
271         }
272         ptpf->m_pipeCommand->m_argv[0] = (char *) malloc(MAX_DN_BYTES * sizeof(char));
273         if (ptpf->m_pipeCommand->m_argv[0] == NULL)
274         {
275                 for(j=0; j<i; j++)
276                 {
277                         if(ptpf->m_pipeCommand->m_argv[j])
278                         {
279                                 free(ptpf->m_pipeCommand->m_argv[j]);
280                                 ptpf->m_pipeCommand->m_argv[j]=NULL;
281                         }
282                 }
283                 free(ptpf->m_pipeCommand->m_argv);
284                 ptpf->m_pipeCommand->m_argv=NULL;
285
286                 free(ptpf->m_pipeCommand);
287                 ptpf->m_pipeCommand = NULL;
288
289 //              if (strlen(ptpf->m_fileName))
290                 if (ptpf->m_fileName)
291                         unlink(ptpf->m_fileName);
292
293                 free(ptpf->m_fileName);
294                 ptpf->m_fileName = NULL;
295
296                 return NULL;
297         }
298
299
300         ptpf->m_redirect = (char *) malloc(MAX_DN_BYTES * sizeof(char));
301         if (ptpf->m_redirect == NULL)
302         {
303                 for(i=0; i<ptpf->m_pipeCommand->m_argv_len; i++)
304                 {
305                         if(ptpf->m_pipeCommand->m_argv[i] != NULL)
306                         {
307                                 free(ptpf->m_pipeCommand->m_argv[i]);
308                                 ptpf->m_pipeCommand->m_argv[i] = NULL;
309                         }
310                 }
311
312                 free(ptpf->m_pipeCommand->m_argv);
313                 ptpf->m_pipeCommand->m_argv = NULL;
314
315                 free(ptpf->m_pipeCommand);
316                 ptpf->m_pipeCommand = NULL;
317
318
319 //              if (strlen(ptpf->m_fileName))
320                 if (ptpf->m_fileName)
321                         unlink(ptpf->m_fileName);
322
323                 free(ptpf->m_fileName);
324                 ptpf->m_fileName = NULL;
325
326                 return NULL;
327         }
328
329         // The char array is emptied.
330         // If it is not done so, then it could contain some junk values and the string length in that case
331         // will not be zero.  This causes erroneous results in  fnPipeFileMakeArgv()  function
332         // where  strlen(ptpf->m_redirect)  is used as a check for incrementing the parameter count and
333         // it will wrongly get incremented in such cases.
334         strncpy(ptpf->m_redirect, "", (MAX_DN_BYTES * sizeof(char)));
335
336         // Parse the parameters.
337         fnCommandLineParser(ptpf->m_pipeCommand, (char *)command, TRUE);
338         if (!ptpf->m_pipeCommand->m_isValid)
339         {
340                 fnTempPipeFileReleaseMemory(ptpf);
341                 return NULL;
342         }
343
344
345         // Create a temporary file name
346         //
347         strncpy ( tempName, fnNwGetEnvironmentStr((char *)"TEMP", NWDEFPERLTEMP), (_MAX_PATH - 20) );
348         tempName[_MAX_PATH-20] = '\0';
349         strcat(tempName, (char *)"\\plXXXXXX.tmp");
350         if (!fnMy_MkTemp(tempName))
351         {
352                 fnTempPipeFileReleaseMemory(ptpf);
353                 return NULL;
354         }
355
356         // create a temporary place-holder file
357         fclose(fopen(tempName, (char *)"w"));
358         strcpy(ptpf->m_fileName, tempName);
359
360
361         // Make the argument array
362         if(!fnPipeFileMakeArgv(ptpf))
363         {
364                 fnTempPipeFileReleaseMemory(ptpf);
365
366                 // Release additional memory
367                 if(ptpf->m_argv != NULL)
368                 {
369                         for(i=0; i<ptpf->m_argv_len; i++)
370                         {
371                                 if(ptpf->m_argv[i] != NULL)
372                                 {
373                                         free(ptpf->m_argv[i]);
374                                         ptpf->m_argv[i] = NULL;
375                                 }
376                         }
377
378                         free(ptpf->m_argv);
379                         ptpf->m_argv = NULL;
380                 }
381
382                 return NULL;
383         }
384
385
386         // Open the temp file in the appropriate way...
387         //
388         if (!ptpf->m_mode)      // If Read mode?
389         {
390                 // we wish to spawn a command, intercept its output,
391                 // and then get that output
392                 //
393                 if (!ptpf->m_argv[0])
394                 {
395                         fnTempPipeFileReleaseMemory(ptpf);
396
397                         // Release additional memory
398                         if(ptpf->m_argv != NULL)
399                         {
400                                 for(i=0; i<ptpf->m_argv_len; i++)
401                                 {
402                                         if(ptpf->m_argv[i] != NULL)
403                                         {
404                                                 free(ptpf->m_argv[i]);
405                                                 ptpf->m_argv[i] = NULL;
406                                         }
407                                 }
408
409                                 free(ptpf->m_argv);
410                                 ptpf->m_argv = NULL;
411                         }
412
413                         return NULL;
414                 }
415
416                 if (ptpf->m_launchPerl)
417                         fnPipeFileDoPerlLaunch(ptpf);
418                 else
419                         if (ptpf->m_doPerlGlob)
420                                 fnDoPerlGlob(ptpf->m_argv, ptpf->m_fileName);   // hack to do perl globbing
421                 else
422                         spawnvp(P_WAIT, ptpf->m_argv[0], ptpf->m_argv);
423
424                 ptpf->m_file = fopen (ptpf->m_fileName, (char *)"r");   // Get the Pipe file handle
425         }
426         else if (ptpf->m_mode)  // If Write mode?
427         {
428                 // we wish to open the file for writing now and
429                 // do the command later
430                 //
431                 ptpf->m_file = fopen(ptpf->m_fileName, (char *)"w");
432         }
433
434         fnTempPipeFileReleaseMemory(ptpf);
435
436         // Release additional memory
437         if(ptpf->m_argv != NULL)
438         {
439                 for(i=0; i<(ptpf->m_argv_len); i++)
440                 {
441                         if(ptpf->m_argv[i] != NULL)
442                         {
443                                 free(ptpf->m_argv[i]);
444                                 ptpf->m_argv[i] = NULL;
445                         }
446                 }
447
448                 free(ptpf->m_argv);
449                 ptpf->m_argv = NULL;
450         }
451
452                 
453         return ptpf->m_file;    // Return the Pipe file handle.
454 }
455
456
457 /*============================================================================================
458
459  Function               :       fnPipeFileClose
460
461  Description    :       This function closes the pipe file.
462
463  Parameters     :       ptpf    (IN)    -       Input structure.
464
465  Returns                :       Nothing.
466
467 ==============================================================================================*/
468
469 void fnPipeFileClose(PTEMPPIPEFILE ptpf)
470 {
471         int i = 0;
472
473         if (ptpf->m_mode)       // If Write mode?
474         {
475                 // we wish to spawn a command using our temp file for
476                 // its input
477                 //
478                 if(ptpf->m_file != NULL)
479                 {
480                         fclose (ptpf->m_file);
481                         ptpf->m_file = NULL;
482                 }
483
484                 if (ptpf->m_launchPerl)
485                         fnPipeFileDoPerlLaunch(ptpf);
486                 else if (ptpf->m_argv)
487                         spawnvp(P_WAIT, ptpf->m_argv[0], ptpf->m_argv);
488         }
489
490
491         // Close the temporary Pipe File, if opened
492         if (ptpf->m_file)
493         {
494                 fclose(ptpf->m_file);
495                 ptpf->m_file = NULL;
496         }
497         // Delete the temporary Pipe Filename if still valid and free the memory associated with the file name.
498         if(ptpf->m_fileName != NULL)
499         {
500 //              if (strlen(ptpf->m_fileName))
501                 if (ptpf->m_fileName)
502                         unlink(ptpf->m_fileName);
503
504                 free(ptpf->m_fileName);
505                 ptpf->m_fileName = NULL;
506         }
507
508 /**
509         if(ptpf->m_argv != NULL)
510         {
511                 for(i=0; i<(ptpf->m_argv_len); i++)
512                 {
513                         if(ptpf->m_argv[i] != NULL)
514                         {
515                                 free(ptpf->m_argv[i]);
516                                 ptpf->m_argv[i] = NULL;
517                         }
518                 }
519
520                 free(ptpf->m_argv);
521                 ptpf->m_argv = NULL;
522         }
523 **/
524
525         if (ptpf->m_perlSynchSemaphore)
526         {
527                 #ifdef MPK_ON
528                         kSemaphoreFree(ptpf->m_perlSynchSemaphore);
529                 #else
530                         CloseLocalSemaphore(ptpf->m_perlSynchSemaphore);
531                 #endif  //MPK_ON
532         }
533
534
535         return;
536 }
537
538
539 /*============================================================================================
540
541  Function               :       fnPipeFileDoPerlLaunch
542
543  Description    :       This function launches Perl.
544
545  Parameters     :       ptpf    (IN)    -       Input structure.
546
547  Returns                :       Nothing.
548
549 ==============================================================================================*/
550
551 void fnPipeFileDoPerlLaunch(PTEMPPIPEFILE ptpf)
552 {
553         char curdir[_MAX_PATH] = {'\0'};
554         char* pcwd = NULL;
555
556         int i=0;
557
558
559         // save off the current working directory to restore later
560         // this is just a hack! these problems of synchronization and
561         // restoring calling context need a much better solution!
562         pcwd = (char *)getcwd(curdir, sizeof(curdir)-1);
563         fnSystemCommand(ptpf->m_argv, ptpf->m_argv_len);
564         if (ptpf->m_perlSynchSemaphore)
565         {
566                 #ifdef MPK_ON
567                         kSemaphoreWait(ptpf->m_perlSynchSemaphore);
568                 #else
569                         WaitOnLocalSemaphore(ptpf->m_perlSynchSemaphore);
570                 #endif  //MPK_ON
571         }
572
573         if (pcwd)
574                 chdir(pcwd);
575
576         return;
577 }
578
579
580 /*============================================================================================
581
582  Function               :       fnTempPipeFile
583
584  Description    :       This function initialises the variables of the structure passed in.
585
586  Parameters     :       ptpf    (IN)    -       Input structure.
587
588  Returns                :       Nothing.
589
590 ==============================================================================================*/
591
592 void fnTempPipeFile(PTEMPPIPEFILE ptpf)
593 {
594         ptpf->m_fileName = NULL;
595
596         ptpf->m_mode = FALSE;   // Default mode = Read mode.
597         ptpf->m_file = NULL;
598         ptpf->m_pipeCommand = NULL;
599         ptpf->m_argv = NULL;
600
601         ptpf->m_redirect = NULL;
602
603         ptpf->m_launchPerl = FALSE;
604         ptpf->m_doPerlGlob = FALSE;
605
606         #ifdef MPK_ON
607                 ptpf->m_perlSynchSemaphore = NULL;
608         #else
609                 ptpf->m_perlSynchSemaphore = 0L;
610         #endif
611
612         ptpf->m_argv_len = 0;
613
614         return;
615 }
616
617
618 /*============================================================================================
619
620  Function               :       fnTempPipeFileReleaseMemory
621
622  Description    :       This function frees the memory allocated to various buffers.
623
624  Parameters     :       ptpf    (IN)    -       Input structure.
625
626  Returns                :       Nothing.
627
628 ==============================================================================================*/
629
630 void fnTempPipeFileReleaseMemory(PTEMPPIPEFILE ptpf)
631 {
632         int i=0;
633
634
635         if (ptpf->m_pipeCommand)
636         {
637                 if(ptpf->m_pipeCommand->m_argv != NULL)
638                 {
639                         for(i=0; i<ptpf->m_pipeCommand->m_argv_len; i++)
640                         {
641                                 if(ptpf->m_pipeCommand->m_argv[i] != NULL)
642                                 {
643                                         free(ptpf->m_pipeCommand->m_argv[i]);
644                                         ptpf->m_pipeCommand->m_argv[i] = NULL;
645                                 }
646                         }
647
648                         free(ptpf->m_pipeCommand->m_argv);
649                         ptpf->m_pipeCommand->m_argv = NULL;
650                 }
651
652                 if(ptpf->m_pipeCommand->sSkippedToken != NULL)
653                 {
654                         free(ptpf->m_pipeCommand->sSkippedToken);
655                         ptpf->m_pipeCommand->sSkippedToken = NULL;
656                 }
657 /****
658 // Commented since these are not being used.  Still retained here.
659 // To be removed once things are proved to be working fine to a good confident level,
660
661                 if(ptpf->m_pipeCommand->nextarg)
662                 {
663                         free(ptpf->m_pipeCommand->nextarg);
664                         ptpf->m_pipeCommand->nextarg = NULL;
665                 }
666
667                 if(ptpf->m_pipeCommand->m_redirInName)
668                 {
669                         free(ptpf->m_pipeCommand->m_redirInName);
670                         ptpf->m_pipeCommand->m_redirInName = NULL;
671                 }
672                 if(ptpf->m_pipeCommand->m_redirOutName)
673                 {
674                         free(ptpf->m_pipeCommand->m_redirOutName);
675                         ptpf->m_pipeCommand->m_redirOutName = NULL;
676                 }
677                 if(ptpf->m_pipeCommand->m_redirErrName)
678                 {
679                         free(ptpf->m_pipeCommand->m_redirErrName);
680                         ptpf->m_pipeCommand->m_redirErrName = NULL;
681                 }
682                 if(ptpf->m_pipeCommand->m_redirBothName)
683                 {
684                         free(ptpf->m_pipeCommand->m_redirBothName);
685                         ptpf->m_pipeCommand->m_redirBothName = NULL;
686                 }
687 ****/
688
689                 if(ptpf->m_pipeCommand != NULL)
690                 {
691                         free(ptpf->m_pipeCommand);
692                         ptpf->m_pipeCommand = NULL;
693                 }
694         }
695
696         if(ptpf->m_redirect != NULL)
697         {
698                 free(ptpf->m_redirect);
699                 ptpf->m_redirect = NULL;
700         }
701
702         return;
703 }
704