static int SysRunCommandPipe( const char *cmd, HFILE *readpipe )
{
HFILE pipe_input;
HFILE pipe_output;
HFILE std_output;
HFILE std_error;
char *cmdnam;
char *sp;
int rc;
cmdnam = strdup( cmd );
if( cmdnam == NULL )
return( -1 );
sp = strchr( cmdnam, ' ' );
if( sp != NULL ) {
*sp = '\0';
sp++;
}
rc = -1;
std_output = 1;
std_error = 2;
if( DosCreatePipe( readpipe, &pipe_output, BUFSIZE ) == 0 ) {
if( DosDupHandle( pipe_output, &std_output ) == 0 ) {
if( DosDupHandle( pipe_output, &std_error ) == 0 ) {
DosClose( pipe_output );
rc = spawnl( P_NOWAIT, cmdnam, cmdnam, sp, NULL );
DosClose( std_output );
DosClose( std_error );
}
}
}
free( cmdnam );
return( rc );
}
static void Test(void *arg)
{
#ifdef XP_OS2
HFILE pipefd[2];
#else
int pipefd[2];
#endif
int rv;
char c = '\0';
#ifdef XP_OS2
if (DosCreatePipe(&pipefd[0], &pipefd[1], 4096) != 0) {
#else
if (pipe(pipefd) == -1) {
#endif
fprintf(stderr, "cannot create pipe: %d\n", errno);
exit(1);
}
close(pipefd[0]);
rv = write(pipefd[1], &c, 1);
if (rv != -1) {
fprintf(stderr, "write to broken pipe should have failed with EPIPE but returned %d\n", rv);
exit(1);
}
#ifdef SYMBIAN
/* Have mercy on the unknown 142 errno, it seems ok */
if (errno != EPIPE && errno != 142) {
#else
if (errno != EPIPE) {
#endif
fprintf(stderr, "write to broken pipe failed but with wrong errno: %d\n", errno);
exit(1);
}
close(pipefd[1]);
printf("write to broken pipe failed with EPIPE, as expected\n");
}
int main(int argc, char **argv)
{
PRThread *thread;
/* This initializes NSPR. */
PR_SetError(0, 0);
thread = PR_CreateThread(PR_USER_THREAD, Test, NULL, PR_PRIORITY_NORMAL,
PR_GLOBAL_THREAD, PR_JOINABLE_THREAD, 0);
if (thread == NULL) {
fprintf(stderr, "PR_CreateThread failed\n");
exit(1);
}
if (PR_JoinThread(thread) == PR_FAILURE) {
fprintf(stderr, "PR_JoinThread failed\n");
exit(1);
}
Test(NULL);
printf("PASSED\n");
return 0;
}
Buffer* launcher(char* command, char* expr, int type, int* prc)
{
int rc = 0;
if(!command || !command[0])
return 0;
HFILE hPipe[2] = {(HFILE)-1, (HFILE)-1};
Buffer* buf = 0;
do
{
rc = DosCreatePipe(&hPipe[0], &hPipe[1], 4096);
if(rc)
break;
// noinherit(hPipe[0]);
// noinherit(hPipe[1]);
rc = redirect_and_run(hPipe[0], hPipe[1], (type) ? STDERR:STDOUT, command);
if(rc)
break;
buf = filter_pipe(hPipe[0], expr);
}
while(0);
DosClose(hPipe[0]);
DosClose(hPipe[1]);
if(prc)
*prc = rc;
return buf;
}
_WCRTLINK int _pipe( int *phandles, unsigned psize, int textmode )
/****************************************************************/
{
#if defined(__NT__)
HANDLE hRead, hWrite;
// HANDLE osHandle; // removed by JBS
BOOL rc;
SECURITY_ATTRIBUTES sa;
#elif defined(__OS2__) && defined(__386__)
HFILE hRead, hWrite;
APIRET rc;
#elif defined(__OS2__) && !defined(__386__)
HFILE hRead, hWrite;
USHORT rc;
#endif
int hReadPosix, hWritePosix;
// removed by JBS - allow O_NOINHERIT
// /*** Sanity check ***/
// if( textmode != 0 && textmode != _O_TEXT && textmode != _O_BINARY ) {
// return( -1 );
// }
/*** Create the pipes (note that psize==0 ==> use default size) ***/
#if defined(__NT__)
sa.nLength = sizeof( SECURITY_ATTRIBUTES );
sa.lpSecurityDescriptor = NULL;
sa.bInheritHandle = (((textmode & O_NOINHERIT)==O_NOINHERIT)?FALSE:TRUE);
rc = CreatePipe( &hRead, &hWrite, &sa, psize );
if( rc == FALSE ) {
return( __set_errno_nt() );
}
#elif defined(__OS2__)
if( psize == 0 ) psize = 4096;
#ifdef __386__
rc = DosCreatePipe( &hRead, &hWrite, psize );
#else
rc = DosMakePipe( &hRead, &hWrite, psize );
#endif
if( rc != NO_ERROR ) {
__set_errno( ENOMEM );
return( -1 );
}
#endif
// removed by JBS - used sa struct instead
// /*** Make read handle inheritable ***/
// #ifdef __NT__
// rc = DuplicateHandle( GetCurrentProcess(), hRead, GetCurrentProcess(),
// &osHandle, 0, TRUE, DUPLICATE_SAME_ACCESS );
// if( rc == FALSE ) {
// CloseHandle( hRead );
// CloseHandle( hWrite );
// return( -1 );
// }
// CloseHandle( hRead );
// hRead = osHandle;
// #elif defined(__OS2__)
// /* Handle is inheritable by default */
// #endif
//
// /*** Make write handle inheritable ***/
// #ifdef __NT__
// rc = DuplicateHandle( GetCurrentProcess(), hWrite, GetCurrentProcess(),
// &osHandle, 0, TRUE, DUPLICATE_SAME_ACCESS );
// if( rc == FALSE ) {
// CloseHandle( hRead );
// CloseHandle( hWrite );
// return( -1 );
// }
// CloseHandle( hWrite );
// hWrite = osHandle;
// #elif defined(__OS2__)
// /* Handle is inheritable by default */
// #endif
/*** Initialize the POSIX-level handles ***/
hReadPosix = _hdopen( (int)hRead, textmode|_O_RDONLY );
hWritePosix = _hdopen( (int)hWrite, textmode|_O_WRONLY );
if( hReadPosix == -1 || hWritePosix == -1 ) {
if( hReadPosix != -1 ) {
close( hReadPosix );
} else {
#if defined(__NT__)
CloseHandle( hRead );
#elif defined(__OS2__)
DosClose( hRead );
#endif
}
if( hWritePosix != -1 ) {
close( hWritePosix );
} else {
#if defined(__NT__)
CloseHandle( hWrite );
#elif defined(__OS2__)
DosClose( hWrite );
#endif
}
return( -1 );
}
/*** Store the new POSIX handles in return buffer ***/
phandles[0] = hReadPosix;
phandles[1] = hWritePosix;
return( 0 );
}
int main(int argc, char * argv[])
{
int i;
char cmdLine[CCHMAXPATH*4]={0};
char * chrPtr;
char * chrPtr2;
HWND hwndNotify;
char exeName[CCHMAXPATH];//="g:\\projects_working\\audiocpy\\cdrecord.exe";
char chrError[CCHMAXPATH];
RESULTCODES resultCodes;
ULONG rc,ulAction;
int a;
char puffer[1024];
LONG lValue1=0;
LONG lValue2=0;
/* Vars for check size */
int iLeadin;
int iLeadout;
int size;
HFILE hfNew;
HFILE hfSave;
HPIPE hpR, hpW;
ULONG cbRead, cbWritten;
BOOL bBreak=TRUE;
char *text,*text2;
CHAR achBuf[PIPESIZE]={0};
CHAR szFailName[CCHMAXPATH];
RESULTCODES ChildRC= {0};
PID pidChild;
/*
argv[0]: progname
argv[1]: hwnd
argv[2]: cdrecord path
argv[3]: dev=x,y,z
*/
/* Have to check if argc is really 4 */
if(argc<4) {
message();
exit(-1);
}
/* Print the parameters in VIO window */
printf("argc:%d\n",argc);
for(a=0;a<argc;a++)
{
printf("%d: %s\n",a,argv[a]);
}
printf("\n");
hwndNotify=atol(argv[1]);
/* Error: no cdrecord options given */
if(argc<4) {
WinPostMsg(hwndNotify,WM_APPTERMINATENOTIFY,MPFROMLONG(lValue1),MPFROMLONG(lValue2));
return;
}
/* Get input */
sprintf(exeName,"%s",argv[2]);// cdrecord/2 path
for(i=3;i<argc;i++) {
/* Find 'dev=' in option string */
chrPtr=strstr(argv[i],"dev=");
if(chrPtr!=NULL)i=argc;
}
/* Build cdrecord/2 cmd-line */
sprintf(cmdLine,"%s",exeName);
if((chrPtr=strrchr(cmdLine, 0))==NULL) {
WinPostMsg(hwndNotify,WM_APPTERMINATENOTIFY,MPFROMLONG(0),MPFROMLONG(0));
return;
}
chrPtr++;
sprintf(chrPtr,"%s -msinfo", argv[3]);
if(DosCreatePipe(&hpR,&hpW,1024)) {
WinPostMsg(hwndNotify,WM_APPTERMINATENOTIFY,MPFROMLONG(0),MPFROMLONG(0));
return;
}
if((chrPtr=strrchr(cmdLine, 0))==NULL) {
WinPostMsg(hwndNotify,WM_APPTERMINATENOTIFY,MPFROMLONG(0),MPFROMLONG(0));
return;
}
/* Save stdout */
hfSave=-1;
if(!DosDupHandle(HF_STDOUT,&hfSave)){/* Saves standard handle *//* Saves standard handle */
/* Redirect stdout */
hfNew=HF_STDOUT;
if(!DosDupHandle(hpW,&hfNew)) {
/* start cdrecord/2 */
rc=DosExecPgm(chrError,sizeof(chrError),EXEC_ASYNC,cmdLine,0,&resultCodes,exeName);
fprintf(stderr,"DosExecPgm() for CDRecord/2 returned: %d\n",rc);
DosClose(hpW); /* Closes write handle to ensure */
/* Notification at child termination */
DosDupHandle(hfSave, &hfNew); /* Brings stdout back */
/*
* Read from the pipe and write to the screen
* as long as there are bytes to read.
*/
do {
/* Retrieve output */
rc=DosRead(hpR,puffer,sizeof(puffer),&cbRead);
DosWrite(HF_STDERR, puffer, cbRead, &cbWritten);
if(cbRead>2) {
lValue1=atol(puffer);// Previous session start sector
puffer[1023]=0; //Make sure we have a terminating zero!
chrPtr=strchr(puffer,',');
chrPtr++;
lValue2=atol(chrPtr);
}
} while(cbRead);
DosClose(hpR);
bBreak=FALSE;
}/* if(!DosDupHandle(hpW,&hfNew)) */
}/* if(!DosDupHandle(HF_STDOUT,&hfSave)) */
/* Get leadin and leadout */
if(!bBreak) {
/* Now query size */
sprintf(achBuf,"%s",argv[2]);/* cdrecord path */
text=strchr(achBuf,0);
if(!text) {
WinPostMsg(hwndNotify,WM_APPTERMINATENOTIFY,MPFROMLONG(0),MPFROMLONG(0));
}
text++;
sprintf(text,"%s -toc -v", argv[3]);
printf("Parameters for size query: %s\n",text);
text=achBuf;
printf("Cdrecord path is: %s\n",text);
/* Redirect stdout */
hfSave = -1;// Get new handle
hfNew = HF_STDOUT;
if(!DosDupHandle(HF_STDOUT, &hfSave)){ /* Saves standard handle */
if(!DosCreatePipe(&hpR, &hpW, PIPESIZE)){ /* Creates pipe */
/* If the pipe size is smaller than the output of the child the system() call blocks.
So create the pipe big enough. */
if(!DosDupHandle(hpW, &hfNew)){ /* Duplicates standard output handle */
/* start CDRecord/2 */
rc=DosExecPgm(szFailName,sizeof(szFailName),EXEC_ASYNCRESULT, text,NULL,&ChildRC, text);
fprintf(stderr,"DosExecPgm() for CDRecord/2 returned: %d\n",rc);
/*
rc=system(text);
*/
DosClose(hpW); /* Closes write handle to ensure */
/* Notification at child termination */
DosDupHandle(hfSave, &hfNew); /* Brings stdout back */
/*
* Read from the pipe and write to the screen
* as long as there are bytes to read.
*/
do {
DosRead(hpR, achBuf, sizeof(achBuf), &cbRead);
DosWrite(HF_STDERR, achBuf, cbRead, &cbWritten);
text=strstr(achBuf,"ATIP");
if(text){
/* Check if we have a lead in section */
text2=strstr(text,"in:");
if(text2) {
/* Yes, we have a lead in. Seems to be a blank disk. Find lead out now */
iLeadin=0;
text2++;
text=strstr(text2,"ATIP");/* Second ATIP shows lead out of blank disk */
if(text)
sscanf(text,"%[^:]: %ld",szFailName,&iLeadout);
}/* if(text2) */
else {
/* No lead in section. It seems to be a disk with some tracks already written */
sscanf(text,"%[^:]: %ld",szFailName,&iLeadout); /* ATIP shows disk lead out */
text2=strstr(text,"lout");
if(!text2){/* Error */
iLeadin=iLeadout;/* Set disk size to zero as error */
break;
}
/* Lead out of track is lead in of next track */
sscanf(text2,"%[^:]: %ld",szFailName,&iLeadin);
}
}
} while(cbRead);
printf("Leadin is %d \n",iLeadin); /* We use stdout because stderr is redirected */
printf("Leadout is %d \n",iLeadout);
DosClose(hpR);
}
}
}/* if(!DosDupHandle(HF_STDERR, &hfSave)) */
DosWaitChild(DCWA_PROCESS, DCWW_WAIT,&ChildRC, &pidChild, ChildRC.codeTerminate);
if(ChildRC.codeResult!=0) {
WinPostMsg(hwndNotify,WM_APPTERMINATENOTIFY,MPFROMLONG(0),MPFROMLONG(0));
exit(0);
}
/* Calculate free space */
size=iLeadout-iLeadin;
if(iLeadin) {
/* Because iLeadin isn't zero, the disk seems to be a disk with already written session.
11400 sectors must be substracted from the size as lead in for the next session */
if(size<11400)
size=0;
else
size-=11400;
}
}
printf("1. sector: %d\n2. sector: %d\n", lValue1, lValue2);
/* The following kombinations of leadin, out, 1. sector and 2. sector are possible:
Open CD with previous session: xxx, xxx, ???, xxx
Empty CD: 0 , xxx, 0 , 0
Closed CD: 0 , 0 , 0 , 0 (???)
Closed CD: xxx, xxxx, 0 , 0
No CD: 0 , 0 , 0 , 0
*/
/* Full or no CD -> Error */
if(!lValue1 && !lValue2 && !iLeadin && !iLeadout) {
WinPostMsg(hwndNotify,WM_APPTERMINATENOTIFY,MPFROMLONG(0),MPFROMLONG(0));
exit(0);
}
if(!lValue1 && !lValue2 && iLeadin && iLeadout) {
WinPostMsg(hwndNotify,WM_APPTERMINATENOTIFY,MPFROMLONG(0),MPFROMLONG(0));
exit(0);
}
/* Empty CD. Mark it by sending 1 for the sectors */
if(!lValue1 && !lValue2 && iLeadout) {
WinPostMsg(hwndNotify,WM_APPTERMINATENOTIFY,MPFROMLONG(1),MPFROMLONG(1));
exit(0);
}
/* Send the two values to our notification window */
WinPostMsg(hwndNotify,WM_APPTERMINATENOTIFY,MPFROMLONG(lValue1),MPFROMLONG(lValue2));
exit(0);
}
/*
* Marks the end of writing. Returns ElvTrue if all is okay, or ElvFalse if
* error.
*
* For UNIX, the temp file is closed, and the program is forked.
* (Since this function is only called when willwrite, the program
* wasn't forked when prgopen() was called.) Returns ElvTrue if the
* fork was successful, or ElvFalse if it failed.
*/
ELVBOOL
prggo (void)
{
HFILE r_pipe, w_pipe; /* two ends of a pipe */
SAVE_IO save_io;
HFILE fd, tmp_fd;
APIRET rc;
/* If we weren't writing, then there's nothing to be done here */
if (writefd < 0)
{
return ElvTrue;
}
/*
* If we're using a temp file, close it for writing, then spawn
* the program with its stdin redirected to come from the file.
*/
if (command)
{
/* Close the temp file for writing. */
close (writefd);
writefd = -1;
/* Make a pipe to use for reading stdout/stderr. */
rc = DosCreatePipe (&r_pipe, &w_pipe, 4096);
if (rc != NO_ERROR)
{
msg (MSG_ERROR, "can't create pipe");
goto Error;
}
/* Save all of the standard I/O handles. */
if (!SaveStdIOHandles (save_io,
SAVE_STDIN | SAVE_STDOUT | SAVE_STDERR))
{
goto Error;
}
/*
* Redirect standard file handles for the CHILD PROCESS.
*/
/* Get stdin from the temporary file. */
tmp_fd = open (tempfname, O_RDONLY);
fd = 0;
if (DosDupHandle (tmp_fd, &fd) != NO_ERROR)
{
goto DupError;
}
close(tmp_fd);
/* Connect the write end of the pipe to stdout/stderr. */
fd = 1;
if (DosDupHandle (w_pipe, &fd) != NO_ERROR)
{
goto DupError;
}
fd = 2;
if (DosDupHandle (w_pipe, &fd) != NO_ERROR)
{
goto DupError;
}
/*
* Prevent the child process from inheriting the read end
* of the pipe. This will ensure that the pipe closes
* cleanly when the parent process (elvis) is done with it.
*/
if (DosSetFHState (r_pipe, OPEN_FLAGS_NOINHERIT) != NO_ERROR)
{
msg (MSG_ERROR, "can't set file inheritance");
goto Error;
}
/* Launch the command. */
if ((pid = RunCommand (command)) < 0)
{
msg (MSG_ERROR, "can't spawn");
goto Error;
}
/* Restore standard file handles for the PARENT PROCESS. */
RestoreStdIOHandles (save_io);
/*
* Close the write end of the pipe; the read end becomes
* 'readfd'.
*/
DosClose (w_pipe);
w_pipe = NULLHANDLE;
readfd = r_pipe;
/* We don't need the command string any more. */
free (command);
}
else /* writing but not reading */
{
/* close the writefd */
close (writefd);
writefd = -1;
}
return ElvTrue;
DupError:
msg (MSG_ERROR, "can't dup file handle");
Error:
/* Restore standard I/O handles if necessary. */
RestoreStdIOHandles (save_io);
return ElvFalse;
}
/*
* Declares which program we'll run, and what we'll be doing with it.
* This function should return ElvTrue if successful. If there is an error,
* it should issue an error message via msg(), and return ElvFalse.
*
* For UNIX, the behavior of this function depends on willwrite.
* If willwrite, then the command is saved and a temporary file is
* is created to store the data that will become the program's stdin,
* and the function succeeds if the temp file was created successfully.
* Else the program is forked (with stdout/stderr redirected to a pipe
* if willread) and the function succedes if pipe() and fork()
* succeed.
*/
ELVBOOL
prgopen (char *cmd, /* command string */
ELVBOOL willwrite, /* if ElvTrue, redirect command's stdin */
ELVBOOL willread) /* if ElvTrue, redirect command's stdout */
{
HFILE r_pipe, w_pipe; /* two ends of a pipe */
SAVE_IO save_io;
HFILE fd;
APIRET rc;
/* Mark both fd's as being unused */
writefd = readfd = -1;
/* Next step depends on what I/O we expect to do with this program */
if (willwrite && willread)
{
/* save the command */
command = strdup (cmd);
/* create a temporary file for feeding the program's stdin */
sprintf (tempfname, "%s/elvis%d.tmp", TMPDIR, (int)getpid ());
writefd = open (tempfname, O_WRONLY|O_CREAT|O_EXCL, S_IREAD|S_IWRITE);
if (writefd < 0)
{
msg (MSG_ERROR, "can't make temporary file");
free (command);
return ElvFalse;
}
}
else if (willwrite || willread) /* but not both */
{
/* Create a pipe. */
rc = DosCreatePipe (&r_pipe, &w_pipe, 4096);
if (rc != NO_ERROR)
{
msg(MSG_ERROR, "can't create pipe");
goto Error;
}
/*
* Redirect standard file handles for the CHILD PROCESS.
*/
if (willwrite)
{
/* Save the standard input handle. */
if (!SaveStdIOHandles (save_io, SAVE_STDIN))
goto Error;
/* Get standard input from the read end of the pipe. */
fd = 0;
if (DosDupHandle (r_pipe, &fd) != NO_ERROR)
goto DupError;
/*
* Prevent the child process from inheriting the write end
* of the pipe. This will ensure that the pipe closes
* cleanly when the parent process (elvis) is done with it.
*/
if (DosSetFHState (w_pipe, OPEN_FLAGS_NOINHERIT) != NO_ERROR)
{
msg (MSG_ERROR, "can't set file inheritance");
goto Error;
}
}
else
{
/* Save the standard output and error handles. */
if (!SaveStdIOHandles (save_io, SAVE_STDOUT | SAVE_STDERR))
{
goto Error;
}
/* Send standard output to the write end of the pipe. */
fd = 1;
if (DosDupHandle (w_pipe, &fd) != NO_ERROR)
{
goto DupError;
}
/* Send error output to the write end of the pipe. */
fd = 2;
if (DosDupHandle (w_pipe, &fd) != NO_ERROR)
{
goto DupError;
}
}
/* Launch the command. */
if ((pid = RunCommand (cmd)) < 0)
{
msg (MSG_ERROR, "can't spawn");
goto Error;
}
if (willwrite)
{
/*
* Close the read end of the pipe and remember the fd
* of the write end.
*/
DosClose (r_pipe);
r_pipe = NULLHANDLE;
writefd = w_pipe;
}
else
{
/*
* Close the write end of the pipe and remember the fd
* of the read end.
*/
DosClose (w_pipe);
w_pipe = NULLHANDLE;
readfd = r_pipe;
}
/* Restore standard file handles for the PARENT PROCESS. */
RestoreStdIOHandles (save_io);
}
else /* no redirection */
{
/* Launch the command. */
if ((pid = RunCommand (cmd)) < 0)
{
msg(MSG_ERROR, "can't spawn");
goto Error;
}
}
/* if we get here, we must have succeeded */
return ElvTrue;
DupError:
msg(MSG_ERROR, "can't dup file handle");
Error:
/* Restore standard I/O handles if necessary. */
RestoreStdIOHandles (save_io);
return ElvFalse;
}
int main(VOID) {
HFILE ReadHandle = NULLHANDLE; /* Read handle of pipe */
HFILE WriteHandle = NULLHANDLE; /* Write handle of pipe */
HFILE NewReadHandle = (HFILE) -1; /* Duplicate read handle */
HFILE NewWriteHandle = (HFILE) 10; /* Duplicate write handle */
ULONG PipeSize = 42; /* Size of pipe */
APIRET rc = NO_ERROR; /* API return code */
rc = DosCreatePipe ( &ReadHandle, &WriteHandle, PipeSize );
if (rc != NO_ERROR) {
printf("DosCreatePipe error: return code = %u\n", rc);
return 1;
}
/* Duplicate Read Handle of Pipe - use next available handle */
rc = DosDupHandle ( ReadHandle, &NewReadHandle );
if (rc != NO_ERROR) {
printf("DosDupHandle error: return code = %u\n", rc);
return 1;
}
/* Duplicate Write Handle of Pipe - use handle 10 */
rc = DosDupHandle ( ReadHandle, &NewWriteHandle );
if (rc != NO_ERROR) {
printf("DosDupHandle error: return code = %u\n", rc);
return 1;
}
printf("Handles are: Read:%u Write:%u NewRead:%u NewWrite:%u\n",
ReadHandle, WriteHandle, NewReadHandle, NewWriteHandle);
return NO_ERROR;
}
int main(int argc, char * argv[])
{
char achBuf[PIPESIZE];
char achBuf2[PIPESIZE];
char szFailName[CCHMAXPATH];
int rc;
HFILE hfNew;
HFILE hfSave;
HPIPE hpR, hpW;
HFILE hfNew2;
HFILE hfSaveOutput;
HPIPE hpR2, hpW2;
ULONG cbRead, cbRead2, cbWritten;
HWND hwndNotify;
char *text;
char *mem;
char *ptrLocalMem;
int a;
UCHAR LoadError[CCHMAXPATH]= {0};
RESULTCODES ChildRC= {0};
PID pidChild;
FILE* fh;
char* pipePtr;
char* fifoPtr;
FILE * pipe;
LONG writtenB=0;
LONG delta=0;
LONG lNoFix=0;
int iFifo=0;
BOOL bPriority=FALSE;
FILE *file;
rc=-1;
/*
argv[0]=progname
argv[1]=HWND
argv[2]=cdrecord path
argv[3]=installation dir
argv[4]=Parameter filename
argv[5]=logfilename
*/
for(a=0;a<argc;a++)
printf("%d: %s\n", a, argv[a]);
if(argc<6) {
message();
exit(-1);
}
hwndNotify=atol(argv[1]);
if((ptrLocalMem=malloc(SHAREDMEM_SIZE))==NULL){
WinPostMsg(hwndNotify,WM_APPTERMINATENOTIFY,MPFROMLONG(ACKEY_PRINTSIZE),MPFROMLONG(0));
exit(255);
}
/* Open file with parameters */
if((file=fopen(argv[4],"rb"))==NULL){
WinPostMsg(hwndNotify,WM_APPTERMINATENOTIFY,MPFROMLONG(ACKEY_PRINTSIZE),MPFROMLONG(0));
exit(255);
}
/* Copy command line to local memory */
fread(ptrLocalMem, sizeof(char), SHAREDMEM_SIZE, file);
fclose(file);
/* Open log file */
snprintf(LoadError, sizeof(LoadError), "%s\\%s",argv[3], argv[5]);
fh=fopen(LoadError,"a");
/* Get cmd line */
text=ptrLocalMem;
/* find pipe char */
pipePtr=strchr(text,'|');
mem=strstr(text,"-print-size");
for(a=0;a<strlen("-print-size");a++) {
*mem=' ';
mem++;
}
if(fh) {
fputs("\n---------------------------------------------------------------\n",fh);
fputs("Starting the helper \"",fh);
fputs(argv[0],fh);
fputs("\" with the following parameters:\n",fh);
fputs(text,fh);
fputs("\n\n",fh);
}
/* Find end of mkisofs path */
mem=strchr(text,'"');
*mem=0;
if(pipePtr) {
*pipePtr=0;
pipePtr++;
*pipePtr=0;
pipePtr++;
}
/* pipePtr points to begin of cdrecord path */
if(strstr(pipePtr,"-nofix"))
lNoFix=1;
/* FIFO size. Needing it to know when FIFO is filled. We raise the priority of the mkisofs
process then.
*/
if((fifoPtr=strstr(pipePtr,"fs="))!=NULLHANDLE) {
fifoPtr+=3;
iFifo=atoi(fifoPtr);
iFifo*=1024*1024;
}
#ifdef DEBUG
// DosFreeMem(pvSharedMem);
free(ptrLocalMem);
WinPostMsg(hwndNotify,WM_APPTERMINATENOTIFY,MPFROMLONG(ACKEY_ONTHEFLY),MPFROMSHORT(rc));
exit(0);
#endif
fflush(stdout);
fflush(stderr);
hfSaveOutput = -1;// Get new handle
hfNew2 = HF_STDOUT;
if(!DosDupHandle(HF_STDOUT, &hfSaveOutput)) {
if(!DosCreatePipe(&hpR2, &hpW2, PIPESIZE)) {
if(!DosDupHandle(hpW2, &hfNew2)){/* Duplicates standard out handle */
/* Start mkisofs */
rc=DosExecPgm(LoadError,sizeof(LoadError),EXEC_ASYNCRESULT, text,NULL,&ChildRC,text);
sprintf(achBuf,"DosExecPgm() for mkisofs returned: %d\n",rc);
if(fh)
fputs(achBuf,fh);
DosClose(hpW2); /* Closes write handle to ensure */
/* Notification at child termination */
DosDupHandle(hfSaveOutput, &hfNew2); /* Brings stdout back */
/* pipePtr points to begin of cdrecord path */
pipe=popen(pipePtr,"wb");
/*
* Read from the pipe and write to the screen
* as long as there are bytes to read.
*/
do {
/* Read from mkisofs */
DosRead(hpR2, achBuf2, sizeof(achBuf2), &cbRead2);
/* Read output of cdrecord */
//DosRead(hpR, achBuf, sizeof(achBuf), &cbRead);
//DosWrite(HF_STDERR, achBuf, cbRead, &cbWritten);
// sscanf(achBuf,"%[^=]= %ld",szFailName,&size);
/* Write output of mkisofs */
if(cbRead2)
fwrite(achBuf2,sizeof(BYTE),cbRead2,pipe);
delta+=cbRead2;
writtenB+=cbRead2;
if(delta>=PIPESIZE*200) {
delta=0;
WinPostMsg(hwndNotify,WM_APPTERMINATENOTIFY,MPFROMLONG(ACKEY_MBWRITTEN),MPFROMLONG(writtenB));
}
if(writtenB>=iFifo && !bPriority) {
fputs("FIFO filled, increasing priority of mkisofs process.\n", fh);
bPriority=TRUE;
rc=DosSetPriority(PRTYS_PROCESS,PRTYC_TIMECRITICAL,30,ChildRC.codeTerminate);
sprintf(LoadError,"DosSetPriority() returned: %d (should be 0)\n", rc);
fputs(LoadError,fh);
fputs("Increasing priority of the on-the-fly helper process.\n",fh);
// rc=DosSetPriority(PRTYS_PROCESS,PRTYC_TIMECRITICAL,20,0);
/* Is this kind of priority setting ok? */
rc=DosSetPriority(PRTYS_PROCESS,PRTYC_TIMECRITICAL,30,0);
sprintf(LoadError,"DosSetPriority() returned: %d (should be 0)\n", rc);
fputs(LoadError,fh);
}
} while(cbRead2);
WinPostMsg(hwndNotify,WM_APPTERMINATENOTIFY,MPFROMLONG(ACKEY_MBWRITTEN),MPFROMLONG(writtenB));
/* mark EOF in pipe */
ungetc(EOF,pipe);
/* Tell the PM wrapper that all the data is transfered to cdrecord */
WinPostMsg(hwndNotify,WM_APPTERMINATENOTIFY,MPFROMLONG(ACKEY_FIXATING),MPFROMLONG(lNoFix));
/* Wait for cdrecord process to end */
rc=pclose(pipe);
DosClose(hpR2);
}
}
}/* if(!DosDupHandle(HF_STDERR, &hfSave)) */
DosWaitChild(0,DCWW_WAIT,&ChildRC,&pidChild,0);
free(ptrLocalMem);
// DosFreeMem(pvSharedMem);
if(fh) {
sprintf(achBuf,"CDRecord returned: %d\n",rc);
fputs(achBuf,fh);
fclose(fh);
}
/* Send msg. to the notification window */
WinPostMsg(hwndNotify,WM_APPTERMINATENOTIFY,MPFROMLONG(ACKEY_ONTHEFLY),MPFROMSHORT(rc));
}
int main(int argc, char * argv[])
{
int rc;
HFILE hfNew;
HWND hwndNotify;
char *text;
HPIPE hpR, hpW;
ULONG cbRead, cbWritten;
CHAR achBuf[PIPESIZE]={0};
CHAR szFailName[CCHMAXPATH];
HFILE hfSave;
RESULTCODES ChildRC= {0};
int a;
int iBlocks;
rc=-1;
if(argc<4) {
message();
exit(-1);
}
hwndNotify=atol(argv[1]);
/* Print the parameters in VIO window */
printf("argc:%d\n",argc);
for(a=0;a<argc;a++)
{
printf("%d: %s\n",a,argv[a]);
}
printf("\n");
memset(achBuf, 0, sizeof(achBuf));
/* sprintf(achBuf,"%s %s -toc -v",argv[2],argv[3]); */
sprintf(achBuf,"%s",argv[3]);
text=strchr(achBuf,0);
if(!text) {
WinPostMsg(hwndNotify,WM_APPTERMINATENOTIFY,MPFROMLONG(4),MPFROMLONG(0));
}
text++;
sprintf(text,"%s", argv[4]);
printf("Parameters for size query: %s\n",text);
text=achBuf;
printf("Path is: %s\n",text);
/**** start ****/
/* Redirect stdout */
hfSave = -1;// Get new handle
hfNew = HF_STDOUT;
if(!DosDupHandle(HF_STDOUT, &hfSave)){ /* Saves standard handle */
if(!DosCreatePipe(&hpR, &hpW, PIPESIZE)){ /* Creates pipe */
/* If the pipe size is smaller than the output of the child the system() call blocks.
So create the pipe big enough. */
if(!DosDupHandle(hpW, &hfNew)){ /* Duplicates standard output handle */
/* start CDRecord/2 */
rc=DosExecPgm(szFailName,sizeof(szFailName),EXEC_ASYNC, text,NULL,&ChildRC, text);
fprintf(stderr,"DosExecPgm() for dvddao returned: %d\n",rc);
/*
rc=system(text);
*/
DosClose(hpW); /* Closes write handle to ensure */
/* Notification at child termination */
DosDupHandle(hfSave, &hfNew); /* Brings stdout back */
/*
* Read from the pipe and write to the screen
* as long as there are bytes to read.
*/
do {
BOOL bNoMedia=FALSE;
DosRead(hpR, achBuf, sizeof(achBuf), &cbRead);
DosWrite(HF_STDERR, achBuf, cbRead, &cbWritten);
/* Uppercase string */
strupr(achBuf);
text=strstr(achBuf,"NO MEDIA");
if(text){
/* No DVD/CD inserted */
iBlocks=0;
//WinPostMsg(hwndNotify,WM_APPTERMINATENOTIFY,MPFROMLONG(4),MPFROMLONG(0));
bNoMedia=TRUE;
break;
}
text=strstr(achBuf,"MEDIA SIZE");
if(text){
char dummy[200];
/* We have the size */
sscanf(text, "%s %s %d", dummy, dummy, &iBlocks);
break;
}
} while(cbRead);
printf("Num blocks found %d \n",iBlocks);
DosClose(hpR);
}
}
}/* if(!DosDupHandle(HF_STDERR, &hfSave)) */
printf("Errorcode from dvddao is: %d\n",rc);
/* Send msg. to the notification window */
WinPostMsg(hwndNotify,WM_APPTERMINATENOTIFY,MPFROMLONG(4),MPFROMLONG(iBlocks));
exit(0);
}
