FB::variant BracExtenssionProviderAPI::setExtensionPath(const FB::variant& msg) {
m_extension_path = msg.cast<std::string>();
size_t index = 0;
#if defined _WIN32
std::string env_var = "LOCALAPPDATA";
#elif defined __APPLE__
std::string env_var = "USER";
#endif
std::string signedvar = '%' + std::string(env_var) + '%';
index = m_extension_path.find(signedvar, index);
if (std::string::npos != index) {
m_extension_path.replace(index, signedvar.length(), get_env(env_var.c_str()));
log("Extension path is set to ('" + std::string(get_env(env_var.c_str())) + "'): " + m_extension_path);
} else {
log("No environment variable was found: " + m_extension_path);
}
#if defined __APPLE__
std::string esc_ext_path = escape_path(m_extension_path);
systemCall("chmod 700 " + esc_ext_path + "/bin/7za");
systemCall("chmod 700 " + esc_ext_path + "/bin/clg-crop.app");
systemCall("chmod 700 " + esc_ext_path + "/bin/clg-snapshot.app");
#endif
return m_extension_path;
}
/**
* Check credentials
*/
OPENVPN_EXPORT int
openvpn_plugin_func_v1 (openvpn_plugin_handle_t handle, const int type, const char *argv[], const char *envp[])
{
/* get username/password from envp string array */
const char *username = get_env ("username", envp);
const char *password = get_env ("password", envp);
const char *ip = get_env ("untrusted_ip", envp);
const char *port = get_env ("untrusted_port", envp);
const int ulen = strlen(username);
const int pwlen = strlen(password);
if ( ulen > MAXWORDLEN || ulen == 0 || pwlen > MAXWORDLEN || pwlen == 0) {
return OPENVPN_PLUGIN_FUNC_ERROR;
}
/* check entered username/password against what we require */
int ok = otp_verify(username, password);
if (ok == 1) {
LOG("OTP-AUTH: authentication succeeded for username '%s', remote %s:%s\n", username, ip, port);
return OPENVPN_PLUGIN_FUNC_SUCCESS;
}
else {
LOG("OTP-AUTH: authentication failed for username '%s', remote %s:%s\n", username, ip, port);
return OPENVPN_PLUGIN_FUNC_ERROR;
}
}
OPENVPN_EXPORT int
openvpn_plugin_func_v1 (openvpn_plugin_handle_t handle, const int type, const char *argv[], const char *envp[])
{
struct auth_pam_context *context = (struct auth_pam_context *) handle;
if (type == OPENVPN_PLUGIN_AUTH_USER_PASS_VERIFY && context->foreground_fd >= 0)
{
/* get username/password from envp string array */
const char *username = get_env ("username", envp);
const char *password = get_env ("password", envp);
const char *common_name = get_env ("common_name", envp) ? get_env ("common_name", envp) : "";
if (username && strlen (username) > 0 && password)
{
if (send_control (context->foreground_fd, COMMAND_VERIFY) == -1
|| send_string (context->foreground_fd, username) == -1
|| send_string (context->foreground_fd, password) == -1
|| send_string (context->foreground_fd, common_name) == -1)
{
fprintf (stderr, "AUTH-PAM: Error sending auth info to background process\n");
}
else
{
const int status = recv_control (context->foreground_fd);
if (status == RESPONSE_VERIFY_SUCCEEDED)
return OPENVPN_PLUGIN_FUNC_SUCCESS;
if (status == -1)
fprintf (stderr, "AUTH-PAM: Error receiving auth confirmation from background process\n");
}
}
}
return OPENVPN_PLUGIN_FUNC_ERROR;
}
void printMemoryInfo(void)
{
int line;
unsigned long i;
MemoryRange *mp = (MemoryRange*)(uint32_t)get_env(envMemoryMap);
// Activate and clear page 1
setActiveDisplayPage(1);
clearScreenRows(0, 24);
setCursorPosition( 0, 0, 1 );
printf("BIOS reported memory ranges:\n");
line = 1;
int memoryMapCount = (int)get_env(envMemoryMapCnt);
for (i=0; i<memoryMapCount; i++) {
printf("Base 0x%08x%08x, ",
(unsigned long)(mp->base >> 32),
(unsigned long)(mp->base));
printf("length 0x%08x%08x, type %d\n",
(unsigned long)(mp->length >> 32),
(unsigned long)(mp->length),
mp->type);
if (line++ > 20) {
pause();
line = 0;
}
mp++;
}
if (line > 0) {
pause();
}
setActiveDisplayPage(0);
}
OPENVPN_EXPORT int
openvpn_plugin_func_v3 (const int version,
struct openvpn_plugin_args_func_in const *args,
struct openvpn_plugin_args_func_return *retptr)
{
struct plugin_context *context = (struct plugin_context *) args->handle;
printf("\nopenvpn_plugin_func_v3() :::::>> ");
show (args->type, args->argv, args->envp);
/* Dump some X509 information if we're in the TLS_VERIFY phase */
if ((args->type == OPENVPN_PLUGIN_TLS_VERIFY) && args->current_cert ) {
printf("---- X509 Subject information ----\n");
printf("Certificate depth: %i\n", args->current_cert_depth);
x509_print_info(args->current_cert);
printf("----------------------------------\n");
}
/* check entered username/password against what we require */
if (args->type == OPENVPN_PLUGIN_AUTH_USER_PASS_VERIFY)
{
/* get username/password from envp string array */
const char *username = get_env ("username", args->envp);
const char *password = get_env ("password", args->envp);
if (username && !strcmp (username, context->username)
&& password && !strcmp (password, context->password))
return OPENVPN_PLUGIN_FUNC_SUCCESS;
else
return OPENVPN_PLUGIN_FUNC_ERROR;
}
else
return OPENVPN_PLUGIN_FUNC_SUCCESS;
}
void PNG_recycle(PNG* png)
{
if (png == NULL) {
return;
}
free(png->buffer);
png->buffer = NULL;
free_frame_info_array(png->frame_info_array, png->frame_count);
png->frame_info_array = NULL;
free(png->backup);
png->backup = NULL;
if (png->png_ptr != NULL && png->info_ptr != NULL) {
png_destroy_read_struct(&png->png_ptr, &png->info_ptr, NULL);
}
png->png_ptr = NULL;
png->info_ptr = NULL;
if (png->patch_head_input_stream != NULL) {
close_patch_head_input_stream(get_env(), png->patch_head_input_stream);
destroy_patch_head_input_stream(get_env(), &png->patch_head_input_stream);
png->patch_head_input_stream = NULL;
}
}
bool PNG_complete(PNG* png)
{
int i;
if (!png->partially) {
return true;
}
if (png->png_ptr == NULL || png->info_ptr == NULL || png->patch_head_input_stream == NULL) {
LOGE(EMSG("Some stuff is NULL"));
return false;
}
// Read left frames
for (i = 1; i < png->frame_count; read_frame(png->png_ptr, png->info_ptr, png->frame_info_array + i++));
// Generate pop
generate_pop(png->frame_info_array, png->frame_count);
// End read
png_read_end(png->png_ptr, png->info_ptr);
png_destroy_read_struct(&png->png_ptr, &png->info_ptr, NULL);
// Close input stream
close_patch_head_input_stream(get_env(), png->patch_head_input_stream);
destroy_patch_head_input_stream(get_env(), &png->patch_head_input_stream);
// Clean up
png->partially = false;
png->png_ptr = NULL;
png->info_ptr = NULL;
png->patch_head_input_stream = NULL;
return true;
}
int cd_tild(char **args, t_dlist *env, t_cmd *cmd, int i)
{
char *path;
path = get_path_from_opt(args[1]);
if (check_access(env, cmd, i) == -1)
return (-1);
chdir(get_my_home(env));
if (strcmp(path, "\0") == 0)
{
modif_oldpwd(get_env("PWD", env), env);
modif_pwd_from_home_to_path(args[1], env);
return (0);
}
path = realloc_path(path, env);
if (access(path, F_OK) == -1 || access(path, R_OK) == -1)
{
if (access(path, F_OK) == -1)
fprintf(stderr, "42sh: cd: No such file or directory\n");
else
print_permission_denied(cmd, i);
return (-1);
}
chdir(path);
modif_oldpwd(get_env("PWD", env), env);
modif_pwd_from_home_to_path(args[1], env);
return (0);
}
static int
tls_final (struct plugin_context *context, struct plugin_per_client_context *pcc, const char *argv[], const char *envp[])
{
if (context->test_packet_filter)
{
if (!pcc->generated_pf_file)
{
const char *pff = get_env ("pf_file", envp);
const char *cn = get_env ("username", envp);
if (pff && cn)
{
char buf[256];
snprintf (buf, sizeof(buf), "( sleep %d ; echo PF %s/%s ; cp \"%s.pf\" \"%s\" ) &",
context->test_packet_filter, cn, pff, cn, pff);
printf ("%s\n", buf);
system (buf);
pcc->generated_pf_file = true;
return OPENVPN_PLUGIN_FUNC_SUCCESS;
}
else
return OPENVPN_PLUGIN_FUNC_ERROR;
}
else
return OPENVPN_PLUGIN_FUNC_ERROR;
}
else
return OPENVPN_PLUGIN_FUNC_SUCCESS;
}
void* decode(JNIEnv* env, InputStream* stream, bool partially, int* format)
{
unsigned char magic_numbers[2];
PatchHeadInputStream* patch_head_input_stream;
*format = get_format(env, stream);
switch (*format) {
#ifdef IMAGE_SUPPORT_JPEG
case IMAGE_FORMAT_JPEG:
magic_numbers[0] = IMAGE_JPEG_MAGIC_NUMBER_0;
magic_numbers[1] = IMAGE_JPEG_MAGIC_NUMBER_1;
break;
#endif
#ifdef IMAGE_SUPPORT_PNG
case IMAGE_FORMAT_PNG:
magic_numbers[0] = IMAGE_PNG_MAGIC_NUMBER_0;
magic_numbers[1] = IMAGE_PNG_MAGIC_NUMBER_1;
break;
#endif
#ifdef IMAGE_SUPPORT_GIF
case IMAGE_FORMAT_GIF:
magic_numbers[0] = IMAGE_GIF_MAGIC_NUMBER_0;
magic_numbers[1] = IMAGE_GIF_MAGIC_NUMBER_1;
break;
#endif
default:
LOGE(EMSG("Can't detect format %d"), *format);
destroy_input_stream(get_env(), &stream);
return NULL;
}
patch_head_input_stream = create_patch_head_input_stream(stream, magic_numbers, 2);
if (patch_head_input_stream == NULL){
WTF_OM;
destroy_input_stream(get_env(), &stream);
return NULL;
}
switch (*format) {
#ifdef IMAGE_SUPPORT_JPEG
case IMAGE_FORMAT_JPEG:
return JPEG_decode(env, patch_head_input_stream, partially);
#endif
#ifdef IMAGE_SUPPORT_PNG
case IMAGE_FORMAT_PNG:
return PNG_decode(env, patch_head_input_stream, partially);
#endif
#ifdef IMAGE_SUPPORT_GIF
case IMAGE_FORMAT_GIF:
return GIF_decode(env, patch_head_input_stream, partially);
#endif
default:
LOGE(EMSG("Can't detect format %d"), *format);
close_patch_head_input_stream(get_env(), patch_head_input_stream);
destroy_patch_head_input_stream(get_env(), &patch_head_input_stream);
return NULL;
}
}
static void get_parameters(int argc, char** argv)
{
progname = get_env(erl_block, "PROGNAME");
rootdir = get_env(erl_block, "ROOTDIR");
emu = get_env(erl_block, "EMU");
if (!progname || !rootdir || !emu ) {
ose_error("PROGNAME, ROOTDIR and EMU must be set", 0);
}
}
void prompt(t_env *env)
{
char *user;
char *host;
if ((user = get_env(env, "USER")) == NULL)
user = MYSH_USER_DEF;
if ((host = get_env(env, "HOST")) == NULL)
host = MYSH_HOST_DEF;
my_printf("{{%s%s%s@%s%s%s}}", C_CYN, user, A_RST, C_BLU, host, A_RST);
my_printf(" %s%s->%s ", C_GRN, A_BLD, A_RST);
}
static void set_uniform(t_resources *res, t_mode mode)
{
t_pt3f *camera;
camera = (t_pt3f*)get_env()->position->array;
glUniformMatrix4fv(get_uniform_id(&res->gl_mvp_uni, mode),
1, GL_FALSE, get_env()->mvp->array);
glUniform3f(get_uniform_id(&res->gl_lightpos_uni, mode),
LIGHT_POS_X, LIGHT_POS_Y, LIGHT_POS_Z);
glUniform3f(get_uniform_id(&res->gl_camera_uni, mode),
camera->x, camera->y, camera->z);
}
/**
** Locate the fisrt instance of _panic inside of _cpuid_set_info, and either remove it
** Or replace it so that the cpuid is set to a valid value.
**/
static void patch_cpuid_set_info_all(void* kernelData)
{
switch(get_env(envModel))
{
case CPUID_MODEL_ATOM:
if(determineKernelArchitecture(kernelData) == KERNEL_32)
{
patch_cpuid_set_info_32(kernelData, CPUFAMILY_INTEL_PENRYN, CPUID_MODEL_PENRYN);
}
else
{
patch_cpuid_set_info_64(kernelData, CPUFAMILY_INTEL_PENRYN, CPUID_MODEL_PENRYN);
}
break;
default:
{
// AnV: Extra cpuid fix for spoofing Nehalem CPU for i5/i9
switch(get_env(envFamily))
{
case 0x1E: /* Intel i5 */
case 0x2C: /* Intel i9 */
if(determineKernelArchitecture(kernelData) == KERNEL_32)
{
patch_cpuid_set_info_32(kernelData, CPUFAMILY_INTEL_NEHALEM, CPUID_MODEL_NEHALEM);
}
else
{
patch_cpuid_set_info_64(kernelData, CPUFAMILY_INTEL_NEHALEM, CPUID_MODEL_NEHALEM);
}
break;
default:
if(determineKernelArchitecture(kernelData) == KERNEL_32)
{
patch_cpuid_set_info_32(kernelData, 0, 0);
}
else
{
patch_cpuid_set_info_64(kernelData, 0, 0);
}
break;
}
break;
}
}
}
long HFSReadFile(CICell ih, char * filePath, void *base, uint64_t offset, uint64_t length)
{
char entry[512];
char devStr[12];
long dirID, result, flags = 0;
if (HFSInitPartition(ih) == -1) return -1;
dirID = kHFSRootFolderID;
// Skip a lead '\'. Start in the system folder if there are two.
if (filePath[0] == '/') {
if (filePath[1] == '/') {
if (gIsHFSPlus) dirID = SWAP_BE32(((long *)gHFSPlus->finderInfo)[5]);
else dirID = SWAP_BE32(gHFSMDB->drFndrInfo[5]);
if (dirID == 0) {
return -1;
}
filePath++;
}
filePath++;
}
result = ResolvePathToCatalogEntry(filePath, &flags, entry, dirID, 0);
if ((result == -1) || ((flags & kFileTypeMask) != kFileTypeFlat)) {
return -1;
}
#if UNUSED
// Not yet for Intel. System.config/Default.table will fail this check.
// Check file owner and permissions.
if (flags & (kOwnerNotRoot | kPermGroupWrite | kPermOtherWrite)) return -1;
#endif
result = ReadFile(entry, &length, base, offset);
if (result == -1) {
return -1;
}
getDeviceDescription(ih, devStr, sizeof(devStr));
if (get_env(envHFSLoadVerbose)) {
verbose("Read HFS%s file: [%s/%s] %d bytes.\n",
(gIsHFSPlus ? "+" : ""), devStr, filePath, (uint32_t)length);
} else if (get_env(envHFSLoadVerbose) == 0) {
safe_set_env(envHFSLoadVerbose, 1);
}
return length;
}
int error_cdenv(char **env, char **cmd, int n)
{
if ((n == 1 || (n == 2 && (ft_strcmp(cmd[1], "--") == 0)))\
&& get_env(env, "HOME=") == NULL)
{
ft_putendl("cd: HOME not set");
return (1);
}
else if ((ft_strcmp(cmd[1], "-") == 0) && get_env(env, "OLDPWD=") == NULL)
{
ft_putendl("cd: OLDPWD not set");
return (1);
}
return (0);
}
int ft_unsetenv(int ac, char **av, int i, int j)
{
char *tmp;
char **env;
env = get_env();
if (!ac)
{
ft_putendl_fd("unsetenv: Too few arguments.", 2);
return (EXIT_FAILURE);
}
while (i < ac)
{
j = 0;
while (env[j])
{
tmp = ft_strjoin(av[i], "=");
if (ft_strnequ(tmp, env[j], ft_strlen(tmp)))
env = ft_ctabdel(env, j);
j++;
}
i++;
}
create_env(env);
return (EXIT_SUCCESS);
}
static void load_default_env(void)
{
int i;
char *tmp;
int mum = 1;
char load_buf[20]={0};
printk("[%s]load default env\n",MODULE_NAME);
tmp = get_env(DATA_FREE_SIZE_TH_NAME);
if(tmp == NULL){
printk("[%s]can not find %s,set the default value\n",MODULE_NAME,DATA_FREE_SIZE_TH_NAME);
sprintf(load_buf,"%d",DATA_FREE_SIZE_TH_DEFAULT);
set_env(DATA_FREE_SIZE_TH_NAME,load_buf);
return;
}
for(i=0;i<strlen(tmp);i++){
if(tmp[i] == 'M' || tmp[i] == 'm'){
mum = 1024*1024;
break;
}else if(tmp[i] == 'K' || tmp[i] == 'k'){
mum = 1024;
break;
}else{
load_buf[i] = tmp[i];
}
}
data_free_size_th =(long long)simple_strtol(load_buf,NULL,10)*mum;
printk("[%s]find %s = %llx\n",MODULE_NAME,DATA_FREE_SIZE_TH_NAME,data_free_size_th);
}
/*!
\brief Constructor.
\param[in] AppName String containing unit test name.
\param[in] argc Number of arguments in argv
\param[in] argv Array of char arrays containing the command line arguments.
*/
dmz::Test::Test (const String &AppName, int argc, char *argv[]) :
obs (rt.get_context ()),
config ("global"),
log ("", rt.get_context ()),
error (False) {
const String LogLevelEnvStr (get_env ("DMZ_TEST_LOG_LEVEL"));
LogLevelEnum level (LogLevelWarn);
if (LogLevelEnvStr) { level = string_to_log_level (LogLevelEnvStr); }
obs.set_level (level);
log.out
<< "-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-" << endl
<< "Running " << AppName << " unit test." << endl
<< "-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-" << endl;
CommandLine cl (argc, argv);
CommandLineConfig clconfig;
if (!clconfig.process_command_line (cl, config)) {
log.error << "Unable to process command line: " << clconfig.get_error () << endl;
error = True;
}
}
void
make_tex_tfm (string name) {
string s;
int r= 0;
if (get_setting ("MAKETFM") == "MakeTeXTFM") {
s= "MakeTeXTFM " * name;
if (DEBUG_VERBOSE) debug_fonts << "Executing " << s << "\n";
r= system (s);
}
if (get_setting ("MAKETFM") == "mktextfm") {
url tfm_dir ("$TEXMACS_HOME_PATH/fonts/tfm");
s= "mktextfm " *
string ("--destdir ") * as_string (tfm_dir) * " " *
name;
if (DEBUG_VERBOSE) debug_fonts << "Executing " << s << "\n";
r= system (s);
string superfluous= name * ".600pk";
if (ends (name, ".tfm")) superfluous= name (0, N(name)-4) * ".600pk";
remove (tfm_dir * superfluous);
}
if (get_setting ("MAKETFM") == "maketfm"){
if (name(N(name) - 4, N(name)) == ".tfm")
name = name (0, N(name) - 4);
s = "maketfm --dest-dir \"" * get_env("$TEXMACS_HOME_PATH")
* "\\fonts\\tfm\" " * name;
if (DEBUG_VERBOSE) debug_fonts << "Executing " << s << "\n";
r= system (s);
}
if (r) cout << "TeXmacs] system command failed: " << s << "\n";
}
void umount_cmd(int term, char **args, int argc)
{
char *current_dir = NULL;
if(argc != 1)
{
term_color_print(term, "\nInvalid parameters.\n", 12);
term_color_print(term, "Usage: umount path\n", 7);
return;
}
current_dir = get_env("CURRENT_PATH", term);
if(strprefix(args[0], current_dir))
{
term_color_print(term, "Cannot umount dir, because it's a prefix of the current path.\n", 12);
return;
}
if(umount(args[0]))
{
term_color_print(term, mapioerr(ioerror()), 12);
term_color_print(term, "\n", 12);
}
}
/*
* Terminate destination --- called by jpeg_finish_compress
*/
METHODDEF(void) ios_term_destination(j_compress_ptr cinfo) {
struct jpeg_compress_struct * cs;
enc_client_data_ptr cdata;
enc_error_mgr_ptr err_mgr;
jbyteArray java_buffer;
JOCTET *native_buffer;
JNIEnv *env;
cs = (struct jpeg_compress_struct *) cinfo;
cdata = (enc_client_data_ptr) cs->client_data;
err_mgr = (enc_error_mgr_ptr) cs->err;
env = get_env();
java_buffer = (*env)->NewByteArray(env, MAX_BUFFER);
native_buffer = (JOCTET *)(*env)->GetPrimitiveArrayCritical(env, java_buffer, NULL);
memcpy(native_buffer, cdata->jpeg_buffer, MAX_BUFFER);
(*env)->ReleasePrimitiveArrayCritical(env, java_buffer, native_buffer, 0);
(*env)->CallVoidMethod(env, cdata->ios, IOSwriteID, java_buffer, 0, MAX_BUFFER - cs->dest->free_in_buffer);
// checking for an exception in the java method
if ((*env)->ExceptionOccurred(env)) {
err_mgr->base.error_exit((j_common_ptr) cinfo);
}
cs->dest->next_output_byte = NULL;
cs->dest->free_in_buffer = 0;
}
// ----------------------------------------------------------------------------
// the callback used to format data (into text, json, html, etc.) for clients
// ----------------------------------------------------------------------------
// HTTP/1.1 200 OK
// Content-type:text/plain
// Transfer-Encoding: chunked
//
// 3c;
// KEY:time VAL:Mon, 12 Mar 2012 13:11:49 GMT|KEY:00 VAL:14.03
// 3c;
// KEY:time VAL:Mon, 12 Mar 2012 13:11:49 GMT|KEY:00 VAL:40.75
// 3c;
// KEY:time VAL:Mon, 12 Mar 2012 13:11:49 GMT|KEY:00 VAL:45.02
// 0
//
static int push_fn(char *argv[], xbuf_t *reply)
{
reply->len = 0; // empty buffer
xbuf_xcat(reply, " \r\n" // room for chunck size: "1a; "
"KEY:time VAL:%s|", (char*)get_env(argv, SERVER_DATE));
// fill the 2D HTML <table> cells with our 1D array
// (we randomly skip some cells to avoid updating all of them)
{
int i = 0, r = 0, c = 0;
while(i < CELLS)
{
if(!(sw_rand(&rnd) & 3)) // skip some cells
xbuf_xcat(reply, "KEY:%c%c VAL:%.02f|",
'0' + r, '0' + c, s_data[i++]);
if(c + 1 < COLS) c++;
else
{
c = 0;
if(r + 1 < ROWS) r++; else r = 0;
}
}
}
reply->ptr[--reply->len] = 0; // remove the ending '|'
// now we know it, setup the chunk size
char *p = reply->ptr;
int i = s_snprintf(p, 8, "%x;", reply->len - (sizeof(" \r\n") - 2));
p[i] = ' '; // useful for tracing, when we puts(reply->ptr); later
xbuf_ncat(reply, "\r\n", sizeof("\r\n") - 1); // close this chunk
return 1;
}
string
get_locale_language () {
#if defined(_WIN32) || defined(__WIN32__)
return windows_locale_to_language (setlocale (LC_ALL, ""));
#else
string env_lan= get_env ("LC_ALL");
if (env_lan != "") return locale_to_language (env_lan);
env_lan= get_env ("LC_MESSAGES");
if (env_lan != "") return locale_to_language (env_lan);
env_lan= get_env ("LANG");
if (env_lan != "") return locale_to_language (env_lan);
env_lan= get_env ("GDM_LANG");
if (env_lan != "") return locale_to_language (env_lan);
return "english";
#endif
}
url
get_texmacs_home_path () {
url path= get_env ("TEXMACS_HOME_PATH");
if (path == "")
path= url_system ("$HOME/.TeXmacs");
return path;
}
/*
* getenv_int:
*/
static char *getenv_int(const char *name) {
#ifdef __OSE__
return get_env(get_bid(current_process()),name);
#else
return getenv(name);
#endif
}
int deal_with_command(t_lst *node, char **arg)
{
char **path;
char *right_path;
char **env;
env = get_env(node);
path = (char **)malloc(sizeof(char *) * 7);
if (!path)
return (-1);
path = split_path(node);
if (path && *arg && env)
{
right_path = check_path(path, *arg);
if (right_path)
{
exec_right_path(node, arg, env, right_path);
return (-1);
}
}
if (*arg && env)
{
right_path = "";
check_command(node, arg, right_path, env);
ft_strdel(arg);
}
return (-1);
}
int main(int argc, char **argv, char **env)
{
int fd;
get_env(env, 's');
sh_increase_shlvl();
fd = 0;
if (argc == 2)
fd = open(argv[1], O_RDONLY);
else if (argc > 2)
ft_putendl("Sorry, too many files to handle. Only one at a time");
else
{
gestion_signal(0);
ft_putendl("Welcome in this basic shell.");
sh_help();
}
if (fd >= 0)
{
sh_boucle_lecture(fd);
close(fd);
}
else
ft_putendl("An error occured: Could not open the file");
return (0);
}
int cd(t_shell *shell, t_tree *tree)
{
char *pwd;
char *path;
char *home;
if (cd_needed(shell, tree, &pwd, &home) == EXIT_FAILURE)
return (EXIT_FAILURE);
cd_get_path(tree->argv, &path, pwd, home);
if (!path)
{
if (!(path = get_env(shell->env, "OLDPWD")))
{
ft_putmsg(CD_OLDPWD, NULL);
return (EXIT_FAILURE);
}
ft_putendl(path);
}
if (chdir(path) == -1)
return (cd_error(&path, tree->argv[1]));
else
end_cd(shell, &path, &pwd);
ft_del(&path, &pwd, &home);
return (EXIT_SUCCESS);
}
static void build_cd_bis(char **s, char **env)
{
char *tmp;
if (ft_tablen(s) == 2)
{
if (s[1][0] == '~')
{
tmp = ft_strsub(s[1], 1, ft_strlen(s[1]));
s[1] = ft_strjoin(get_env("HOME", env), tmp);
free(tmp);
}
if (s[1][0] == '-')
s[1] = get_env("OLDPWD", env);
}
}
