Beispiel #1
0
int		check_cmd(t_shell *sh, t_node *tree)
{
  int		i;

  i = -1;
  number_reset(sh);
  sh->cmd = my_str_to_wordtab(tree->str);
  dollar(sh);
  check_point_slash(sh, sh->env);
  if (built_in(sh) == -1)
    return (-1);
  while (sh->path != NULL && sh->path[++i] != NULL && sh->ch == 0)
    if (access(strcat(sh->path[i], sh->cmd[0]), X_OK) == 0)
      exec_cmd(sh->path[i], sh->cmd, sh->env, sh);
  if (sh->ch == 0)
    exec_slah_bin(sh->cmd, sh);
  if (sh->ch == 0)
    {
      fprintf(stderr, "Error: '%s' command not found\n", sh->cmd[0]);
      sh->ok_cmd = -1;
      return (0);
    }
  my_free(sh->cmd);
  return (0);
}
Beispiel #2
0
//Parse in parallel
int parParse(char*** commands){
    const char* whitespace = " \t\n";
    char** arguments;
    bool is_built_in = true;
    pid_t pid;
    int i;
    int state = 1;
    pid_t waitArr[arrLen(*commands)];
    memset(waitArr, 0, (arrLen(*commands)+1)*sizeof(pid_t));

    for (i = 0; (*commands)[i] != NULL; i++){
        arguments = tokenify((*commands)[i], whitespace);
        is_built_in = built_in(arguments, &state);  //check if built in
        if (!is_built_in){
            pid = fork();       //create child process
            if (pid == 0){
                execv(arguments[0], arguments);
                freeTokens(arguments);
                printf("Command not valid\n");
                exit(0);
            }
            else{
                waitArr[i] = pid;
            }
        }
        freeTokens(arguments);
    }

    waitParallel(waitArr);
    return state;
}
Beispiel #3
0
void
bip_parallel_init(int flags)
{
    if (flags & INIT_SHARED)
    {
#ifdef NEW_ORACLE
	(void) exported_built_in(in_dict("get_oracle", 3),
				p_get_oracle3, B_UNSAFE);
	(void) exported_built_in(in_dict("install_oracle", 1),
				p_install_oracle, B_SAFE);
	(void) exported_built_in(in_dict("install_pending_oracle", 0),
				p_install_pending_oracle, B_SAFE);
	(void) built_in(in_dict("recomputing", 0),
				p_recomputing, B_SAFE);
	(void) exported_built_in(in_dict("oracle_check", 1),
				p_oracle_check, B_UNSAFE);
	(void) local_built_in(in_dict("set_par_goal", 1),
				p_set_par_goal, B_UNSAFE);
	(void) local_built_in(in_dict("get_par_goal", 1),
				p_get_par_goal, B_UNSAFE|U_UNIFY);
#endif
	(void) local_built_in(in_dict("dbag_create", 1),
				p_dbag_create, B_SAFE|U_GROUND);
	(void) local_built_in(in_dict("dbag_enter", 2),
				p_dbag_enter, B_SAFE|U_NONE);
	(void) local_built_in(in_dict("dbag_dissolve", 2),
				p_dbag_dissolve, B_UNSAFE|U_UNIFY);
    }
}
Beispiel #4
0
//Parses commands sequentially
int seqParse(char*** commands){
    const char* whitespace = " \t\n";
    char** arguments;
    bool is_built_in = true;
    int* status = 0;
    pid_t pid;
    int state = 0;

    for (int i = 0; (*commands)[i] != NULL; i++){
        arguments = tokenify((*commands)[i], whitespace);
        is_built_in = built_in(arguments, &state);
        if (!is_built_in){
            pid = fork();
            if (pid == 0){   //child process
                execv(arguments[0], arguments);//execv the command
                freeTokens(arguments);
                printf("Command not valid\n");      //if execv returns, command was invalid
                exit(0);
            }
            else{   //parent process
                waitpid(pid, status, 0);    // wait for child process to end
            }
        }
        freeTokens(arguments);
    }
    return state;
}
Beispiel #5
0
void
bip_module_init(int flags)
{
    if (!(flags & INIT_SHARED))
	return;
    (void) local_built_in(in_dict("erase_module_", 2), p_erase_module, B_SAFE);
    (void) local_built_in(in_dict("is_a_module", 1), p_is_module, B_SAFE);
    (void) local_built_in(in_dict("authorized_module", 1), p_authorized_module, B_SAFE);
    (void) built_in(in_dict("is_locked", 1), p_is_locked, B_SAFE);
    (void) built_in(in_dict("begin_module", 1), p_begin_module, B_SAFE);
    (void) local_built_in(in_dict("begin_module", 2), p_begin_module, B_SAFE);
    (void) local_built_in(in_dict("create_module_", 1), p_create_module, B_SAFE);
    (void) built_in(d_.lock, p_lock1, B_SAFE);
    (void) built_in(in_dict("lock", 2), p_lock2, B_SAFE);
    (void) built_in(in_dict("lock_pass_", 2), p_lock_pass_, B_SAFE);
    (void) built_in(in_dict("unlock", 2), p_unlock2, B_SAFE);
    (void) exported_built_in(in_dict("tool_", 2), p_tool1, B_UNSAFE);
    (void) exported_built_in(in_dict("tool_", 3), p_tool2, B_UNSAFE);
    exported_built_in(in_dict("tool_body_", 4), p_tool_body, B_UNSAFE|U_GROUND)
	-> mode = BoundArg(2, GROUND) | BoundArg(3, CONSTANT);
    (void) local_built_in(d_.localb, p_local, B_UNSAFE);
    (void) exported_built_in(in_dict("implicit_local",2), p_implicit_local, B_UNSAFE);
    (void) local_built_in(d_.exportb, p_export, B_UNSAFE);
    (void) local_built_in(in_dict("reexport_from_",3), p_reexport_from, B_UNSAFE);
    (void) local_built_in(d_.import_fromb, p_import_from, B_UNSAFE);
    (void) local_built_in(in_dict("import_", 2), p_import, B_UNSAFE);
    (void) local_built_in(in_dict("module_tag", 2), p_module_tag, B_UNSAFE);
    (void) exported_built_in(in_dict("default_module", 1), p_default_module,
    	B_UNSAFE|U_SIMPLE);
    (void) exported_built_in(in_dict("pr", 1), p_pr, B_SAFE);

}
Beispiel #6
0
void
error_init(int flags)
{
    if (flags & INIT_SHARED)
    {
	int i;
	/*
	 * Due to the user entries, part of the message array is
	 * mutable and must be in shared memory.
	 */
	ErrorMessage = (char **) hg_alloc_size(sizeof(char *) * MAX_ERRORS);
	for(i=0; i<MAX_ERRORS; i++)
	{
	    ErrorMessage[i] = ec_error_message[i];
	}
	(void) built_in(in_dict("error_id", 2), p_error_id, B_UNSAFE|U_SIMPLE);
	(void) local_built_in(in_dict("max_error", 1), p_max_error, B_UNSAFE|U_SIMPLE);
	(void) local_built_in(in_dict("set_last_errno", 1), p_set_last_errno, B_SAFE);
	(void) local_built_in(in_dict("get_last_errno", 1), p_get_last_errno, B_UNSAFE|U_SIMPLE);
	(void) built_in(in_dict("errno_id", 1), 	p_errno_id1,	B_UNSAFE|U_SIMPLE);
	(void) built_in(in_dict("errno_id", 2), 	p_errno_id,	B_UNSAFE|U_SIMPLE);
    }
}
int Shelly::execute(Shelly::command command)
{
	int status = 0;

	// Check if the command is a built in function of the shell
	commands::internal_function built_in = commands::internal[command.name];

	if (built_in != 0)
	{
		return built_in(*this, command);
	}

	int pid = fork();

	if (pid == 0)
	{
		// execvp always expects the last argument to be a null terminator
		command.argv_c.push_back(0);

		// Because the argv_c vector stores the C-strings in order we can
		// simply de-refrence the first element of the argv_c vector
		execvp(command.argv_c[0], (char * const *) &command.argv_c[0]);

		// exec failed, the command was _probably_ not found
		std::cerr << command.name << ": command not found\n";
		finish();
	}
	else
	{
		if (command.background)
		{
			if (background_jobs.size() < Shelly::MAX_BG_JOBS)
			{
				background_jobs.push_back({command, pid});
				std::cout << "[" << pid << "] " << command.command << '\n';

				return status;
			}

			// Let the user know only so many commands may be run in the bg
			std::cerr << "No more than " << Shelly::MAX_BG_JOBS
			          << " background jobs may be run at once.\n"
			          << "Executing " << command.name << " in the foreground\n";
		}

		wait(&status);
	}

	return status;
}
Beispiel #8
0
void
bip_shelf_init(int flags)
{
    if (flags & INIT_SHARED)
    {
	(void) built_in(in_dict("shelf_create", 3), p_shelf_create3, B_SAFE|U_SIMPLE);
	(void) built_in(in_dict("shelf_create", 2), p_shelf_create2, B_SAFE|U_SIMPLE);
	(void) built_in(in_dict("shelf_get_",4), p_shelf_get, B_UNSAFE|U_FRESH);
	(void) built_in(in_dict("shelf_set_",4), p_shelf_set, B_SAFE);
	(void) built_in(in_dict("shelf_inc_",3), p_shelf_inc, B_SAFE);
	(void) built_in(in_dict("shelf_dec_",3), p_shelf_dec, B_SAFE);
	(void) built_in(in_dict("shelf_abolish", 1), p_handle_free, B_SAFE|U_NONE);
	(void) local_built_in(in_dict("shelf_name",3), p_shelf_name, B_SAFE);
    }
}
Beispiel #9
0
/* ------------------------------------------------------ *
   process_rq( char *rq, int fd )
   do what the request asks for and write reply to fd 
   handles request in a new process
   rq is HTTP command:  GET /foo/bar.html HTTP/1.0
   ------------------------------------------------------ */
