Return to ox_pathfinder.c CVS log | Up to [local] / OpenXM / src / util |
version 1.1, 2003/07/21 11:36:10 | version 1.17, 2003/12/04 10:35:24 | ||
---|---|---|---|
|
|
||
/* $OpenXM$ */ | /* $OpenXM: OpenXM/src/util/ox_pathfinder.c,v 1.16 2003/12/04 06:29:21 takayama Exp $ */ | ||
/* Moved from misc-2003/07/cygwin/test.c */ | /* Moved from misc-2003/07/cygwin/test.c */ | ||
#include <stdio.h> | #include <stdio.h> | ||
#include <sys/types.h> | #include <sys/types.h> | ||
#include <sys/stat.h> | #include <sys/stat.h> | ||
|
|
||
#include <sys/wait.h> | #include <sys/wait.h> | ||
#include <signal.h> | #include <signal.h> | ||
#include <ctype.h> | #include <ctype.h> | ||
#include <time.h> | |||
#include <string.h> | |||
#include "ox_pathfinder.h" | #include "ox_pathfinder.h" | ||
int OX_P_stdin = -1; | |||
int OX_P_stdout = -1; | |||
int OX_P_stderr = -1; | |||
extern char **environ; | extern char **environ; | ||
static int getOStypei(); | static int getOStypei(); | ||
|
|
||
static char *get_ox_path(); | static char *get_ox_path(); | ||
static char *get_oxc_path(); | static char *get_oxc_path(); | ||
static char *get_oxlog_path(); | static char *get_oxlog_path(); | ||
static char **setOXenv(); | static int getFileSize(char *fn); | ||
static int forkExec(char **argv); | static void errorPathFinder(char *s); | ||
static void usage(); | static void msgPathFinder(char *s); | ||
static int Verbose_get_home = 1; | static int Verbose_get_home = 0; | ||
static int NoX = 0; | static int NoX = 0; | ||
#define nomemory(a) {fprintf(stderr,"(%d) no more memory.\n",a);exit(10);} | |||
#define mymalloc(a) sGC_malloc(a) | |||
static void errorPathFinder(char *s) { | |||
/* Todo; we need to return the error message to the client if it is used | |||
in ox_shell */ | |||
fprintf(stderr,"Error: %s",s); | |||
} | |||
static void msgPathFinder(char *s) { | |||
/* Todo; we need to return the error message to the client if it is used | |||
in ox_shell */ | |||
fprintf(stderr,"Log(ox_pathfinder): %s",s); | |||
} | |||
int ox_pathfinderNoX(int f) { | |||
if (f < 0) return NoX; | |||
NoX = f; | |||
return f; | |||
} | |||
int ox_pathfinderVerbose(int f) { | |||
extern Verbose_get_home; | |||
if (f < 0) return Verbose_get_home; | |||
Verbose_get_home = f; | |||
return f; | |||
} | |||
/* test main */ | |||
/* | |||
main() { | |||
char *outfile; | |||
char *cpp; | |||
char *argv[10]; | |||
int n; | |||
char *sfile = "ox_pathfinder.c"; | |||
if (getFileSize(sfile) < 0) { | |||
fprintf(stderr,"The source file is not found.\n"); return -1; | |||
} | |||
cpp = getCppPath(); | |||
if (cpp == NULL) { | |||
fprintf(stderr,"cpp is not found.\n"); return -1; | |||
} | |||
printf("%s\n",cpp); | |||
outfile = generateTMPfileName("seed"); | |||
if (outfile == NULL) { | |||
fprintf(stderr,"Failed to generate a temporary file name.\n"); return -1; | |||
} | |||
printf("%s\n",outfile); | |||
if ((char *)strstr(cpp,"/asir/bin/cpp.exe") == NULL) { | |||
argv[0] = cpp; | |||
argv[1] = "-P"; | |||
argv[2] = "-lang-c++"; | |||
argv[3] = sfile; | |||
argv[4] = outfile; | |||
argv[5] = NULL; | |||
}else{ | |||
argv[0] = cpp; | |||
argv[1] = cygwinPathToWinPath(sfile); | |||
argv[2] = cygwinPathToWinPath(outfile); | |||
argv[3] = NULL; | |||
} | |||
n=oxForkExecBlocked(argv); | |||
} | |||
void *sGC_malloc(int s) { return (void *) malloc(s); } | |||
*/ | |||
/* -------- end of test main ----------- */ | |||
/* See kxx/ox100start.c for main */ | |||
#define MYFORKCP_SIZE 100 | #define MYFORKCP_SIZE 100 | ||
static int Myforkchildren[MYFORKCP_SIZE]; | static int Myforkchildren[MYFORKCP_SIZE]; | ||
static int Myforkcp=0; | static int Myforkcp=0; | ||
|
|
||
int status; | int status; | ||
int pid; | int pid; | ||
int i,j; | int i,j; | ||
signal(SIGCHLD,SIG_IGN); | /* signal(SIGCHLD,SIG_IGN); It is not allowed in posix */ | ||
pid = wait(&status); | pid = wait(&status); | ||
fprintf(stderr,"Child process %d is exiting.\n",pid); | fprintf(stderr,"Child process %d is exiting.\n",pid); | ||
if (pid < 0) { | |||
perror("wait"); | |||
} | |||
for (i=0; i<Myforkcp; i++) { | for (i=0; i<Myforkcp; i++) { | ||
if (Myforkchildren[i] == pid) { | if (Myforkchildren[i] == pid) { | ||
for (j=i; j<Myforkcp-1; j++) { | for (j=i; j<Myforkcp-1; j++) { | ||
|
|
||
signal(SIGCHLD,myforkwait); | signal(SIGCHLD,myforkwait); | ||
} | } | ||
#define nomemory(a) {fprintf(stderr,"(%d) no more memory.\n",a);exit(10);} | int oxForkExec(char **argv) { | ||
#define mymalloc(a) malloc(a) | |||
/* See kxx/ox100start.c for main. */ | |||
static int forkExec(char **argv) { | |||
int pid; | int pid; | ||
char **eee; | char **eee; | ||
int m; | int m; | ||
|
|
||
fprintf(stderr,"Cannot fork and exec.\n"); return -1; | fprintf(stderr,"Cannot fork and exec.\n"); return -1; | ||
} | } | ||
if ((pid = fork()) > 0) { | if ((pid = fork()) > 0) { | ||
oxResetRedirect(); | |||
if (m&2) { | if (m&2) { | ||
/* Do not call singal to turn around a trouble on cygwin. BUG. */ | /* Do not call singal to turn around a trouble on cygwin. BUG. */ | ||
}else{ | }else{ | ||
signal(SIGCHLD,myforkwait); /* to kill Zombie */ | signal(SIGCHLD,myforkwait); /* to kill Zombie */ | ||
} | } | ||
Myforkchildren[Myforkcp++] = pid; | Myforkchildren[Myforkcp++] = pid; | ||
if (Myforkcp >= MYFORKCP_SIZE-1) { | if (Myforkcp >= MYFORKCP_SIZE-1) { | ||
fprintf(stderr,"Child process table is full.\n"); | fprintf(stderr,"Child process table is full.\n"); | ||
Myforkcp = 0; | Myforkcp = 0; | ||
} | } | ||
}else{ | }else{ | ||
/* close the specified files */ | /* close the specified files */ | ||
if (m&1) { | if (m&1) { | ||
sigset_t sss; | sigset_t sss; | ||
sigemptyset(&sss); | sigemptyset(&sss); | ||
sigaddset(&sss,SIGINT); | sigaddset(&sss,SIGINT); | ||
sigprocmask(SIG_BLOCK,&sss,NULL); | sigprocmask(SIG_BLOCK,&sss,NULL); | ||
} | } | ||
eee = setOXenv(); | if (NoX) { | ||
if (NoX) { | FILE *null; | ||
FILE *null; | null = fopen("/dev/null","wb"); | ||
null = fopen("/dev/null","wb"); | if (OX_P_stdout >= 0) dup2(OX_P_stdout,1); else dup2(fileno(null),1); | ||
dup2(fileno(null),1); | if (OX_P_stderr >= 0) dup2(OX_P_stderr,2); else dup2(fileno(null),2); | ||
dup2(fileno(null),2); | }else{ | ||
} | if (OX_P_stdout >= 0) dup2(OX_P_stdout,1); | ||
if (OX_P_stderr >= 0) dup2(OX_P_stderr,2); | |||
} | |||
if (OX_P_stdin >= 0) dup2(OX_P_stdin,0); | |||
execve(argv[0],argv,environ); | execve(argv[0],argv,environ); | ||
/* This place will never be reached unless execv fails. */ | /* This place will never be reached unless execv fails. */ | ||
fprintf(stderr,"forkExec fails: "); | fprintf(stderr,"oxForkExec fails: "); | ||
exit(3); | |||
} | } | ||
} | } | ||
int oxForkExecBlocked(char **argv) { | |||
int pid; | |||
char **eee; | |||
int m; | |||
int status; | |||
if (argv == NULL) { | |||
fprintf(stderr,"Cannot fork and exec.\n"); return -1; | |||
} | |||
if ((pid = fork()) > 0) { | |||
oxResetRedirect(); | |||
Myforkchildren[Myforkcp++] = pid; | |||
if (Myforkcp >= MYFORKCP_SIZE-1) { | |||
fprintf(stderr,"Child process table is full.\n"); | |||
Myforkcp = 0; | |||
} | |||
if (waitpid(pid,&status,0) < 0) { /* blocked */ | |||
perror("waitpid"); | |||
} | |||
Myforkcp--; | |||
return status; | |||
}else{ | |||
/* close the specified files */ | |||
if (m&1) { | |||
sigset_t sss; | |||
sigemptyset(&sss); | |||
sigaddset(&sss,SIGINT); | |||
sigprocmask(SIG_BLOCK,&sss,NULL); | |||
} | |||
if (NoX) { | |||
FILE *null; | |||
null = fopen("/dev/null","wb"); | |||
if (OX_P_stdout >= 0) dup2(OX_P_stdout,1); else dup2(fileno(null),1); | |||
if (OX_P_stderr >= 0) dup2(OX_P_stderr,2); else dup2(fileno(null),2); | |||
}else{ | |||
if (OX_P_stdout >= 0) dup2(OX_P_stdout,1); | |||
if (OX_P_stderr >= 0) dup2(OX_P_stderr,2); | |||
} | |||
if (OX_P_stdin >= 0) dup2(OX_P_stdin,0); | |||
execve(argv[0],argv,environ); | |||
/* This place will never be reached unless execv fails. */ | |||
fprintf(stderr,"oxForkExecBlock fails: "); | |||
exit(3); | |||
} | |||
} | |||
static int getOStypei() { | static int getOStypei() { | ||
/* | /* | ||
0 unix | 0 unix | ||
|
|
||
}else if (t == 2) { | }else if (t == 2) { | ||
fprintf(stderr,"getServerEnv(): "); | fprintf(stderr,"getServerEnv(): "); | ||
}else if (t == 3) { | }else if (t == 3) { | ||
fprintf(stderr,"setOXenv(): "); | fprintf(stderr,"?? "); | ||
}else if (t == 4) { | }else if (t == 4) { | ||
fprintf(stderr,"cygwinPathToWinPath(): "); | fprintf(stderr,"cygwinPathToWinPath(): "); | ||
}else if (t == 5) { | }else if (t == 5) { | ||
|
|
||
char **aaa; | char **aaa; | ||
if (Verbose_get_home) { | if (Verbose_get_home) { | ||
if (oxServer == NULL) { | if (oxServer == NULL) { | ||
fprintf(stderr,"Server name is NULL.\n"); | fprintf(stderr,"Server name is NULL.\n"); | ||
}else{ | }else{ | ||
fprintf(stderr,"Server name is %s\n",oxServer); | fprintf(stderr,"Server name is %s\n",oxServer); | ||
} | } | ||
} | } | ||
if (oxServer == NULL) return NULL; | if (oxServer == NULL) return NULL; | ||
|
|
||
strcpy(oxServer,p); | strcpy(oxServer,p); | ||
if ((ostype == 0) || (ostype == 2)) { | if ((ostype == 0) || (ostype == 2)) { | ||
if (!NoX) { | if (!NoX) { | ||
xterm = "/usr/X11R6/bin/xterm"; | xterm = "/usr/X11R6/bin/xterm"; | ||
if (getFileSize(xterm) == -1) { | if (getFileSize(xterm) == -1) { | ||
msg_get_home(2,"xterm is not found. NoX is automatically set."); | msg_get_home(2,"xterm is not found. NoX is automatically set."); | ||
NoX = 1; | NoX = 1; | ||
} | } | ||
} | } | ||
oxlog = get_oxlog_path(); | oxlog = get_oxlog_path(); | ||
xterm = "/usr/X11R6/bin/xterm -icon -e "; | xterm = "/usr/X11R6/bin/xterm -icon -e "; | ||
argv[i] = oxlog; i++; argv[i] = NULL; | argv[i] = oxlog; i++; argv[i] = NULL; | ||
if (!NoX) { | if (!NoX) { | ||
argv[i] = "/usr/X11R6/bin/xterm"; i++; argv[i] = NULL; | argv[i] = "/usr/X11R6/bin/xterm"; i++; argv[i] = NULL; | ||
argv[i] = "-icon"; i++; argv[i] = NULL; | argv[i] = "-icon"; i++; argv[i] = NULL; | ||
argv[i] = "-e"; i++; argv[i] = NULL; | argv[i] = "-e"; i++; argv[i] = NULL; | ||
} | } | ||
argv[i] = get_ox_path(); i++; argv[i] = NULL; | argv[i] = get_ox_path(); i++; argv[i] = NULL; | ||
argv[i] = "-ox"; i++; argv[i] = NULL; | argv[i] = "-ox"; i++; argv[i] = NULL; | ||
argv[i] = oxServer; i++; argv[i] = NULL; | argv[i] = oxServer; i++; argv[i] = NULL; | ||
}else{ | }else{ | ||
if (!NoX) { | if (!NoX) { | ||
if (getFileSize("/cygdrive/c/winnt/system32/cmd.exe") >= 0) { | if (getFileSize("/cygdrive/c/winnt/system32/cmd.exe") >= 0) { | ||
xterm = "/cygdrive/c/winnt/system32/cmd.exe /c start /min "; | xterm = "/cygdrive/c/winnt/system32/cmd.exe /c start /min "; | ||
argv[i] = "/cygdrive/c/winnt/system32/cmd.exe"; i++; argv[i] = NULL; | argv[i] = "/cygdrive/c/winnt/system32/cmd.exe"; i++; argv[i] = NULL; | ||
}else if (getFileSize("/cygdrive/c/windows/system32/cmd.exe") >= 0) { | }else if (getFileSize("/cygdrive/c/windows/system32/cmd.exe") >= 0) { | ||
xterm = "/cygdrive/c/windows/system32/cmd.exe /c start /min "; | xterm = "/cygdrive/c/windows/system32/cmd.exe /c start /min "; | ||
argv[i] = "/cygdrive/c/windows/system32/cmd.exe"; i++; argv[i] = NULL; | argv[i] = "/cygdrive/c/windows/system32/cmd.exe"; i++; argv[i] = NULL; | ||
}else{ | }else{ | ||
msg_get_home(2,"cmd.exe is not found. NoX is automatically set."); | msg_get_home(2,"cmd.exe is not found. NoX is automatically set."); | ||
NoX = 1; | NoX = 1; | ||
} | } | ||
} | } | ||
oxlog = " "; | oxlog = " "; | ||
if (!NoX) { | if (!NoX) { | ||
argv[i] = "/c"; i++; argv[i] = NULL; | argv[i] = "/c"; i++; argv[i] = NULL; | ||
argv[i] = "start"; i++; argv[i] = NULL; | argv[i] = "start"; i++; argv[i] = NULL; | ||
argv[i] = "/min"; i++; argv[i] = NULL; | argv[i] = "/min"; i++; argv[i] = NULL; | ||
} | } | ||
argv[i] = cygwinPathToWinPath(get_ox_path()); i++; argv[i] = NULL; | argv[i] = cygwinPathToWinPath(get_ox_path()); i++; argv[i] = NULL; | ||
argv[i] = "-ox"; i++; argv[i] = NULL; | argv[i] = "-ox"; i++; argv[i] = NULL; | ||
argv[i] = oxServer; i++; argv[i] = NULL; | argv[i] = oxServer; i++; argv[i] = NULL; | ||
|
|
||
return aaa; | return aaa; | ||
} | } | ||
char **setOXenv() { | |||
/* Do nothing. */ | |||
return NULL; | |||
} | |||
char **setOXenv_old() { | char **setOXenv_old() { | ||
char *openXM_HOME; | char *openXM_HOME; | ||
char *load_sm1_path; | char *load_sm1_path; | ||
|
|
||
for (i=0; i<n2; i++) argv[n1+i] = argv2[i]; | for (i=0; i<n2; i++) argv[n1+i] = argv2[i]; | ||
argv[n1+n2]=NULL; | argv[n1+n2]=NULL; | ||
for (i=0; i<n1+n2; i++) { | for (i=0; i<n1+n2; i++) { | ||
msg_get_home(5,argv[i]); | msg_get_home(5,argv[i]); | ||
} | } | ||
return argv; | return argv; | ||
} | } | ||
|
|
||
if (p == NULL) { | if (p == NULL) { | ||
return("/usr/local/lib/sm1/"); | return("/usr/local/lib/sm1/"); | ||
}else{ | }else{ | ||
return p; | return p; | ||
} | } | ||
} | |||
char *getLOAD_K_PATH2(void) { | |||
char *p; | |||
p = get_k0_lib_path(); | |||
if (p == NULL) { | |||
return("/usr/local/lib/kxx97/yacc/"); | |||
}else{ | |||
return p; | |||
} | |||
} | |||
char *winPathToCygwinPath(char *s) { | |||
char *new; | |||
int n,i; | |||
if (s == NULL) return s; | |||
new = (char *) mymalloc(strlen(s)+20); | |||
if (new == NULL) nomemory(new); | |||
if (strlen(s) >= 3) { | |||
/* case of c:\xxx ==> /cygdrive/c/xxx */ | |||
if ((s[1] == ':') && (s[2] == '\\')) { | |||
sprintf(new,"/cygdrive/%c/%s",s[0],&(s[3])); | |||
}else{ | |||
strcpy(new,s); | |||
} | |||
}else{ | |||
strcpy(new,s); | |||
} | |||
n = strlen(s); | |||
for (i=0; i<n; i++) { | |||
if (new[i] == '\\') new[i] = '/'; | |||
} | |||
return new; | |||
} | |||
char *generateTMPfileName(char *seed) { | |||
char *tmp; | |||
char *fname; | |||
char *tt; | |||
int num; | |||
static int prevnum=0; | |||
/* Bugs for k0. | |||
(1) unlink does not work so, load["t.k"];; load["t.k"];; fails (only cygwin. | |||
(2) In case of error, TMP file is not removed. cf KCerror(). | |||
In case of cygwin, we can only load 90 times. | |||
*/ | |||
int i; | |||
int clean = 0; | |||
tmp = getenv("TMP"); | |||
if (tmp == NULL) { | |||
tmp = getenv("TEMP"); | |||
} | |||
if ((tmp == NULL) && (strcmp(getOStypes(),"Windows-native") != 0)) { | |||
tmp = "/tmp"; | |||
} | |||
tmp = winPathToCygwinPath(tmp); | |||
if (tmp != NULL) { | |||
fname = (char *)mymalloc(strlen(tmp)+strlen(seed)+40); | |||
if (fname == NULL) nomemory(fname); | |||
}else{ | |||
fname = (char *)mymalloc(strlen(seed)+40); | |||
if (fname == NULL) nomemory(fname); | |||
} | |||
for (num=prevnum+1; num <100; num++) { | |||
if (tmp != NULL) { | |||
sprintf(fname,"%s/%s-tmp-%d.txt",tmp,seed,num); | |||
}else{ | |||
sprintf(fname,"%s-tmp-%d.txt",seed,num); | |||
} | |||
if (getFileSize(fname) < 0) { | |||
prevnum = num; | |||
return fname; | |||
} else { | |||
if ((num > 90) && (!clean)) { | |||
/* Clean the old garbages. */ | |||
for (i=0; i<100; i++) { | |||
if (tmp != NULL) { | |||
sprintf(fname,"%s/%s-tmp-%d.txt",tmp,seed,i); | |||
}else{ | |||
sprintf(fname,"%s-tmp-%d.txt",seed,i); | |||
} | |||
{ | |||
struct stat buf; | |||
int m; | |||
m = stat(fname,&buf); | |||
if ((m >= 0) && (buf.st_mtime+120 < time(NULL))) { | |||
unlink(fname); | |||
} | |||
} | |||
} | |||
num = 0; clean=1; prevnum=0; | |||
} | |||
} | |||
} | |||
return NULL; | |||
} | |||
#define MAXTMP2 0xffffff | |||
char *generateTMPfileName2(char *seed,char *ext,int usetmp,int win){ | |||
char *tmp; | |||
char *fname; | |||
char *tt; | |||
int num; | |||
static int prevnum=0; | |||
int i; | |||
int clean = 0; | |||
char *extold; | |||
if (ext == NULL) ext=""; | |||
else { | |||
extold = ext; | |||
ext = (char *) mymalloc(strlen(ext)+3); | |||
if (ext == NULL) {fprintf(stderr,"No more memory.\n"); return NULL;} | |||
strcpy(ext,"."); | |||
strcat(ext,extold); | |||
} | |||
if (usetmp) { | |||
tmp = getenv("TMP"); | |||
if (tmp == NULL) { | |||
tmp = getenv("TEMP"); | |||
} | |||
if ((tmp == NULL) && (strcmp(getOStypes(),"Windows-native") != 0)) { | |||
tmp = "/tmp"; | |||
} | |||
tmp = winPathToCygwinPath(tmp); | |||
}else{ | |||
tmp = NULL; | |||
} | |||
if (tmp != NULL) { | |||
fname = (char *)mymalloc(strlen(tmp)+strlen(seed)+40); | |||
if (fname == NULL) nomemory(fname); | |||
}else{ | |||
fname = (char *)mymalloc(strlen(seed)+40); | |||
if (fname == NULL) nomemory(fname); | |||
} | |||
for (num=prevnum+1; num <MAXTMP2; num++) { | |||
if (tmp != NULL) { | |||
sprintf(fname,"%s/%s-tmp-%d%s",tmp,seed,num,ext); | |||
}else{ | |||
sprintf(fname,"%s-tmp-%d%s",seed,num,ext); | |||
} | |||
if (getFileSize(fname) < 0) { | |||
prevnum = num; | |||
if (win) fname= cygwinPathToWinPath(fname); | |||
return fname; | |||
} else { | |||
if ((num > MAXTMP2-10) && (!clean)) { | |||
/* Clean the old garbages. */ | |||
for (i=0; i<MAXTMP2; i++) { | |||
if (tmp != NULL) { | |||
sprintf(fname,"%s/%s-tmp-%d%s",tmp,seed,i,ext); | |||
}else{ | |||
sprintf(fname,"%s-tmp-%d%s",seed,i,ext); | |||
} | |||
{ | |||
struct stat buf; | |||
int m; | |||
m = stat(fname,&buf); | |||
if ((m >= 0) && (buf.st_mtime+120 < time(NULL))) { | |||
unlink(fname); | |||
} | |||
} | |||
} | |||
num = 0; clean=1; prevnum=0; | |||
} | |||
} | |||
} | |||
return NULL; | |||
} | |||
char *getCppPath(void) { | |||
static char *cpp = "/usr/local/bin/cpp"; | |||
int ostype; | |||
char *oxhome; | |||
if ((cpp != NULL) && (getFileSize(cpp) >= 0)) return cpp; | |||
ostype = getOStypei(); | |||
if (ostype < 3) { | |||
/* unix or cygwin env */ | |||
cpp = "/lib/cpp"; /* on linux */ | |||
if (getFileSize(cpp) >= 0) return cpp; | |||
cpp = "/usr/bin/cpp"; /* on freebsd, on cygwin */ | |||
if (getFileSize(cpp) >= 0) return cpp; | |||
cpp = "/bin/cpp"; | |||
if (getFileSize(cpp) >= 0) return cpp; | |||
cpp = NULL; return cpp; | |||
}else { | |||
/* On Windows */ | |||
oxhome = getOpenXM_HOME(); | |||
if (oxhome == NULL) { | |||
cpp = NULL; return cpp; | |||
} | |||
cpp = (char *) mymalloc(strlen(oxhome)+strlen("/asir/bin/cpp.exe")+5); | |||
if (cpp == NULL) nomemory(cpp); | |||
sprintf(cpp,"%s/asir/bin/cpp.exe",oxhome); | |||
if (getFileSize(cpp) >= 0) return cpp; | |||
else return NULL; | |||
} | |||
} | |||
char *getCommandPath(char *cmdname) | |||
{ | |||
char *path; | |||
char *msg; | |||
char *path2; | |||
char *ss; | |||
int i,j; | |||
/* Use /cygdrive format always. */ | |||
if (cmdname == NULL) return NULL; | |||
if (strlen(cmdname) < 1) { | |||
errorPathFinder("getCommandPath: cmdname is an empty string.\n"); | |||
return NULL; | |||
} | |||
if (cmdname[0] == '/') { | |||
if (getFileSize(cmdname) >= 0) { /* Todo: isExecutableFile() */ | |||
}else{ | |||
msg = (char *)mymalloc(strlen(cmdname)+30); | |||
sprintf(msg,"getCommandPath: %s is not found."); | |||
errorPathFinder(msg); | |||
return NULL; | |||
} | |||
return cmdname; | |||
} | |||
path = getOpenXM_HOME(); /* It will return /cygdrive for windows. */ | |||
if (path != NULL) { | |||
path2 = (char *)mymalloc(strlen(path)+5); | |||
strcpy(path2,path); | |||
strcat(path2,"bin"); | |||
ss = oxWhich(cmdname,path2); | |||
if (ss != NULL) return ss; | |||
} | |||
path = (char *)getenv("PATH"); /* Todo: it will not give /cygdrive format*/ | |||
ss = oxWhich(cmdname,path); | |||
if (ss == NULL) { | |||
errorPathFinder("oxWhich_unix: could not find it in the path string.\n"); | |||
} | |||
return ss; | |||
} | |||
char *oxWhich(char *cmdname,char *path) { | |||
return(oxWhich_unix(cmdname,path)); | |||
} | |||
char *oxWhich_unix(char *cmdname,char *path) { | |||
char *path2; | |||
int i,j; | |||
if (path == NULL) { | |||
return NULL; | |||
} | |||
path2 = (char *)mymalloc(strlen(path)+strlen(cmdname)+2); | |||
for (i=0, j=0; i <= strlen(path); i++) { | |||
path2[j] = 0; | |||
if ((path[i] == ':') || (path[i] == 0)) { | |||
strcat(path2,"/"); strcat(path2,cmdname); | |||
if (getFileSize(path2) >= 0) { /* Todo: isExecutableFile() */ | |||
return path2; | |||
} | |||
j = 0; path2[j] = 0; | |||
}else{ | |||
path2[j] = path[i]; j++; path2[j] = 0; | |||
} | |||
} | |||
return NULL; | |||
} | |||
char *oxEvalEnvVar(char *s) { | |||
int n, i,j; | |||
char *es; | |||
char *news; | |||
int flag,flag2; | |||
flag=-1; | |||
n = strlen(s); | |||
es = (char *)mymalloc(n+1); es[0] = 0; | |||
if (es == NULL) nomemory(1); | |||
for (i=0; i<n; i++) { | |||
if ((s[i] == '$') && (s[i+1] == '{')) { | |||
for (j=0; ; j++) { | |||
if ((s[i+2+j] == 0) || (s[i+2+j] == '}')) { | |||
flag2 = i+2+j+1; | |||
break; | |||
} | |||
es[j] = s[i+2+j]; es[j+1]=0; | |||
} | |||
if (es[0] != 0) { flag=i; break; } | |||
} | |||
} | |||
if (flag >= 0) { | |||
es = (char *)getenv(es); | |||
if (es == NULL) es=""; | |||
news = (char *) mymalloc(n+5+strlen(es)); | |||
if (news == NULL) nomemory(1); | |||
j = 0; | |||
for (i=0; i<flag; i++) { | |||
news[j] = s[i]; j++; | |||
} | |||
for (i=0; i<strlen(es); i++) { | |||
news[j] = es[i]; j++; | |||
} | |||
for (i=flag2; i<strlen(s); i++) { | |||
news[j] = s[i]; j++; | |||
} | |||
news[j] = 0; | |||
return(oxEvalEnvVar(news)); | |||
}else{ | |||
return(s); | |||
} | |||
} | |||
void oxResetRedirect(void) { | |||
if (OX_P_stdin >= 0) close(OX_P_stdin); | |||
if (OX_P_stdout >= 0) close(OX_P_stdout); | |||
if (OX_P_stderr >= 0) close(OX_P_stderr); | |||
OX_P_stdin = OX_P_stdout = OX_P_stderr = -1; | |||
} | |||
int oxDeleteFile(char *fname) { | |||
if (getFileSize(fname) >= 0) { | |||
return(unlink(fname)); | |||
}else{ | |||
return(-1); | |||
} | |||
} | |||
/* This function just kills processes, so if there is a process which | |||
uses ox protocol, it is not relevant to use this functions. | |||
*/ | |||
int oxKillAll(void) { | |||
int i; | |||
int pid; | |||
int status; | |||
for (i=0; i<Myforkcp; i++) { | |||
pid = Myforkchildren[i]; | |||
fprintf(stderr,"Sending signal to %d ... ",pid); | |||
kill(pid,SIGKILL); | |||
waitpid(pid,&status,0); | |||
fprintf(stderr,"Gone.\n"); | |||
} | |||
Myforkcp = 0; | |||
return(0); | |||
} | } |