Example #1
0
char		mysh_cd(t_arg *targ, UNUSED char *path)
{
  int		i;

  if ((i = cd_tiret(targ)) == 1)
    return (1);
  if (i != 2 && !access(targ->wtab[1], F_OK))
    {
      if (!access(targ->wtab[1], R_OK))
	{
	  if ((i = find_env(targ->env, "PWD=")) < 0)
	    if ((targ->env = add_env(targ->env, "PWD", '=', "/")) == NULL)
	      return (1);
	  if ((targ->pwd = get_flagss(targ->env,"PWD")) == NULL ||
	      ((i = find_env(targ->env, "PWD=")) < 0))
	    return (1);
	  free(targ->env[i]);
	  if ((targ->env[i] = concat_str("PWD", '=', targ->wtab[1])) == NULL
	      || chdir(targ->wtab[1]) < 0)
	    return (1);
	}
      else
	write(2, "Error while accessing path, no rights.\n", 40);
    }
  else if (i != 2)
    write(2, "No such file or directory.\n", 28);
  return (0);
}
Example #2
0
char		cd_home(t_arg *targ)
{
  int		i;
  char		*str3;

  if (targ->wtab[1] == NULL)
    {
      if ((i = find_env(targ->env, "PWD=")) < 0)
	if ((targ->env = add_env(targ->env, "PWD", '=', "/")) == NULL)
	  return (1);
      if ((i = find_env(targ->env, "HOME=")) < 0)
	if ((targ->env = add_env(targ->env, "HOME", '=', "/")) == NULL)
	  return (1);
      if ((targ->pwd = get_flagss(targ->env, "PWD")) == NULL ||
	  (i = find_env(targ->env, "PWD=")) < 0)
	return (1);
      if ((str3 = get_flagss(targ->env, "HOME")) == NULL ||
	  (targ->env[i] = concat_str("PWD", '=', str3)) == NULL ||
	  (chdir(str3) < 0))
	return (1);
      free(str3);
      return (2);
    }
  return (0);
}
Example #3
0
void		ft_cd(t_list *lst, char **av)
{
	char	*path;
	t_env	*e;
	int		show;

	path = NULL;
	show = 0;
	if (!av[1] && (e = find_env(lst, "HOME")))
		path = ft_strdup(e->value);
	else if (!av[1])
		return (err_cd_args());
	else if (av[2] != NULL && !(path = ft_cd_replace(lst, av)))
		return ;
	else if (!av[2] && !ft_strcmp(av[1], "~") && (e = find_env(lst, "HOME")))
		path = ft_strreplace("~", e->value, av[1], 0);
	else if (!av[2] && !ft_strcmp(av[1], "-") && (e = find_env(lst, "OLDPWD")))
	{
		path = ft_strdup(e->value);
		show = 1;
	}
	else if (av[1][0] != '/' && !av[2] && (e = find_env(lst, "PWD")))
		path = ft_strjoin(e->value, ft_strjoin("/", av[1]));
	else if ((av[1][0] == '/' && !av[2]) || (av[1] && !av[2]))
		path = ft_strdup(av[1]);
	ft_cd_do(lst, path, show);
	free(path);
}
Example #4
0
static void	ft_cd_do(t_list *envlst, char *path, int show)
{
	char	*buf;
	int		len;
	int		t;

	buf = NULL;
	t = test_pwd(path);
	if (t == 1)
	{
		chdir(path);
		len = ft_strlen(path);
		buf = getcwd(buf, len);
		if (!buf)
			buf = clear_path(path);
		if (find_env(envlst, "PWD"))
			update_env(envlst, "OLDPWD", find_env(envlst, "PWD")->value);
		update_env(envlst, "PWD", buf);
		if (show)
			ft_putendl(remove_home(envlst, buf));
	}
	else if (t == -1)
		err_cd_perm(remove_home(envlst, path));
	else
		err_cd_no_file(remove_home(envlst, path));
}
Example #5
0
int			builtin_unsetenv(char **av)
{
	int		i;
	int		j;
	int		index;
	char	**tab;

	i = 0;
	j = 0;
	if (!av[1])
		return (-1);
	if ((index = find_env(av[1])) == -1)
		return (0);
	tab = (char **)ft_memalloc(sizeof(char *) * ft_tablen(g_handler.env));
	if (!tab)
		return (-42);
	while (g_handler.env[i])
	{
		if (index != i)
			tab[j++] = ft_strdup(g_handler.env[i]);
		i++;
	}
	ft_free_tab(&g_handler.env);
	g_handler.env = tab;
	return (0);
}
Example #6
0
/* If no specified variable exist, safe_set_env will create one, else it only modify the value */
static void _safe_set_env(const char *name, unsigned long long value,  enum envtype Type, void* ptr, size_t size )
{
	struct env_struct *var;
    
	var = find_env(name);
    
    if (!var) {
        if (Type == kEnvPtr) {
            _set_env(name, 0, kEnvPtr,ptr,size);
        } 
        else if (Type == kEnvValue) {
            _set_env(name, value, kEnvValue,0,0);
        }
    } 
    else if (var->Type != Type) {
        return;        
	}     
    else {
        if (Type == kEnvValue) 
            var->value = value;
        else if (Type == kEnvPtr)
            _re_set_env_copy(var,ptr,size);            
    }
	
	return;    
}
Example #7
0
int				init_termios(t_term *term, char **env)
{
	term->fd = STDIN_FILENO;
	if (!isatty(STDIN_FILENO))
		return (-1);
	term->term_name = find_env(env, "TERM");
	if (!term->term_name)
		term->term_name = "xterm-256color";
	if (tgetent(NULL, term->term_name) < 1)
	{
		term->term_name = NULL;
		return (-1);
	}
	if ((tcgetattr(term->fd, &(term)->term) == -1)
			|| (tcgetattr(term->fd, &(term)->term_bak) == -1))
	{
		ft_putendl_fd("Termios failed to init", 3);
		return (-1);
	}
	term->term.c_cc[VMIN] = 1;
	term->term.c_cc[VTIME] = 0;
	term->term.c_lflag &= ~(ICANON | ECHO);
	ioctl(term->fd, TIOCGWINSZ, &(term)->ws);
	if (tcsetattr(term->fd, 0, &(term)->term) == -1)
		return (-1);
	return (0);
}
Example #8
0
/**
 * If the ENV is not exist, create it.
 * @see flash_write_env
 *
 * @param key ENV name
 * @param value ENV value
 *
 * @return result
 */