process_rq( char *rq, int fd)
{
	char	cmd[BUFSIZ], arg[BUFSIZ];

	if ( sscanf(rq, "%s%s", cmd, arg) != 2 )
		return;
	sanitize(arg);
	printf("sanitized version is %s\n", arg);

	if ( strcmp(cmd,"GET") != 0 )
		not_implemented();
	else if ( built_in(arg, fd) )
		;
	else if ( not_exist( arg ) )
		do_404(arg, fd);
	else if ( isadir( arg ) )
		do_ls( arg, fd );
	else
		do_cat( arg, fd );
}
Beispiel #10
0
PUBLIC void init_lib(void)
{
     built_in("chr", char_type, L_CHR);
     built_in("ord", int_type, L_ORD);
     built_in("halt", void_type, L_HALT);
     built_in("eof", bool_type, L_EOF);
     built_in("eoln", bool_type, L_EOLN);
     built_in("write", void_type, L_WRITE);
     built_in("writeln", void_type, L_WRITELN);
     built_in("read", void_type, L_READ);
     built_in("readln", void_type, L_READLN);
     built_in("flush", void_type, L_FLUSH);
     built_in("argc", int_type, L_ARGC);
     built_in("argv", void_type, L_ARGV);
     built_in("openin", bool_type, L_OPENIN);
     built_in("closein", void_type, L_CLOSEIN);
}
Beispiel #11
0
int main()
{
    
    char prompt[MAXLINE];
	char *cmd;
	char **param;
    struct parse_info parse;

	param=malloc(sizeof(char *)*(MAXARG+2));

    open(".history",O_WRONLY|O_TRUNC,0666);
    open(".alias",O_WRONLY|O_TRUNC,0666);

    while(1){
        
        int fd[2],in_fd,out_fd,status;
        pid_t pid,pid2;

        type_prompt(prompt);

        int count=read_cmd(&cmd,param,prompt);
		if(count==-1) continue;

        parsing(param,count,&parse);

        //printf("%d\n%s\n%s\n%s\n",parse.flag,parse.in_file,parse.out_file,parse.cmd2);

		if(built_in(cmd,param))  continue;

        if(parse.flag & IS_PIPED){
            if(pipe(fd)<0){
                printf("myshell error: pipe failed.\n");
                exit(0);
            }
        }

        

		if((pid=fork())==0){
            if(parse.flag & IS_PIPED){
                if(!(parse.flag & OUT_REDIRECT)&&!(parse.flag & OUT_REDIRECT_APPEND)){
                    close(fd[0]);
                    close(fileno(stdout));
                    dup2(fd[1],fileno(stdout));
                    close(fd[1]);
                }
                else{
                    close(fd[0]);
                    close(fd[1]);
                    if(parse.flag & OUT_REDIRECT)
                        out_fd=open(parse.out_file,O_WRONLY|O_CREAT|O_TRUNC,0666);
                    else 
                        out_fd=open(parse.out_file,O_WRONLY|O_CREAT|O_APPEND,0666);
                    close(fileno(stdout));
                    dup2(out_fd,fileno(stdout));
                    close(out_fd);
                }
            }
            else{
                if(parse.flag & OUT_REDIRECT){
                    out_fd=open(parse.out_file,O_WRONLY|O_CREAT|O_TRUNC,0666);
                    close(fileno(stdout));
                    dup2(out_fd,fileno(stdout));
                    close(out_fd);
                }
                if(parse.flag & OUT_REDIRECT_APPEND){
                    out_fd=open(parse.out_file,O_WRONLY|O_CREAT|O_APPEND,0666);
                    close(fileno(stdout));
                    dup2(out_fd,fileno(stdout));
                    close(out_fd);
                }
            }

            if(parse.flag & IN_REDIRECT){
                in_fd=open(parse.in_file,O_RDONLY|O_CREAT,0666);
                close(fileno(stdin));
                dup2(in_fd,fileno(stdin));
                close(in_fd);
            }

			execvp(cmd,param);
		}
		else{
            if(parse.flag & IS_PIPED){
                if((pid2=fork())==0){
                    close(fd[1]);
                    close(fileno(stdin));
                    dup2(fd[0],fileno(stdin));
                    close(fd[0]);
                    execvp(parse.cmd2,parse.param2);
                }
                else{
                    close(fd[0]);
                    close(fd[1]);
                    waitpid(pid2,&status,0);
                }
            }

            if(parse.flag & BACKGROUND){
                printf("Child pid:  %u\n",pid);
                

            }
            else waitpid(pid,&status,0);
		}
        
        if(env_modify){
            char str[1024];
            env_modify=0;
            FILE *fp;
            fp=fopen(".environment","r");
            while(!feof(fp)){
                fgets(str,1024,fp);
                if(!strncmp(str,str_env,strlen(str_env))){
                    printf("%s",str+strlen(str_env)+1);
                    break;
                }
            }
            fclose(fp);
        }

    }    

    return 0;
}
/*
 * FUNCTION NAME:       bip_strings_init() 
 *
 * PARAMETERS:          NONE. 
 *
 * DESCRIPTION:         links the 'C' functions in this file with SEPIA 
 *                      built-in predicates.    
 */
