void
search_for_collection (char *name)
{
char *dir = GetDefEnv ("mgdir", "./");
char buffer[512];
struct stat stat_buf;
if (strrchr (dir, '/') && *(strrchr (dir, '/') + 1) != '\0')
{
sprintf (buffer, "%s/", dir);
SetEnv ("mgdir", buffer, NULL);
dir = GetEnv ("mgdir");
}
sprintf (buffer, "%s.text", name);
if (stat (buffer, &stat_buf) != -1)
{
if ((stat_buf.st_mode & S_IFREG) != 0)
{
/* The name is a directory */
SetEnv ("mgname", name, NULL);
SetEnv ("mgdir", "./", NULL);
return;
}
}
sprintf (buffer, "%s%s", dir, name);
if (stat (buffer, &stat_buf) != -1)
{
if ((stat_buf.st_mode & S_IFDIR) != 0)
{
/* The name is a directory */
sprintf (buffer, "%s/%s", name, name);
SetEnv ("mgname", buffer, NULL);
return;
}
}
/* Look in the current directory last */
if (stat (name, &stat_buf) != -1)
{
if ((stat_buf.st_mode & S_IFDIR) != 0)
{
/* The name is a directory */
sprintf (buffer, "%s/%s", name, name);
SetEnv ("mgname", buffer, NULL);
SetEnv ("mgdir", "./", NULL);
return;
}
}
SetEnv ("mgname", name, NULL);
}
void Minigame::NewMap() {
if (NumMoves > 0) {
SetEnv("difficulty", Engine()->GetInt("difficulty") + rand() % 3 + 1);
SetEnv("boxsize", 100 - Engine()->GetInt("difficulty"));
Level++;
}
int Difficulty = Engine()->GetInt("difficulty");
NumMoves = 0;
double Boundary = Engine()->GetDouble("boundary");
double BoxX, BoxY;
double BoxSize = Engine()->GetDouble("boxsize");
Engine()->GetPhysDevice()->Clear();
// The world!
ENTITY * WorldTop = new Wall(VectorOf(Engine()->ScreenX() / 2.0, Engine()->ScreenY() + 16), Engine()->ScreenX() + 8, 64);
ENTITY * WorldBottom = new Wall(VectorOf(Engine()->ScreenX() / 2.0, - 8), Engine()->ScreenX() + 8, 64);
ENTITY * WorldLeft = new Wall(VectorOf(-16, Engine()->ScreenY() / 2.0), 64, Engine()->ScreenY() + 8);
ENTITY * WorldRight = new Wall(VectorOf(Engine()->ScreenX() + 16, Engine()->ScreenY() / 2.0), 64, Engine()->ScreenY() + 8);
Engine()->GetPhysDevice()->AddEntity(WorldTop);
Engine()->GetPhysDevice()->AddEntity(WorldBottom);
Engine()->GetPhysDevice()->AddEntity(WorldLeft);
Engine()->GetPhysDevice()->AddEntity(WorldRight);
int i;
ENTITY * Obstruction;
for (i = 0; i < Difficulty; i++) {
BoxX = rand() % (int)Engine()->ScreenX();
BoxY = rand() % (int)Engine()->ScreenY();
if ((BoxX > Boundary || BoxY > Boundary) &&
(BoxX < Engine()->ScreenX() - Boundary || BoxY < Engine()->ScreenY() - Boundary)) {
Obstruction = new Wall(VectorOf(BoxX, BoxY), BoxSize, BoxSize);
Engine()->GetPhysDevice()->AddEntity(Obstruction);
}
else
i--;
}
hole = new Hole(VectorOf(Engine()->ScreenX() - 100, Engine()->ScreenY() - 100));
Engine()->GetPhysDevice()->AddEntity(hole);
ball = new Ball(VectorOf(50, 80));
Engine()->GetPhysDevice()->AddEntity(ball);
}
// Set up the default env values
void SetupEnv() {
SetEnv("friction", "0.03");
SetEnv("cc", "0.95");
SetEnv("ball_tex", "ball");
SetEnv("bg_tex", "background");
SetEnv("wall_tex", "block");
SetEnv("hole_tex", "hole");
SetEnv("time_mul", "0.25");
SetEnv("boundary", "200");
SetEnv("boxsize", "100");
SetEnv("difficulty", "1");
}
bool
Env::SetEnvWithErrorMessage( const char *nameValueExpr, MyString *error_msg )
{
char *expr, *delim;
int retval;
if( nameValueExpr == NULL || nameValueExpr[0] == '\0' ) {
return false;
}
// make a copy of nameValueExpr for modifying
expr = strnewp( nameValueExpr );
ASSERT( expr );
// find the delimiter
delim = strchr( expr, '=' );
if(delim == NULL && strstr(expr,"$$")) {
// This environment entry is an unexpanded $$() macro.
// We just want to keep it in the environment verbatim.
SetEnv(expr,NO_ENVIRONMENT_VALUE);
delete[] expr;
return true;
}
// fail if either name or delim is missing
if( expr == delim || delim == NULL ) {
if(error_msg) {
MyString msg;
if(delim == NULL) {
msg.sprintf(
"ERROR: Missing '=' after environment variable '%s'.",
nameValueExpr);
}
else {
msg.sprintf("ERROR: missing variable in '%s'.",expr);
}
AddErrorMessage(msg.Value(),error_msg);
}
delete[] expr;
return false;
}
// overwrite delim with '\0' so we have two valid strings
*delim = '\0';
// do the deed
retval = SetEnv( expr, delim + 1 );
delete[] expr;
return retval;
}
bool
Env::SetEnv( const char* var, const char* val )
{
MyString myVar = var;
MyString myVal = val;
return SetEnv( myVar, myVal );
}
void
Env::Import( void )
{
char **my_environ = GetEnviron();
for (int i=0; my_environ[i]; i++) {
const char *p = my_environ[i];
int j;
MyString varname = "";
MyString value = "";
for (j=0; ( p[j] != '\0' ) && ( p[j] != '=' ); j++) {
varname += p[j];
}
if ( p[j] == '\0' ) {
// ignore entries in the environment that do not
// contain an assignment
continue;
}
if ( varname.IsEmpty() ) {
// ignore entries in the environment that contain
// an empty variable name
continue;
}
ASSERT( p[j] == '=' );
value = p+j+1;
// Allow the application to filter the import
if ( ImportFilter( varname, value ) ) {
bool ret = SetEnv( varname, value );
ASSERT( ret ); // should never fail
}
}
}
void
main_pre_dc_init( int, char*[] )
{
DC_Skip_Auth_Init();
DC_Skip_Core_Init();
#ifdef WIN32
_setmaxstdio(2048);
#endif
// Convert the DAGMan log file name to an absolute path if it's
// not one already, so that we'll log things to the right file
// if we change to a different directory.
const char * logFile = GetEnv( "_CONDOR_DAGMAN_LOG" );
if ( logFile && !fullpath( logFile ) ) {
MyString currentDir;
if ( condor_getcwd( currentDir ) ) {
MyString newLogFile(currentDir);
newLogFile += DIR_DELIM_STRING;
newLogFile += logFile;
SetEnv( "_CONDOR_DAGMAN_LOG", newLogFile.Value() );
} else {
debug_printf( DEBUG_NORMAL, "ERROR: unable to get cwd: %d, %s\n",
errno, strerror(errno) );
}
}
}
static void RunJob(const char *user, CronLine *line)
{
struct passwd *pas;
pid_t pid;
/* prepare things before vfork */
pas = getpwnam(user);
if (!pas) {
crondlog(LVL9 "can't get uid for %s", user);
goto err;
}
SetEnv(pas);
/* fork as the user in question and run program */
pid = vfork();
if (pid == 0) {
/* CHILD */
/* change running state to the user in question */
ChangeUser(pas);
if (DebugOpt) {
crondlog(LVL5 "child running %s", DEFAULT_SHELL);
}
execl(DEFAULT_SHELL, DEFAULT_SHELL, "-c", line->cl_Shell, NULL);
crondlog(ERR20 "can't exec, user %s cmd %s %s %s", user,
DEFAULT_SHELL, "-c", line->cl_Shell);
_exit(EXIT_SUCCESS);
}
if (pid < 0) {
/* FORK FAILED */
crondlog(ERR20 "can't vfork");
err:
pid = 0;
}
line->cl_Pid = pid;
}
char *
get_cdpath(void)
{
if (cdpath == 0)
SetEnv(&cdpath, DftEnv("CDPATH", ""));
return cdpath;
}
char *
get_directory(void)
{
if (directory == 0)
SetEnv(&directory, DftEnv("TMP", P_tmpdir));
return directory;
}
char *
get_xdisplay(void)
{
if (x_display == 0)
SetEnv(&x_display, DftEnv("DISPLAY", x_get_display_name()));
return x_display;
}
char *
get_xshellflags(void)
{
if (x_shellflags == 0)
SetEnv(&x_shellflags, DftEnv("XSHELLFLAGS", DEFAULT_XSHELLFLAGS));
return x_shellflags;
}
char *
get_xshell(void)
{
if (x_shell == 0)
SetEnv(&x_shell, DftEnv("XSHELL", DEFAULT_XSHELL));
return x_shell;
}
char *
get_findpath(void)
{
if (findpath == 0)
SetEnv(&findpath, DftEnv("VILE_FINDPATH", ""));
return (findpath);
}
char *
get_shell(void)
{
if (shell == 0)
SetEnv(&shell, DftEnv(SHELL_NAME, SHELL_PATH));
return shell;
}
void
Env::MergeFrom( Env const &env )
{
MyString var,val;
env._envTable->startIterations();
while(env._envTable->iterate(var,val)) {
ASSERT(SetEnv(var,val));
}
}
/**
* \brief set the global variables
*/
void testSetEnvNormal()
{
strcpy(Source, "38 - http://www.fossology.org/testdata/wgetagent/mkpackages -l 1 -R index.html*");
strcpy(TempFileDir, "./test_result");
SetEnv(Source, TempFileDir);
CU_ASSERT_EQUAL(GlobalUploadKey, 38);
char *cptr = strstr(GlobalTempFile, "./test_result/wget."); /* is like ./test_result/wget.29923 */
CU_ASSERT_PTR_NOT_NULL(cptr);
CU_ASSERT_STRING_EQUAL(GlobalURL, "http://www.fossology.org/testdata/wgetagent/mkpackages");
CU_ASSERT_STRING_EQUAL(GlobalParam, "-l 1 -R index.html*");
}
void
VMUniverseMgr::killVM(const char *matchstring)
{
if ( !matchstring ) {
return;
}
if( !m_vm_type.Length() || !m_vmgahp_server.Length() ) {
return;
}
// vmgahp is daemonCore, so we need to add -f -t options of daemonCore.
// Then, try to execute vmgahp with
// vmtype <vmtype> match <string>"
ArgList systemcmd;
systemcmd.AppendArg(m_vmgahp_server);
systemcmd.AppendArg("-f");
char *gahp_log_file = param("VM_GAHP_LOG");
if( gahp_log_file ) {
free(gahp_log_file);
}else {
systemcmd.AppendArg("-t");
}
systemcmd.AppendArg("-M");
systemcmd.AppendArg(VMGAHP_KILL_MODE);
systemcmd.AppendArg("vmtype");
systemcmd.AppendArg(m_vm_type);
systemcmd.AppendArg("match");
systemcmd.AppendArg(matchstring);
#if !defined(WIN32)
if( can_switch_ids() ) {
MyString tmp_str;
tmp_str.formatstr("%d", (int)get_condor_uid());
SetEnv("VMGAHP_USER_UID", tmp_str.Value());
}
#endif
// execute vmgahp with root privilege
priv_state priv = set_root_priv();
int ret = my_system(systemcmd);
// restore privilege
set_priv(priv);
if( ret == 0 ) {
dprintf( D_ALWAYS, "VMUniverseMgr::killVM() is called with "
"'%s'\n", matchstring );
}else {
dprintf( D_ALWAYS, "VMUniverseMgr::killVM() failed!\n");
}
return;
}
static int
any_rw_TXT(TBUFF **rp, const char *vp, char **value)
{
if (rp) {
tb_scopy(rp, *value);
return TRUE;
} else if (vp) {
SetEnv(value, vp);
return TRUE;
} else {
return FALSE;
}
}
int
var_CDPATH(TBUFF **rp, const char *vp)
{
if (rp) {
tb_scopy(rp, get_cdpath());
return TRUE;
} else if (vp) {
SetEnv(&cdpath, vp);
return TRUE;
} else {
return FALSE;
}
}
EnvironmentVariebles::EnvironmentVariebles(wxXmlNode *node){
if(node){
//read values XML
wxXmlNode *child = node->GetChildren();
while(child){
wxString name = XmlUtils::ReadString(child, wxT("Name"));
wxString value = XmlUtils::ReadString(child, wxT("Value"));
SetEnv(name, value);
child = child->GetNext();
}
}else{
//do nothing
}
}
// Update environment variables
void env_update_settings(BOOL save)
{
// Clear buffer
GUI->work_buffer[0]=0;
// Clock?
if (GUI->flags&GUIF_CLOCK)
{
strcat(GUI->work_buffer,"-clock-");
}
// Create icons?
if (GUI->flags&GUIF_SAVE_ICONS)
{
strcat(GUI->work_buffer,"-icons-");
}
// File filter?
if (GUI->flags&GUIF_FILE_FILTER)
{
strcat(GUI->work_buffer,"-filter-");
}
// Def public screen?
if (GUI->flags&GUIF_DEFPUBSCR)
{
strcat(GUI->work_buffer,"-defpub-");
}
// Show icons?
if (GUI->flags&GUIF_VIEW_ICONS)
{
strcat(GUI->work_buffer,"-showicons-");
}
// Icon action?
if (GUI->flags&GUIF_ICON_ACTION)
{
strcat(GUI->work_buffer,"-iconaction-");
}
// Show all?
if (GUI->flags&GUIF_SHOW_ALL)
{
strcat(GUI->work_buffer,"-showall-");
}
// Set variable
SetEnv("dopus/dopus",GUI->work_buffer,save);
}
bool
VMType::createConfigUsingScript(const char* configfile)
{
vmprintf(D_FULLDEBUG, "Inside VMType::createConfigUsingScript\n");
if( !configfile || m_scriptname.IsEmpty() ) {
return false;
}
// Set temporary environments for script program
StringList name_list;
const char *name;
ExprTree* expr = NULL;
m_classAd.ResetExpr();
while( m_classAd.NextExpr(name, expr) ) {
if( !strncasecmp( name, "JobVM", strlen("JobVM") ) ||
!strncasecmp( name, "VMPARAM", strlen("VMPARAM") )) {
name_list.append(name);
SetEnv(name, ExprTreeToString(expr));
}
}
ArgList systemcmd;
if( m_prog_for_script.IsEmpty() == false ) {
systemcmd.AppendArg(m_prog_for_script);
}
systemcmd.AppendArg(m_scriptname);
systemcmd.AppendArg("createconfig");
systemcmd.AppendArg(configfile);
int result = systemCommand(systemcmd, m_file_owner);
// UnSet temporary environments for script program
const char *tmp_name = NULL;
name_list.rewind();
while( (tmp_name = name_list.next()) != NULL ) {
UnsetEnv(tmp_name);
}
if( result != 0 ) {
vmprintf(D_ALWAYS, "Failed to create Configuration file('%s') using "
"script program('%s')\n", configfile,
m_scriptname.Value());
return false;
}
return true;
}
/*
* @implemented
*/
int _putenv(const char* val)
{
int size, result;
wchar_t *woption;
size = MultiByteToWideChar(CP_ACP, 0, val, -1, NULL, 0);
woption = malloc(size* sizeof(wchar_t));
if (woption == NULL)
return -1;
MultiByteToWideChar(CP_ACP, 0, val, -1, woption, size);
result = SetEnv(woption);
free(woption);
return result;
}
HRESULT STDMETHODCALLTYPE CPopupMenu::InvokeCommand( __in CMINVOKECOMMANDINFO *pici)
{
if(HIWORD(((CMINVOKECOMMANDINFOEX *)pici)->lpVerbW)){
return S_OK;
}
else
{
if(1 == LOWORD(pici->lpVerb)){
SetEnv();
}
else if(2 == LOWORD(pici->lpVerb)){
Update();
}
else if(3 == LOWORD(pici->lpVerb)){
Checkout();
}
else if(4 == LOWORD(pici->lpVerb)){
Commit();
}
else if(5 == LOWORD(pici->lpVerb)){
Checkin();
}
else if(6 == LOWORD(pici->lpVerb)){
Cancel();
}
else if(7 == LOWORD(pici->lpVerb)){
Add();
}
else if(8 == LOWORD(pici->lpVerb)){
Revert();
}
else if(9 == LOWORD(pici->lpVerb)){
Merge();
}
else if(10 == LOWORD(pici->lpVerb)){
ShowLog();
}
else if(11 == LOWORD(pici->lpVerb)){
Diff();
}
else if(12 == LOWORD(pici->lpVerb)){
Compare();
}
else if(13 == LOWORD(pici->lpVerb)){
UpdateRelyFiles();
}
}
return S_OK;
}
void DOS_Shell::CMD_SET(char * args) {
HELP("SET");
StripSpaces(args);
std::string line;
if (!*args) {
/* No command line show all environment lines */
Bitu count=GetEnvCount();
for (Bitu a=0;a<count;a++) {
if (GetEnvNum(a,line)) WriteOut("%s\n",line.c_str());
}
return;
}
//There are args:
char * pcheck = args;
while ( *pcheck && (*pcheck == ' ' || *pcheck == '\t')) pcheck++;
if (*pcheck && strlen(pcheck) >3 && (strncasecmp(pcheck,"/p ",3) == 0)) E_Exit("Set /P is not supported. Use Choice!");
char * p=strpbrk(args, "=");
if (!p) {
if (!GetEnvStr(args,line)) WriteOut(MSG_Get("SHELL_CMD_SET_NOT_SET"),args);
WriteOut("%s\n",line.c_str());
} else {
*p++=0;
/* parse p for envirionment variables */
char parsed[CMD_MAXLINE];
char* p_parsed = parsed;
while(*p) {
if(*p != '%') *p_parsed++ = *p++; //Just add it (most likely path)
else if( *(p+1) == '%') {
*p_parsed++ = '%'; p += 2; //%% => %
} else {
char * second = strchr(++p,'%');
if(!second) continue; *second++ = 0;
std::string temp;
if (GetEnvStr(p,temp)) {
std::string::size_type equals = temp.find('=');
if (equals == std::string::npos) continue;
strcpy(p_parsed,temp.substr(equals+1).c_str());
p_parsed += strlen(p_parsed);
}
p = second;
}
}
*p_parsed = 0;
/* Try setting the variable */
if (!SetEnv(args,parsed)) {
WriteOut(MSG_Get("SHELL_CMD_SET_OUT_OF_SPACE"));
}
}
}
bool
Env::MergeFrom( char const * env_str )
{
if ( !env_str ) {
return false;
}
const char *ptr = env_str;
while ( *ptr != '\0' ) {
// a Windows environment block typically contains stuff like
// '=::=::\' and '=C:=C:\some\path'; SetEnv will return an error
// for strings like these, so we'll just silently ignore errors
// from SetEnv and insert what we can
//
SetEnv( ptr );
ptr += strlen(ptr) + 1;
}
return true;
}
bool
Env::MergeFrom( char const * const *stringArray )
{
if( !stringArray ) {
return false;
}
int i;
bool all_ok = true;
for( i = 0; stringArray[i] && stringArray[i][0] != '\0'; i++ ) {
if( !SetEnv( stringArray[i] ) ) {
// Keep going so that we behave like getenv() in
// our treatment of invalid entries in the
// environment. However, this function still
// returns error, unlike Import().
all_ok = false;
}
}
return all_ok;
}
int SetEnv( const char *env_var )
{
// this function used if you've already got a name=value type
// of string, and want to put it into the environment. env_var
// must therefore contain an '='.
if ( !env_var ) {
dprintf (D_ALWAYS, "SetEnv, env_var = NULL!\n" );
return FALSE;
}
// Assume this type of string passes thru with no problem...
if ( env_var[0] == 0 ) {
return TRUE;
}
char const *equalpos = NULL;
if ( ! (equalpos = strchr( env_var, '=' )) ) {
dprintf (D_ALWAYS, "SetEnv, env_var has no '='\n" );
dprintf (D_ALWAYS, "env_var = \"%s\"\n", env_var );
return FALSE;
}
// hack up string and pass to other SetEnv version.
size_t namelen = equalpos - env_var;
int valuelen = strlen(env_var) - namelen - 1;
char *name = new char[namelen+1];
char *value = new char[valuelen+1];
strncpy ( name, env_var, namelen );
strncpy ( value, equalpos+1, valuelen );
name[namelen] = '\0';
value[valuelen] = '\0';
int retval = SetEnv ( name, value );
delete [] name;
delete [] value;
return retval;
}
int main() {
int n, childPid;
char buf[BUF_MAX_SIZE];
char execPath[PATH_MAX_LEN];
char execCmd[CMD_MAX_LEN];
int cmdLen = 0;
char* execArgv[BUF_MAX_SIZE];
int argvNum = 0;
struct ExecCmd execCmdQueue[CMD_MAX_NUM];
int cmdNum = 0;
chdir(WorkDir);
if(remoteOption) CreateConnection();
stdoutfd = dup(STDOUT_FILENO);
stderrfd = dup(STDERR_FILENO);
/*** a connection come ***/
for(;;) {
/*** accept ***/
if(remoteOption) {
clilen = sizeof(cli_addr);
newsockfd = accept(sockfd, (struct sockaddr*)&cli_addr, &clilen);
if(newsockfd < 0) {
write(STDERR_FILENO, "accept error!\n", 14);
exit(1);
}
//write(STDERR_FILENO, "accept\n", 7);
/*** for remote client, stdout/stderr is client socket ***/
if(remoteOption){
dup2(newsockfd, STDOUT_FILENO);
dup2(newsockfd, STDERR_FILENO);
}
}
connectionOption = 1;
//int line = 1;
/*** shell start ***/
while(connectionOption) {
if(welcomeMsgOption) {
welcomeMsgOption = WelcomeMsg();
}
//printf("%4d", line++);fflush(stdout);
write(STDOUT_FILENO, "% ", 2);
/*** clean & initialize variables ***/
bzero(buf, BUF_MAX_SIZE);
bzero(execPath, PATH_MAX_LEN);
bzero(execCmd, CMD_MAX_LEN);
bzero(execArgv, sizeof(execArgv));
bzero(execCmdQueue, sizeof(execCmdQueue));
cmdNum = 0;
argvNum = 0;
cmdLen = 0;
if(remoteOption) ReadCmdLineFromRemote(buf, &n);
else ReadCmdLine(buf, &n);
/*** cut input ***/
char buf2[BUF_MAX_SIZE];
strncpy(buf2, buf, n);
strtok(buf2, "\n");
strtok(buf2, "\r");
/*write(STDERR_FILENO, "parse cmd line: ", 16);
write(STDERR_FILENO, buf2, strlen(buf2));
write(STDERR_FILENO, "\n", 1);*/
ParsePipe(buf2, execCmdQueue, &cmdNum);
int i = 0;
for(; i < cmdNum; ++i) {
/*** clean & initialize variables ***/
bzero(execPath, PATH_MAX_LEN);
bzero(execCmd, CMD_MAX_LEN);
bzero(execArgv, sizeof(execArgv));
argvNum = 0;
cmdLen = 0;
if(ParseCmdAndArgv(execCmdQueue[i].execCmdLine, execCmd, execArgv, &cmdLen, &argvNum) == -1) {
break;
}
/*** select a function ***/
if(!strcmp(execCmd, "setenv")) {
SetEnv(argvNum, execArgv);
}
else if(!strcmp(execCmd, "printenv")) {
PrintEnv();
}
else if(!strcmp(execCmd, "\n")) {
break;
}
else if(!strcmp(execCmd, "exit")) {
CloseAllPipe();
//ListAllPipe();
if(remoteOption) {
connectionOption = 0;
break;
}
else {
return 0;
}
}
else {
/*** prepare to execute cmd ***/
int refreshOption = 0;
int stdinOption = 0;
int stdoutOption = 0;
char* ptrNextCmdLine;
if(i+1 < cmdNum) {
ptrNextCmdLine = execCmdQueue[i+1].execCmdLine;
}
/*** | or ! or > pipe ***/
if(execCmdQueue[i].pipeType > 0) {
CreatePipe(&stdoutOption, &execCmdQueue[i].pipeType, ptrNextCmdLine);
SetPipePriority(ptrNextCmdLine, &cmdNum, &refreshOption, &execCmdQueue[i].pipeType);
//ListAllPipe();
}
/*** fork a process to execute the cmd (in child process) ***/
if( (childPid = fork()) == -1) {
write(STDERR_FILENO, "fork() error.\n", 14);
}
else if(childPid == 0) {
/*** child process ***/
if(remoteOption) close(sockfd);
SetStdin(&stdinOption);
SetStdoutAndStderr(&stdoutOption, &execCmdQueue[i].pipeType);
Execute(execCmd, execPath, execArgv, &cmdLen);
exit(0);
}
else {
/*** parent process ***/
wait();
/*** stdout check & close ***/
if(stdoutOption == 1) {
if(execCmdQueue[i].pipeType == 1 || execCmdQueue[i].pipeType == 2) {
//printf("close fd[1]: %d\n", pipesTail->pipefd[1]);fflush(stdout);
close(pipesTail->pipefd[1]);
}
else if(execCmdQueue[i].pipeType == 3 && filepipe != NULL) {
//printf("close file, fd: %d\n", pipesTail->pipefd[0]);fflush(stdout);
fclose(filepipe);
filepipe = NULL;
struct PipeStruct* tmpPtr = pipes;
struct PipeStruct* tmpPrePtr;
pipesTail->priority = 1;
}
}
/*** when stdin complete, close both the r/w pipe fd (that priority==1) ***/
struct PipeStruct* ptrPipeStruct = pipes;
struct PipeStruct* prePtr = NULL;
while(ptrPipeStruct != NULL) {
if(ptrPipeStruct->priority == 1) {
//printf("close fd[0]: %d\n", ptrPipeStruct->pipefd[0]);fflush(stdout);
close(ptrPipeStruct->pipefd[0]);
if(ptrPipeStruct == pipes) {
/*** delete the first node ***/
if(ptrPipeStruct == pipesTail) {
/*** the first node is also the last node ***/
free(ptrPipeStruct);
pipes = NULL;
pipesTail = NULL;
break;
}
else {
pipes = ptrPipeStruct->next;
free(ptrPipeStruct);
ptrPipeStruct = pipes;
}
}
else if(ptrPipeStruct == pipesTail) {
/*** delete the last node ***/
prePtr->next = NULL;
pipesTail = prePtr;
free(ptrPipeStruct);
break;
}
else {
prePtr->next = ptrPipeStruct->next;
free(ptrPipeStruct);
ptrPipeStruct = prePtr->next;
}
}
else {
prePtr = ptrPipeStruct;
ptrPipeStruct = ptrPipeStruct->next;
}
}
/*** refresh the next pipe priority ***/
if(refreshOption) {
pipesTail->priority = pipesTail->priority - 1;
}
/*** handle > pipe, end this execCmdQueue ***/
if(execCmdQueue[i].pipeType == 3) {
break;
}
}
}
}
RefreshPipe();
}
if(remoteOption){
dup2(stdoutfd, STDOUT_FILENO);
dup2(stderrfd, STDERR_FILENO);
close(newsockfd);
}
welcomeMsgOption = 1;
bzero(PATH, sizeof(PATH));
strcpy(PATH[0], "bin");
strcpy(PATH[1], ".");
pathNum = 2;
}
if(remoteOption) close(sockfd);
return 0;
}