static FlashErrCode create_env(const char *key, const char *value) {
    FlashErrCode result = FLASH_NO_ERR;

    FLASH_ASSERT(key);
    FLASH_ASSERT(value);

    if (*key == NULL) {
        FLASH_INFO("Flash ENV name must be not empty!\n");
        return FLASH_ENV_NAME_ERR;
    }

    if (strstr(key, "=")) {
        FLASH_INFO("Flash ENV name can't contain '='.\n");
        return FLASH_ENV_NAME_ERR;
    }

    /* find ENV */
    if (find_env(key)) {
        FLASH_INFO("The name of \"%s\" is already exist.\n", key);
        return FLASH_ENV_NAME_EXIST;
    }
    /* write ENV at the end of cache */
    result = write_env(key, value);

    return result;
}
Example #9
0
void
cupsdSetEnv(const char *name,		/* I - Name of variable */
            const char *value)		/* I - Value of variable */
{
  int	i;				/* Index into environent array */


 /*
  * If "value" is NULL, try getting value from current environment...
  */

  if (!value)
    value = getenv(name);

  if (!value)
    return;

 /*
  * Do not allow dynamic linker variables when running as root...
  */

  if (!RunUser && (!strncmp(name, "DYLD_", 5) || !strncmp(name, "LD_", 3)))
    return;

 /*
  * See if this variable has already been defined...
  */

  if ((i = find_env(name)) < 0)
  {
   /*
    * Check for room...
    */

    if (num_common_env >= (int)(sizeof(common_env) / sizeof(common_env[0])))
    {
      cupsdLogMessage(CUPSD_LOG_ERROR,
                      "cupsdSetEnv: Too many environment variables set!");
      return;
    }

    i = num_common_env;
    num_common_env ++;
  }

 /*
  * Set the new environment variable...
  */

  cupsdSetStringf(common_env + i, "%s=%s", name, value);

  cupsdLogMessage(CUPSD_LOG_DEBUG2, "cupsdSetEnv: %s", common_env[i]);
}
Example #10
0
void re_set_env(const char *name , unsigned long value) {
	struct env_struct *var;
    
	var = find_env(name);
	if (!var || (var->Type != kEnvValue)/* kEnvPtr currently unsupported */) {
		printf("Unable to reset environement value variable %s\n",name);
		return ;
	} 
    
    var->value = value;
	
	return;    
}
Example #11
0
void re_set_env_copy(const char *name , void* ptr,size_t size) {
	struct env_struct *var;
    
	var = find_env(name);
	if (!var|| (var->Type == kEnvPtr)) {
		printf("Unable to find environement variable %s\n",name);
		return ;
	} 
    
    _re_set_env_copy(var , ptr, size);
	
	return;    
}
Example #12
0
/**
 * Get an ENV value by key name.
 *
 * @param key ENV name
 *
 * @return value
 */