void
bip_strings_init(int flags)
{
    if (flags & INIT_PRIVATE)
    {
	empty_string = enter_string_n("", 0, DICT_PERMANENT);
	d_sha_ = in_dict("sha", 0);
    }

    if (flags & INIT_SHARED)
    {
	built_in(in_dict("string_list", 2),    p_string_list, B_UNSAFE|U_GROUND|PROC_DEMON)
	    -> mode = BoundArg(1, NONVAR) | BoundArg(2, NONVAR);
	built_in(in_dict("utf8_list", 2),    p_utf8_list, B_UNSAFE|U_GROUND|PROC_DEMON)
	    -> mode = BoundArg(1, NONVAR) | BoundArg(2, NONVAR);
	(void) built_in(in_dict("hash_secure", 3), 	p_hash_secure,	B_UNSAFE|U_SIMPLE);
	(void) built_in(in_dict("string_length", 2), 	p_string_length,B_UNSAFE|U_SIMPLE);
	(void) built_in(in_dict("get_string_code", 3), 	p_get_string_code,	B_UNSAFE|U_SIMPLE);
	(void) b_built_in(in_dict("string_code", 4), 	p_string_code, d_.kernel_sepia);
	(void) built_in(in_dict("substring", 3), 	p_substring,	B_UNSAFE|U_SIMPLE);
	(void) built_in(in_dict("atom_length", 2), 	p_atom_length,	B_UNSAFE|U_SIMPLE);
	(void) built_in(in_dict("string_upper", 2),	p_string_upper,	B_UNSAFE|U_SIMPLE);
	(void) built_in(in_dict("string_lower", 2),	p_string_lower,	B_UNSAFE|U_SIMPLE);
	(void) built_in(in_dict("concat_atoms", 3), 	p_concat_atoms,	B_UNSAFE|U_SIMPLE|PROC_DEMON);
	(void) built_in(in_dict("concat_atom", 2), 	p_concat_atom,	B_UNSAFE|U_SIMPLE|PROC_DEMON);
	(void) built_in(in_dict("concat_strings", 3), 	p_concat_strings,B_UNSAFE|U_SIMPLE|PROC_DEMON);
	(void) built_in(in_dict("concat_string", 2), 	p_concat_string,B_UNSAFE|U_SIMPLE|PROC_DEMON);
	(void) built_in(in_dict("atomics_to_string", 2),p_concat_string,B_UNSAFE|U_SIMPLE|PROC_DEMON);
	(void) built_in(in_dict("join_string", 3), 	p_join_string,	B_UNSAFE|U_SIMPLE|PROC_DEMON);
	(void) built_in(in_dict("atomics_to_string", 3),p_join_string,	B_UNSAFE|U_SIMPLE|PROC_DEMON);
	(void) built_in(in_dict("text_to_string", 2),	p_text_to_string,	B_UNSAFE|U_SIMPLE|PROC_DEMON);
	built_in(in_dict("split_string", 4), 		p_split_string,	B_UNSAFE|U_GROUND)
	    -> mode = BoundArg(4, GROUND);
	built_in(in_dict("char_int", 2), 	p_char_int,	B_UNSAFE|U_SIMPLE)
	    -> mode = BoundArg(1, NONVAR) | BoundArg(2, NONVAR);
	(void) exported_built_in(in_dict("first_substring", 4),
						p_first_substring, B_UNSAFE|U_SIMPLE);
	exported_built_in(in_dict("string_print_length", 4),
						p_string_print_length, B_UNSAFE|U_SIMPLE) -> mode = BoundArg(3, CONSTANT);
    }
}