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