char *flash_get_env(const char *key) {
    uint32_t *env_cache_addr = NULL;
    char *value = NULL;

    /* find ENV */
    env_cache_addr = find_env(key);
    if (env_cache_addr == NULL) {
        return NULL;
    }
    /* get value address */
    value = strstr((char *) env_cache_addr, "=");
    if (value != NULL) {
        /* the equal sign next character is value */
        value++;
    }
    return value;
}
Example #13
0
/**
 * Set an ENV. If it value is empty, delete it.
 * If not find it in ENV table, then create it.
 *
 * @param key ENV name
 * @param value ENV value
 *
 * @return result
 */
FlashErrCode flash_set_env(const char *key, const char *value) {
    FlashErrCode result = FLASH_NO_ERR;

    /* if ENV value is empty, delete it */
    if (*value == NULL) {
        result = flash_del_env(key);
    } else {
        /* if find this ENV, then delete it and recreate it  */
        if (find_env(key)) {
            result = flash_del_env(key);
        }
        if (result == FLASH_NO_ERR) {
            result = create_env(key, value);
        }
    }
    return result;
}
Example #14
0
void * get_env_ptr(const char *name) {
	struct env_struct *var;
    
	var = find_env(name);
	if (!var) {
		printf("Unable to get environement ptr variable %s\n",name);
		return 0;
	}
    
    if (var->Type != kEnvPtr) {
        printf("Variable %s is not a ptr\n",name);
        return 0;
    }
	
	return var->ptr;
    
}
Example #15
0
unsigned long get_env_var(const char *name) {
	struct env_struct *var;
    
	var = find_env(name);
	if (!var) {
		printf("Unable to find environement variable %s\n",name);
		return 0;
	}
    
    if (var->Type != kEnvValue) {
        printf("Variable %s is not a value\n",name);
        return 0;
    }
	
	return var->value;
    
}
Example #16
0
/**
 * Delete an ENV in cache.
 *
 * @param key ENV name
 *
 * @return result
 */
FlashErrCode flash_del_env(const char *key){
    FlashErrCode result = FLASH_NO_ERR;
    char *del_env_str = NULL;
    size_t del_env_length, remain_env_length;

    FLASH_ASSERT(key);

    if (*key == NULL) {
        FLASH_INFO("Flash ENV name must be not NULL!\n");
        return FLASH_ENV_NAME_ERR;
    }

    if (strstr(key, "=")) {
        FLASH_INFO("Flash ENV name or value can't contain '='.\n");
        return FLASH_ENV_NAME_ERR;
    }

    /* find ENV */
    del_env_str = (char *) find_env(key);
    if (!del_env_str) {
        FLASH_INFO("Not find \"%s\" in ENV.\n", key);
        return FLASH_ENV_NAME_ERR;
    }
    del_env_length = strlen(del_env_str);
    /* '\0' also must be as ENV length */
    del_env_length ++;
    /* the address must multiple of 4 */
    if (del_env_length % 4 != 0) {
        del_env_length = (del_env_length / 4 + 1) * 4;
    }
    /* calculate remain ENV length */
    remain_env_length = get_env_detail_size()
            - (((uint32_t) del_env_str + del_env_length) - ((uint32_t) env_cache + ENV_PARAM_PART_BYTE_SIZE));
    /* remain ENV move forward */
    memcpy(del_env_str, del_env_str + del_env_length, remain_env_length);
    /* reset ENV end address */
    set_env_detail_end_addr(get_env_detail_end_addr() - del_env_length);

    return result;
}
Example #17
0
char		cd_tiret(t_arg *targ)
{
  char		*tmp;
  int		i;

  if (targ->wtab[1] != NULL &&
      !my_strncmp(targ->wtab[1], "-", 1) && targ->pwd != NULL)
    {
      tmp = targ->pwd;
      if ((i = find_env(targ->env, "PWD=")) < 0)
	if ((targ->env = add_env(targ->env, "PWD", '=', "/")) == NULL)
	  return (1);
      if ((targ->pwd = get_flagss(targ->env, "PWD")) == NULL)
	return (1);
      free(targ->env[i]);
      if ((targ->env[i] = concat_str("PWD", '=', tmp)) == NULL ||
	  chdir(tmp) < 0)
	return (1);
      return (2);
    }
  return (cd_home(targ));
}
Example #18
0
File: env.c Project: zdohnal/cups
void
cupsdUpdateEnv(void)
{
 /*
  * Set common variables...
  */

#define set_if_undefined(name,value) if (find_env(name) < 0) cupsdSetEnv(name,value)

  set_if_undefined("CUPS_CACHEDIR", CacheDir);
  set_if_undefined("CUPS_DATADIR", DataDir);
  set_if_undefined("CUPS_DOCROOT", DocumentRoot);
  set_if_undefined("CUPS_FONTPATH", FontPath);
  set_if_undefined("CUPS_REQUESTROOT", RequestRoot);
  set_if_undefined("CUPS_SERVERBIN", ServerBin);
  set_if_undefined("CUPS_SERVERROOT", ServerRoot);
  set_if_undefined("CUPS_STATEDIR", StateDir);
  set_if_undefined("DYLD_INSERT_LIBRARIES", NULL);
  set_if_undefined("DYLD_LIBRARY_PATH", NULL);
  set_if_undefined("HOME", TempDir);
  set_if_undefined("LD_ASSUME_KERNEL", NULL);
  set_if_undefined("LD_LIBRARY_PATH", NULL);
  set_if_undefined("LD_PRELOAD", NULL);
  set_if_undefined("NLSPATH", NULL);
  if (find_env("PATH") < 0)
    cupsdSetEnvf("PATH", "%s/filter:" CUPS_BINDIR ":" CUPS_SBINDIR
			 ":/bin:/usr/bin", ServerBin);
  set_if_undefined("SERVER_ADMIN", ServerAdmin);
  set_if_undefined("SHLIB_PATH", NULL);
  set_if_undefined("SOFTWARE", CUPS_MINIMAL);
  set_if_undefined("TMPDIR", TempDir);
  set_if_undefined("TZ", NULL);
  set_if_undefined("USER", "root");
  set_if_undefined("VG_ARGS", NULL);

  cupsdSetEnvf("CUPS_MAX_MESSAGE", "%d", CUPSD_SB_BUFFER_SIZE - 1);
}
Example #19
0
void open_oslibext(lua_State * L)
{

    find_env(L);

    lua_getglobal(L, "os");
    lua_pushcfunction(L, ex_sleep);
    lua_setfield(L, -2, "sleep");
    lua_pushliteral(L, OS_PLATTYPE);
    lua_setfield(L, -2, "type");
    lua_pushliteral(L, OS_PLATNAME);
    lua_setfield(L, -2, "name");
    lua_pushcfunction(L, ex_uname);
    lua_setfield(L, -2, "uname");
#if (! defined (_WIN32))  && (! defined (__SUNOS__))
    lua_pushcfunction(L, os_times);
    lua_setfield(L, -2, "times");
#endif
#if ! defined (__SUNOS__)
    lua_pushcfunction(L, os_gettimeofday);
    lua_setfield(L, -2, "gettimeofday");
#endif

    lua_pushcfunction(L, os_setenv);
    lua_setfield(L, -2, "setenv");
    lua_pushcfunction(L, os_exec);
    lua_setfield(L, -2, "exec");
    lua_pushcfunction(L, os_spawn);
    lua_setfield(L, -2, "spawn");
    lua_pushcfunction(L, os_execute);
    lua_setfield(L, -2, "execute");
    lua_pushcfunction(L, os_tmpdir);
    lua_setfield(L, -2, "tmpdir");

    lua_pop(L, 1);              /* pop the table */
}
Example #20
0
int evaluate(int exp_id) {
  if (DEBUG) {
    print(exp_id);
    indent += 1;
  }

  if (ATOM(exp_id)) {
    int found = find_env(exp_id);
    if (!NILP(found)) {
      expression[exp_id] = REMOVE_BIT(found);
    }
  } else {
    switch (expression[CAR(exp_id)]) {
    // car
    case 1:
      evaluate(CADR(exp_id));
      if (ATOM(CADR(exp_id))) {
        error(LIST_EXPECTED);
      }
      expression[exp_id] = expression[CAADR(exp_id)];
      break;

    // cdr
    case 2:
      evaluate(CADR(exp_id));
      if (ATOM(CADR(exp_id))) {
        error(LIST_EXPECTED);
      }
      expression[exp_id] = expression[CDR(CADR(exp_id))];
      break;

    // cons
    case 3:
      evaluate(CADR(exp_id));
      evaluate(CADDR(exp_id));
      expression[exp_id] = CONS(CADR(exp_id), CADDR(exp_id));
      break;

    // quote
    case 4:
      expression[exp_id] = expression[CADR(exp_id)];
      break;

    // eq
    case 5:
      evaluate(CADR(exp_id));
      evaluate(CADDR(exp_id));
      if (expression[CADR(exp_id)] == expression[CADDR(exp_id)]) {
        expression[exp_id] = L_T;
      } else {
        expression[exp_id] = L_NIL;
      }
      break;

    // atom
    case 6:
      evaluate(CADR(exp_id));
      if (ATOM(CADR(exp_id))) {
        expression[exp_id] = L_T;
      } else {
        expression[exp_id] = L_NIL;
      }
      break;

    // cond
    case 7:
      evaluate_cond(CDR(exp_id));
      expression[exp_id] = expression[CDR(exp_id)];
      break;

    // print
    case 8:
      evaluate(CADR(exp_id));
      print(CADR(exp_id));
      expression[exp_id] = expression[CADR(exp_id)];
      break;

    // apply
    case 12:
      {
        int callee = CADR(exp_id);
        int args = CDDR(exp_id);

        eval_args(args);

        before_call();

        // if expression stack is not sufficient,
        // you can save and restore max id here
        if (expression[CAR(callee)] == L_LAMBDA) {
          int new_exp_id = move_exp(CADDR(callee));
          update_environment(CADR(callee), args);
          evaluate(new_exp_id);
          expression[exp_id] = expression[new_exp_id];

        } else if (expression[CAR(callee)] == L_LABEL) {
          int lambda_name = CADR(callee);
          int lambda = CADDR(callee);
          int new_exp_id = 0;

          if (ATOM(lambda_name)) {
            env[(call_depth << 8) + expression[lambda_name]] = SET_BIT(expression[lambda]);
          } else {
            error(INVALID_LABEL_NAME);
          }

          new_exp_id = move_exp(CADDR(lambda));
          update_environment(CADR(lambda), args);
          evaluate(new_exp_id);
          expression[exp_id] = expression[new_exp_id];

        } else {
          error(NOT_LAMBDA);
        }

        after_call();
      }
      break;

    default:
      {
        int found = find_env(CAR(exp_id));
        if (!NILP(found)) {
          int cdr = (REMOVE_BIT(found) << 16) >> 16;
          int new_exp_id = 0;
          int args = CDR(exp_id);

          eval_args(args);

          before_call();

          new_exp_id = move_exp(CADR(cdr));

          update_environment(CAR(cdr), args);
          evaluate(new_exp_id);
          expression[exp_id] = expression[new_exp_id];

          after_call();
        } else {
          print(exp_id);
          error(FUNCTION_NOT_FOUND);
        }
      }
      break;
    }