/*
* Builds arguments.
*/
PRIVATE addr_t buildargs
(void *stack, size_t size, const char **argv, const char **envp)
{
int p; /* Stack pointer. */
int argc; /* argv length. */
int envc; /* envc length. */
/* Get argv count. */
if ((argc = count(argv)) < 0)
return (0);
/* Get envp count. */
if ((envc = count(envp)) < 0)
return (0);
/* Copy argv and envp to stack. */
if ((p = copy_strings(envc, envp, stack, size - 1, 0)) < 0)
return (0);
if ((p = copy_strings(argc, argv, stack, p, 0)) < 0)
return (0);
if ((p = create_tables(stack, size, p, argc, envc)) == 0)
return (0);
return (p);
}
static int do_load_applet(struct linux_binprm *bprm,struct pt_regs *regs)
{
char *cp, *interp, *i_name;
int retval;
if (strncmp (bprm->buf, "<!--applet", 10))
return -ENOEXEC;
iput(bprm->inode);
bprm->dont_iput=1;
/*
* OK, we've set the interpreter name
* Splice in (1) the interpreter's name for argv[0] (_PATH_BSHELL)
* (2) the name of the appletviewer wrapper for argv[1] (_PATH_APPLET)
* (3) filename of html file (replace argv[0])
*
* This is done in reverse order, because of how the
* user environment and arguments are stored.
*/
remove_arg_zero(bprm);
i_name = bprm->filename;
bprm->p = copy_strings(1, &i_name, bprm->page, bprm->p, 2);
bprm->argc++;
strcpy (bprm->buf, binfmt_java_appletviewer);
cp = bprm->buf;
bprm->p = copy_strings(1, &cp, bprm->page, bprm->p, 2);
bprm->argc++;
strcpy (bprm->buf, _PATH_SH);
interp = bprm->buf;
if ((i_name = strrchr (bprm->buf, '/')) != NULL)
i_name++;
else
i_name = bprm->buf;
bprm->p = copy_strings(1, &i_name, bprm->page, bprm->p, 2);
bprm->argc++;
if (!bprm->p)
return -E2BIG;
/*
* OK, now restart the process with the interpreter's inode.
* Note that we use open_namei() as the name is now in kernel
* space, and we don't need to copy it.
*/
retval = open_namei(interp, 0, 0, &bprm->inode, NULL);
if (retval)
return retval;
bprm->dont_iput=0;
retval=prepare_binprm(bprm);
if(retval<0)
return retval;
return search_binary_handler(bprm,regs);
}
void load_keys_from_section (char *terminal, char *profile_name)
{
char *section_name;
void *profile_keys;
char *key, *value, *valcopy;
int key_code;
if (!terminal)
return;
section_name = copy_strings ("terminal:", terminal, 0);
profile_keys = profile_init_iterator (section_name, profile_name);
if (!profile_keys){
free (section_name);
return;
}
while (profile_keys){
profile_keys = profile_iterator_next (profile_keys, &key, &value);
key_code = lookup_key (key);
valcopy = convert_controls (value);
if (key_code)
define_sequence (key_code, valcopy, MCKEY_NOACTION);
free (valcopy);
}
free (section_name);
return;
}
/* Returns fd of the open tar file */
static int tar_open_archive (vfs *me, char *name, vfs_s_super *archive)
{
int result, type;
long size;
mode_t mode;
struct vfs_s_inode *root;
result = mc_open (name, O_RDONLY);
if (result == -1) {
message_2s (1, MSG_ERROR, _("Couldn't open tar archive\n%s"), name);
ERRNOR (ENOENT, -1);
}
archive->name = strdup (name);
mc_stat (name, &(archive->u.tar.tarstat));
archive->u.tar.fd = -1;
/* Find out the method to handle this tar file */
size = is_gunzipable (result, &type);
mc_lseek (result, 0, SEEK_SET);
if (size > 0) {
char *s;
mc_close( result );
s = copy_strings( archive->name, decompress_extension (type), NULL );
result = mc_open (s, O_RDONLY);
if (result == -1)
message_2s (1, MSG_ERROR, _("Couldn't open tar archive\n%s"), s);
free(s);
if (result == -1)
ERRNOR (ENOENT, -1);
}
archive->u.tar.fd = result;
mode = archive->u.tar.tarstat.st_mode & 07777;
if (mode & 0400) mode |= 0100;
if (mode & 0040) mode |= 0010;
if (mode & 0004) mode |= 0001;
mode |= S_IFDIR;
root = vfs_s_new_inode (me, archive, &archive->u.tar.tarstat);
root->st.st_mode = mode;
root->u.tar.data_offset = -1;
root->st.st_nlink++;
root->st.st_dev = MEDATA->rdev++;
vfs_s_add_dots (me, root, NULL);
archive->root = root;
return result;
}
int
display_box (WPanel *panel, char **userp, char **minip, int *use_msformat, int num)
{
int result, i;
char *section = NULL;
char *p;
if (!panel) {
p = get_nth_panel_name (num);
panel = (WPanel *) xmalloc (sizeof (WPanel), "temporary panel");
panel->list_type = list_full;
panel->user_format = strdup (DEFAULT_USER_FORMAT);
panel->user_mini_status = 0;
for (i = 0; i < LIST_TYPES; i++)
panel->user_status_format[i] = strdup (DEFAULT_USER_FORMAT);
section = copy_strings ("Temporal:", p, 0);
if (!profile_has_section (section, profile_name)) {
free (section);
section = strdup (p);
}
panel_load_setup (panel, section);
free (section);
}
current_mode = panel->list_type;
display_init (current_mode, panel->user_format,
panel->user_mini_status, panel->user_status_format);
run_dlg (dd);
result = -1;
if (section) {
free (panel->user_format);
for (i = 0; i < LIST_TYPES; i++)
free (panel->user_status_format [i]);
free (panel);
}
if (dd->ret_value != B_CANCEL){
result = my_radio->sel;
*userp = strdup (user->buffer);
*minip = strdup (status->buffer);
*use_msformat = check_status->state & C_BOOL;
}
destroy_dlg (dd);
return result;
}
static Block_Obj sass_parse_block(Sass_Compiler* compiler) throw()
{
// assert valid pointer
if (compiler == 0) return 0;
// The cpp context must be set by now
Context* cpp_ctx = compiler->cpp_ctx;
Sass_Context* c_ctx = compiler->c_ctx;
// We will take care to wire up the rest
compiler->cpp_ctx->c_compiler = compiler;
compiler->state = SASS_COMPILER_PARSED;
try {
// get input/output path from options
std::string input_path = safe_str(c_ctx->input_path);
std::string output_path = safe_str(c_ctx->output_path);
// maybe skip some entries of included files
// we do not include stdin for data contexts
bool skip = c_ctx->type == SASS_CONTEXT_DATA;
// dispatch parse call
Block_Obj root(cpp_ctx->parse());
// abort on errors
if (!root) return 0;
// skip all prefixed files? (ToDo: check srcmap)
// IMO source-maps should point to headers already
// therefore don't skip it for now. re-enable or
// remove completely once this is tested
size_t headers = cpp_ctx->head_imports;
// copy the included files on to the context (dont forget to free later)
if (copy_strings(cpp_ctx->get_included_files(skip, headers), &c_ctx->included_files) == NULL)
throw(std::bad_alloc());
// return parsed block
return root;
}
// pass errors to generic error handler
catch (...) { handle_errors(c_ctx); }
// error
return 0;
}
struct table_text *getTt(char *str)
{
struct table_text *p,*p1;
/* Search text table for attributes to be copied. */
for (p1=&Tt_tab;p1 != NULL;p1=p1->next)
if (strcmp(str,p1->name) == 0) break;
if (p1 == NULL)
{
err_warn(0,fperr,
"Warning - Text attributes (%s) can't be found for get.\n",str);
return NULL;
}
/* Create a new table structure and copy to it. */
if((p=(struct table_text *)malloc(sizeof(struct table_text)))==NULL)
{
err_warn(1,fperr,
"Error - memory for getting Text table (%s) not found.\n",str);
return 0;
}
strcpy(p->name,p1->name);
strcpy(p->proj,p1->proj);
p->txfont=p1->txfont;
p->txpr=p1->txpr;
p->txexp=p1->txexp;
p->txsp=p1->txsp;
p->txci=p1->txci;
p->txfci=p1->txfci;
p->priority=p1->priority;
p->tvp[0]=p1->tvp[0];
p->tvp[1]=p1->tvp[1];
p->tvp[2]=p1->tvp[2];
p->tvp[3]=p1->tvp[3];
p->twc[0]=p1->twc[0];
p->twc[1]=p1->twc[1];
p->twc[2]=p1->twc[2];
p->twc[3]=p1->twc[3];
if (copy_points( &p->tx, p1->tx) == 0) return 0;
if (copy_points( &p->ty, p1->ty) == 0) return 0;
if (copy_strings( &p->ts, p1->ts) == 0) return 0;
p->next=NULL;
return p;
}
static void
learn_save (void)
{
int i;
int profile_changed = 0;
char *section = copy_strings ("terminal:", getenv ("TERM"), NULL);
for (i = 0; i < learn_total; i++) {
if (learnkeys [i].sequence != NULL) {
profile_changed = 1;
WritePrivateProfileString (section, key_name_conv_tab [i].name,
learnkeys [i].sequence, profile_name);
}
}
/* On the one hand no good idea to save the complete setup but
* without 'Auto save setup' the new key-definitions will not be
* saved unless the user does an 'Options/Save Setup'.
* On the other hand a save-button that does not save anything to
* disk is much worse.
*/
if (profile_changed)
sync_profiles ();
}
static int do_load_script(struct linux_binprm *bprm,struct pt_regs *regs)
{
char *cp, *interp, *i_name;
int retval;
unsigned char *ucp = (unsigned char *) bprm->buf;
if ((ucp[0] != 0xca) || (ucp[1] != 0xfe) || (ucp[2] != 0xba) || (ucp[3] != 0xbe))
return -ENOEXEC;
iput(bprm->inode);
bprm->dont_iput=1;
/*
* OK, we've set the interpreter name
* Splice in (1) the interpreter's name for argv[0] (_PATH_SH)
* (2) the name of the java wrapper for argv[1] (_PATH_JAVA)
* (3) filename of Java class (replace argv[0])
* without leading path or trailing '.class'
*
* This is done in reverse order, because of how the
* user environment and arguments are stored.
*/
remove_arg_zero(bprm);
if ((cp = strstr (bprm->filename, ".class")) != NULL)
*cp = 0;
if ((i_name = strrchr (bprm->filename, '/')) != NULL)
i_name++;
else
i_name = bprm->filename;
bprm->p = copy_strings(1, &i_name, bprm->page, bprm->p, 2);
bprm->argc++;
strcpy (bprm->buf, binfmt_java_interpreter);
cp = bprm->buf;
bprm->p = copy_strings(1, &cp, bprm->page, bprm->p, 2);
bprm->argc++;
strcpy (bprm->buf, _PATH_SH);
interp = bprm->buf;
if ((i_name = strrchr (bprm->buf, '/')) != NULL)
i_name++;
else
i_name = bprm->buf;
bprm->p = copy_strings(1, &i_name, bprm->page, bprm->p, 2);
bprm->argc++;
if (!bprm->p)
return -E2BIG;
/*
* OK, now restart the process with the interpreter's inode.
* Note that we use open_namei() as the name is now in kernel
* space, and we don't need to copy it.
*/
retval = open_namei(interp, 0, 0, &bprm->inode, NULL);
if (retval)
return retval;
bprm->dont_iput=0;
retval=prepare_binprm(bprm);
if(retval<0)
return retval;
return search_binary_handler(bprm,regs);
}
static int load_script(struct linux_binprm *bprm)
{
char *cp, *i_name, *i_name_start, *i_arg;
int fd;
char interp[128];
char fullpath[MAX_PATH];
int retval;
my_print("[debug] run script, buf = %s\n", bprm->buf);
if ((bprm->buf[0] != '#') || (bprm->buf[1] != '!') || (bprm->sh_bang))
return -ENOEXEC;
/*
* This section does the #! interpretation.
* Sorta complicated, but hopefully it will work. -TYT
*/
bprm->sh_bang++;
close(bprm->fd);
bprm->buf[127] = '\0';
if ((cp = strchr(bprm->buf, '\n')) == NULL)
cp = bprm->buf+127;
*cp = '\0';
while (cp > bprm->buf) {
cp--;
if ((*cp == ' ') || (*cp == '\t'))
*cp = '\0';
else
break;
}
for (cp = bprm->buf+2; (*cp == ' ') || (*cp == '\t'); cp++);
my_print("[debug]load_script(): cp= %s\n", cp);
if (*cp == '\0')
return -ENOEXEC; /* No interpreter name found */
i_name_start = i_name = cp;
i_arg = 0;
for ( ; *cp && (*cp != ' ') && (*cp != '\t'); cp++) {
if (*cp == '/')
i_name = cp+1;
}
while ((*cp == ' ') || (*cp == '\t'))
*cp++ = '\0';
if (*cp)
i_arg = cp;
strcpy (interp, i_name_start);
my_print("[debug]load_script(): cp= %s, i_name = %s, i_arg = %s\n", cp, i_name, i_arg);
/*
* OK, we've parsed out the interpreter name and
* (optional) argument.
* Splice in (1) the interpreter's name for argv[0]
* (2) (optional) argument to interpreter
* (3) filename of shell script (replace argv[0])
*
* This is done in reverse order, because of how the
* user environment and arguments are stored.
*/
remove_arg_zero(bprm);
bprm->p = copy_strings(1, &bprm->filename, bprm->page, bprm->p);
bprm->argc++;
if (i_arg) {
bprm->p = copy_strings(1, &i_arg, bprm->page, bprm->p);
bprm->argc++;
}
bprm->p = copy_strings(1, &i_name, bprm->page, bprm->p);
bprm->argc++;
if (!bprm->p)
return -E2BIG;
/*
* OK, now restart the process with the interpreter's dentry.
*/
my_print("[debug]load_script(): using interpreter %s\n", interp);
change_path_to_relative(fullpath, interp);
fd = open(fullpath, O_RDONLY);
if (fd < 0)
return -errno;
bprm->fd = fd;
bzero(bprm->buf, sizeof(bprm->buf));
retval = read(fd, bprm->buf, sizeof(bprm->buf));
if (retval < 0)
return retval;
return search_binary_handler(bprm);
}
static int load_elf_binary(struct linux_binprm * bprm, struct pt_regs * regs)
{
struct elfhdr elf_ex;
struct elfhdr interp_elf_ex;
struct file * file;
struct exec interp_ex;
struct inode *interpreter_inode;
unsigned int load_addr;
unsigned int interpreter_type = INTERPRETER_NONE;
int i;
int old_fs;
int error;
struct elf_phdr * elf_ppnt, *elf_phdata;
int elf_exec_fileno;
unsigned int elf_bss, k, elf_brk;
int retval;
char * elf_interpreter;
unsigned int elf_entry;
int status;
unsigned int start_code, end_code, end_data;
unsigned int elf_stack;
char passed_fileno[6];
status = 0;
load_addr = 0;
elf_ex = *((struct elfhdr *) bprm->buf); /* exec-header */
if (elf_ex.e_ident[0] != 0x7f ||
strncmp(&elf_ex.e_ident[1], "ELF",3) != 0)
return -ENOEXEC;
/* First of all, some simple consistency checks */
if(elf_ex.e_type != ET_EXEC ||
(elf_ex.e_machine != EM_386 && elf_ex.e_machine != EM_486) ||
(!bprm->inode->i_op || !bprm->inode->i_op->default_file_ops ||
!bprm->inode->i_op->default_file_ops->mmap)){
return -ENOEXEC;
};
/* Now read in all of the header information */
elf_phdata = (struct elf_phdr *) kmalloc(elf_ex.e_phentsize *
elf_ex.e_phnum, GFP_KERNEL);
old_fs = get_fs();
set_fs(get_ds());
retval = read_exec(bprm->inode, elf_ex.e_phoff, (char *) elf_phdata,
elf_ex.e_phentsize * elf_ex.e_phnum);
set_fs(old_fs);
if (retval < 0) {
kfree (elf_phdata);
return retval;
}
elf_ppnt = elf_phdata;
elf_bss = 0;
elf_brk = 0;
elf_exec_fileno = open_inode(bprm->inode, O_RDONLY);
if (elf_exec_fileno < 0) {
kfree (elf_phdata);
return elf_exec_fileno;
}
file = current->files->fd[elf_exec_fileno];
elf_stack = 0xffffffff;
elf_interpreter = NULL;
start_code = 0;
end_code = 0;
end_data = 0;
old_fs = get_fs();
set_fs(get_ds());
for(i=0;i < elf_ex.e_phnum; i++){
if(elf_ppnt->p_type == PT_INTERP) {
/* This is the program interpreter used for shared libraries -
for now assume that this is an a.out format binary */
elf_interpreter = (char *) kmalloc(elf_ppnt->p_filesz,
GFP_KERNEL);
retval = read_exec(bprm->inode,elf_ppnt->p_offset,elf_interpreter,
elf_ppnt->p_filesz);
#if 0
printk("Using ELF interpreter %s\n", elf_interpreter);
#endif
if(retval >= 0)
retval = namei(elf_interpreter, &interpreter_inode);
if(retval >= 0)
retval = read_exec(interpreter_inode,0,bprm->buf,128);
if(retval >= 0){
interp_ex = *((struct exec *) bprm->buf); /* exec-header */
interp_elf_ex = *((struct elfhdr *) bprm->buf); /* exec-header */
};
if(retval < 0) {
kfree (elf_phdata);
kfree(elf_interpreter);
return retval;
};
};
elf_ppnt++;
};
set_fs(old_fs);
/* Some simple consistency checks for the interpreter */
if(elf_interpreter){
interpreter_type = INTERPRETER_ELF | INTERPRETER_AOUT;
if(retval < 0) {
kfree(elf_interpreter);
kfree(elf_phdata);
return -ELIBACC;
};
/* Now figure out which format our binary is */
if((N_MAGIC(interp_ex) != OMAGIC) &&
(N_MAGIC(interp_ex) != ZMAGIC) &&
(N_MAGIC(interp_ex) != QMAGIC))
interpreter_type = INTERPRETER_ELF;
if (interp_elf_ex.e_ident[0] != 0x7f ||
strncmp(&interp_elf_ex.e_ident[1], "ELF",3) != 0)
interpreter_type &= ~INTERPRETER_ELF;
if(!interpreter_type)
{
kfree(elf_interpreter);
kfree(elf_phdata);
return -ELIBBAD;
};
}
/* OK, we are done with that, now set up the arg stuff,
and then start this sucker up */
if (!bprm->sh_bang) {
char * passed_p;
if(interpreter_type == INTERPRETER_AOUT) {
sprintf(passed_fileno, "%d", elf_exec_fileno);
passed_p = passed_fileno;
if(elf_interpreter) {
bprm->p = copy_strings(1,&passed_p,bprm->page,bprm->p,2);
bprm->argc++;
};
};
if (!bprm->p) {
if(elf_interpreter) {
kfree(elf_interpreter);
}
kfree (elf_phdata);
return -E2BIG;
}
}
/* OK, This is the point of no return */
flush_old_exec(bprm);
current->mm->end_data = 0;
current->mm->end_code = 0;
current->mm->start_mmap = ELF_START_MMAP;
current->mm->mmap = NULL;
elf_entry = (unsigned int) elf_ex.e_entry;
/* Do this so that we can load the interpreter, if need be. We will
change some of these later */
current->mm->rss = 0;
bprm->p += change_ldt(0, bprm->page);
current->mm->start_stack = bprm->p;
/* Now we do a little grungy work by mmaping the ELF image into
the correct location in memory. At this point, we assume that
the image should be loaded at fixed address, not at a variable
address. */
old_fs = get_fs();
set_fs(get_ds());
elf_ppnt = elf_phdata;
for(i=0;i < elf_ex.e_phnum; i++){
if(elf_ppnt->p_type == PT_INTERP) {
/* Set these up so that we are able to load the interpreter */
/* Now load the interpreter into user address space */
set_fs(old_fs);
if(interpreter_type & 1) elf_entry =
load_aout_interp(&interp_ex, interpreter_inode);
if(interpreter_type & 2) elf_entry =
load_elf_interp(&interp_elf_ex, interpreter_inode);
old_fs = get_fs();
set_fs(get_ds());
iput(interpreter_inode);
kfree(elf_interpreter);
if(elf_entry == 0xffffffff) {
printk("Unable to load interpreter\n");
kfree(elf_phdata);
send_sig(SIGSEGV, current, 0);
return 0;
};
};
if(elf_ppnt->p_type == PT_LOAD) {
error = do_mmap(file,
elf_ppnt->p_vaddr & 0xfffff000,
elf_ppnt->p_filesz + (elf_ppnt->p_vaddr & 0xfff),
PROT_READ | PROT_WRITE | PROT_EXEC,
MAP_FIXED | MAP_PRIVATE,
elf_ppnt->p_offset & 0xfffff000);
#ifdef LOW_ELF_STACK
if(elf_ppnt->p_vaddr & 0xfffff000 < elf_stack)
elf_stack = elf_ppnt->p_vaddr & 0xfffff000;
#endif
if(!load_addr)
load_addr = elf_ppnt->p_vaddr - elf_ppnt->p_offset;
k = elf_ppnt->p_vaddr;
if(k > start_code) start_code = k;
k = elf_ppnt->p_vaddr + elf_ppnt->p_filesz;
if(k > elf_bss) elf_bss = k;
if((elf_ppnt->p_flags | PROT_WRITE) && end_code < k)
end_code = k;
if(end_data < k) end_data = k;
k = elf_ppnt->p_vaddr + elf_ppnt->p_memsz;
if(k > elf_brk) elf_brk = k;
};
elf_ppnt++;
};
set_fs(old_fs);
kfree(elf_phdata);
if(interpreter_type != INTERPRETER_AOUT) sys_close(elf_exec_fileno);
/* The following 3 lines need a little bit of work if we are loading
an iBCS2 binary. We should initially load it this way, and if
we get a lcall7, then we should look to see if the iBCS2 execution
profile is present. If it is, then switch to that, otherwise
bomb. */
current->personality = PER_LINUX;
current->lcall7 = no_lcall7;
current->signal_map = current->signal_invmap = ident_map;
current->executable = bprm->inode;
bprm->inode->i_count++;
#ifdef LOW_ELF_STACK
current->start_stack = p = elf_stack - 4;
#endif
bprm->p -= MAX_ARG_PAGES*PAGE_SIZE;
bprm->p = (unsigned long)
create_elf_tables((char *)bprm->p,
bprm->argc,
bprm->envc,
(interpreter_type == INTERPRETER_ELF ? &elf_ex : NULL),
load_addr,
(interpreter_type == INTERPRETER_AOUT ? 0 : 1));
if(interpreter_type == INTERPRETER_AOUT)
current->mm->arg_start += strlen(passed_fileno) + 1;
current->mm->start_brk = current->mm->brk = elf_brk;
current->mm->end_code = end_code;
current->mm->start_code = start_code;
current->mm->end_data = end_data;
current->mm->start_stack = bprm->p;
current->suid = current->euid = bprm->e_uid;
current->sgid = current->egid = bprm->e_gid;
/* Calling sys_brk effectively mmaps the pages that we need for the bss and break
sections */
current->mm->brk = (elf_bss + 0xfff) & 0xfffff000;
sys_brk((elf_brk + 0xfff) & 0xfffff000);
padzero(elf_bss);
/* Why this, you ask??? Well SVr4 maps page 0 as read-only,
and some applications "depend" upon this behavior.
Since we do not have the power to recompile these, we
emulate the SVr4 behavior. Sigh. */
error = do_mmap(NULL, 0, 4096, PROT_READ | PROT_EXEC,
MAP_FIXED | MAP_PRIVATE, 0);
regs->eip = elf_entry; /* eip, magic happens :-) */
regs->esp = bprm->p; /* stack pointer */
if (current->flags & PF_PTRACED)
send_sig(SIGTRAP, current, 0);
return 0;
}
int chk_mov_Tt (struct table_text *pt)
{
struct table_text *ptb,*ptab;
if (pt == NULL) return 0;
for (ptb=ptab=&Tt_tab;
ptab!=NULL && cmpnbl(pt->name,ptab->name)!=0;
ptb=ptab,ptab=ptab->next);
/* Check if it's trying to overwrite the default. */
if (ptab == &Tt_tab)
{
err_warn(1,fperr,"Error - can't replace the default (Tt_%s).\n",
pt->name);
free((char *)pt);
return 0;
}
if (ptab == NULL)
{
ptb->next=ptab=pt;
}
else
{
/* if (pt->txfont != ptab->txfont ) printf("txfont diff %d,%d\n",pt->txfont, ptab->txfont); */
/* if (pt->txpr != ptab->txpr) printf("txpr diff %d,%d\n",pt->txpr, ptab->txpr); */
/* if (pt->txexp != ptab->txexp ) printf("txexp diff\n"); */
/* if (pt->txsp != ptab->txsp) printf("txsp diff\n"); */
/* if ( pt->txci != ptab->txci ) printf("txci diff %d,%d\n",pt->txci, ptab->txci); */
/* if ( pt->priority != ptab->priority ) printf("priority diff\n"); */
/* if (ptab->tvp[0] != pt->tvp[0] || ptab->tvp[1] != pt->tvp[1] || */
/* ptab->tvp[2] != pt->tvp[2] || ptab->tvp[3] != pt->tvp[3] ) printf("tvp diff\n"); */
/* if ( ptab->twc[0] != pt->twc[0] || ptab->twc[1] != pt->twc[1] || */
/* ptab->twc[2] != pt->twc[2] || ptab->twc[3] != pt->twc[3] ) printf("twc diff\n"); */
/* if (compare_points(ptab->tx, pt->tx )!=1) printf("tx difff\n"); */
/* if (compare_points(ptab->ty, pt->ty )!=1) printf("ty difff\n"); */
/* if (compare_strings(ptab->ts, pt->ts )!=1) printf("ts diff %s %s\n",ptab->ts,pt->ts); */
/* if (strcmp(ptab->proj,pt->proj) != 0) printf("proj diff\n"); */
if (pt->txfont != ptab->txfont || pt->txpr != ptab->txpr ||
pt->txexp != ptab->txexp || pt->txsp != ptab->txsp ||
pt->txci != ptab->txci || pt->txfci != ptab->txfci ||
pt->priority != ptab->priority ||
ptab->tvp[0] != pt->tvp[0] || ptab->tvp[1] != pt->tvp[1] ||
ptab->tvp[2] != pt->tvp[2] || ptab->tvp[3] != pt->tvp[3] ||
ptab->twc[0] != pt->twc[0] || ptab->twc[1] != pt->twc[1] ||
ptab->twc[2] != pt->twc[2] || ptab->twc[3] != pt->twc[3] ||
compare_points(ptab->tx, pt->tx )!=1 ||
compare_points(ptab->ty, pt->ty )!=1 ||
compare_strings(ptab->ts, pt->ts )!=1 ||
(strcmp(ptab->proj,pt->proj) != 0)
)
{
strcpy(ptab->proj,pt->proj);
ptab->txfont=pt->txfont;
ptab->txpr=pt->txpr;
ptab->txexp=pt->txexp;
ptab->txsp=pt->txsp;
ptab->txci=pt->txci;
ptab->txfci=pt->txfci;
ptab->priority=pt->priority;
ptab->tvp[0]=pt->tvp[0];
ptab->tvp[1]=pt->tvp[1];
ptab->tvp[2]=pt->tvp[2];
ptab->tvp[3]=pt->tvp[3];
ptab->twc[0]=pt->twc[0];
ptab->twc[1]=pt->twc[1];
ptab->twc[2]=pt->twc[2];
ptab->twc[3]=pt->twc[3];
free_points( &ptab->tx );
free_points( &ptab->ty );
free_strings( &ptab->ts );
if (copy_points( &ptab->tx, pt->tx) == 0) return 0;
if (copy_points( &ptab->ty, pt->ty) == 0) return 0;
if (copy_strings( &ptab->ts, pt->ts) == 0) return 0;
free_points( &pt->tx );
free_points( &pt->ty );
free_strings( &pt->ts );
check_d_text(ptab->name);
}
free((char *)pt);
pt=NULL;
}
if (!Inactive && fpout != NULL) prtTt(fpout,ptab);
return 1;
}
static int do_load_em86(struct linux_binprm *bprm,struct pt_regs *regs)
{
char *cp, *interp, *i_name, *i_arg;
int retval;
struct elfhdr elf_ex;
uid_t x86_uid;
gid_t x86_gid;
/* Make sure this is a Linux/Intel ELF executable... */
elf_ex = *((struct elfhdr *)bprm->buf);
if (elf_ex.e_ident[0] != 0x7f ||
strncmp(&elf_ex.e_ident[1], "ELF",3) != 0) {
return -ENOEXEC;
}
/* First of all, some simple consistency checks */
if ((elf_ex.e_type != ET_EXEC &&
elf_ex.e_type != ET_DYN) ||
(!((elf_ex.e_machine == EM_386) || (elf_ex.e_machine == EM_486))) ||
(!bprm->inode->i_op || !bprm->inode->i_op->default_file_ops ||
!bprm->inode->i_op->default_file_ops->mmap)){
return -ENOEXEC;
}
bprm->sh_bang++; /* Well, the bang-shell is implicit... */
iput(bprm->inode);
bprm->dont_iput = 1;
/* Unlike in the script case, we don't have to do any hairy
* parsing to find our interpreter... it's hardcoded!
*/
interp = EM86_INTERP;
i_name = EM86_I_NAME;
i_arg = NULL; /* We reserve the right to add an arg later */
/*
* Splice in (1) the interpreter's name for argv[0]
* (2) (optional) argument to interpreter
* (3) filename of emulated file (replace argv[0])
*
* This is done in reverse order, because of how the
* user environment and arguments are stored.
*/
remove_arg_zero(bprm);
bprm->p = copy_strings(1, &bprm->filename, bprm->page, bprm->p, 2);
bprm->argc++;
if (i_arg) {
bprm->p = copy_strings(1, &i_arg, bprm->page, bprm->p, 2);
bprm->argc++;
}
bprm->p = copy_strings(1, &i_name, bprm->page, bprm->p, 2);
bprm->argc++;
if (!bprm->p)
return -E2BIG;
/*
* OK, now restart the process with the interpreter's inode.
* Note that we use open_namei() as the name is now in kernel
* space, and we don't need to copy it.
*/
retval = open_namei(interp, 0, 0, &bprm->inode, NULL);
if (retval)
return retval;
bprm->dont_iput=0;
/* Remember the uid/gid that was set by this executable */
x86_uid = bprm->e_uid;
x86_gid = bprm->e_gid;
retval=prepare_binprm(bprm);
if(retval<0)
return retval;
/* ...so that we may propagate them to em86 */
bprm->e_uid = x86_uid;
bprm->e_gid = x86_gid;
current->personality = PER_LINUX_EM86;
return search_binary_handler(bprm,regs);
}
/* FIXME: recode this routine on version 3.0, it could be cleaner */
void execute_menu_command (char *s)
{
char *commands;
FILE *cmd_file;
int cmd_file_fd;
int expand_prefix_found = 0;
int parameter_found = 0;
int do_quote;
char prompt [80] = "";
int col;
char *file_name = tmpnam (0);
#ifdef OS2_NT
/* OS/2 and NT requires the command to end in .cmd */
file_name = copy_strings (file_name, ".cmd", NULL);
file_name = "temp.bat"; // $$ fixme
if ((cmd_file_fd = open (file_name, O_RDWR | O_CREAT | O_TRUNC | O_EXCL
| O_TEXT, 0600)) == -1){
message (1, MSG_ERROR, _(" Can't create temporary command file \n %s "),
unix_error_string (errno));
return;
}
#else
if ((cmd_file_fd = open (file_name, O_RDWR | O_CREAT | O_TRUNC | O_EXCL, 0600)) == -1){
message (1, MSG_ERROR, _(" Can't create temporary command file \n %s "),
unix_error_string (errno));
return;
}
#endif
cmd_file = fdopen (cmd_file_fd, "w");
commands = strchr (s, '\n');
if (!commands){
fclose (cmd_file);
unlink (file_name);
return;
}
commands++;
for (col = 0; *commands; commands++){
if (col == 0 && (*commands != ' ' && *commands != '\t'))
break;
else if (col == 0)
while (*commands == ' ' || *commands == '\t')
commands++;
col++;
if (*commands == '\n')
col = 0;
if (parameter_found){
if (*commands == '}'){
char *parameter;
char *tmp;
parameter_found = 0;
parameter = input_dialog (_(" Parameter "), prompt, "");
if (!parameter || !*parameter){
/* User canceled */
fclose (cmd_file);
unlink (file_name);
return;
}
if (do_quote) {
fputs (tmp = name_quote (parameter, 0), cmd_file);
free (tmp);
} else
fputs (parameter, cmd_file);
free (parameter);
} else {
int len = strlen (prompt);
if (len+1 < sizeof (prompt)){
prompt [len] = *commands;
prompt [len+1] = 0;
} else
prompt [sizeof (prompt)-1] = 0;
}
} else if (expand_prefix_found){
expand_prefix_found = 0;
if (isdigit (*commands)) {
do_quote = atoi (commands);
for ( ; isdigit (*commands); commands++)
;
}
if (*commands == '{')
parameter_found = 1;
else{
char *text = expand_format (*commands, do_quote);
fputs (text, cmd_file);
free (text);
}
} else {
if (*commands == '%') {
do_quote = 1; /* Default: Quote expanded macro */
expand_prefix_found = 1;
} else
fputc (*commands, cmd_file);
}
}
fclose (cmd_file);
chmod (file_name, S_IRWXU);
execute (file_name);
unlink (file_name);
}
static inline int
do_load_elf_binary(struct linux_binprm * bprm, struct pt_regs * regs)
{
struct file * file;
struct dentry *interpreter_dentry = NULL; /* to shut gcc up */
unsigned long load_addr = 0, load_bias;
int load_addr_set = 0;
char * elf_interpreter = NULL;
unsigned int interpreter_type = INTERPRETER_NONE;
unsigned char ibcs2_interpreter = 0;
mm_segment_t old_fs;
unsigned long error;
struct elf_phdr * elf_ppnt, *elf_phdata;
unsigned long elf_bss, k, elf_brk;
int elf_exec_fileno;
int retval, size, i;
unsigned long elf_entry, interp_load_addr = 0;
unsigned long start_code, end_code, end_data;
struct elfhdr elf_ex;
struct elfhdr interp_elf_ex;
struct exec interp_ex;
char passed_fileno[6];
/* Get the exec-header */
elf_ex = *((struct elfhdr *) bprm->buf);
retval = -ENOEXEC;
/* First of all, some simple consistency checks */
if (elf_ex.e_ident[0] != 0x7f ||
strncmp(&elf_ex.e_ident[1], "ELF", 3) != 0)
goto out;
if (elf_ex.e_type != ET_EXEC && elf_ex.e_type != ET_DYN)
goto out;
if (!elf_check_arch(elf_ex.e_machine))
goto out;
#ifdef __mips__
/* allow only mips1 if exec is MIPSEB elf,
because IRIX binaries handled elsewhere. */
/* borrowed from binutils/include/elf/common.h*/
#define EI_DATA 5 /* Data encoding */
#define ELFDATA2MSB 2 /* 2's complement, big endian */
if ((elf_ex.e_ident[EI_DATA] == ELFDATA2MSB ) &&
(elf_ex.e_flags & EF_MIPS_ARCH) ) {
retval = -ENOEXEC;
goto out;
}
#endif
if (!bprm->dentry->d_inode->i_op ||
!bprm->dentry->d_inode->i_op->default_file_ops ||
!bprm->dentry->d_inode->i_op->default_file_ops->mmap)
goto out;
/* Now read in all of the header information */
retval = -ENOMEM;
size = elf_ex.e_phentsize * elf_ex.e_phnum;
elf_phdata = (struct elf_phdr *) kmalloc(size, GFP_KERNEL);
if (!elf_phdata)
goto out;
retval = read_exec(bprm->dentry, elf_ex.e_phoff,
(char *) elf_phdata, size, 1);
if (retval < 0)
goto out_free_ph;
retval = open_dentry(bprm->dentry, O_RDONLY);
if (retval < 0)
goto out_free_ph;
elf_exec_fileno = retval;
file = fget(elf_exec_fileno);
elf_ppnt = elf_phdata;
elf_bss = 0;
elf_brk = 0;
start_code = ~0UL;
end_code = 0;
end_data = 0;
for (i = 0; i < elf_ex.e_phnum; i++) {
if (elf_ppnt->p_type == PT_INTERP) {
retval = -EINVAL;
if (elf_interpreter)
goto out_free_interp;
/* This is the program interpreter used for
* shared libraries - for now assume that this
* is an a.out format binary
*/
retval = -ENOMEM;
elf_interpreter = (char *) kmalloc(elf_ppnt->p_filesz,
GFP_KERNEL);
if (!elf_interpreter)
goto out_free_file;
retval = read_exec(bprm->dentry, elf_ppnt->p_offset,
elf_interpreter,
elf_ppnt->p_filesz, 1);
if (retval < 0)
goto out_free_interp;
/* If the program interpreter is one of these two,
* then assume an iBCS2 image. Otherwise assume
* a native linux image.
*/
if (strcmp(elf_interpreter,"/usr/lib/libc.so.1") == 0 ||
strcmp(elf_interpreter,"/usr/lib/ld.so.1") == 0)
ibcs2_interpreter = 1;
#if 0
printk("Using ELF interpreter %s\n", elf_interpreter);
#endif
old_fs = get_fs(); /* This could probably be optimized */
set_fs(get_ds());
#ifdef __sparc__
if (ibcs2_interpreter) {
unsigned long old_pers = current->personality;
current->personality = PER_SVR4;
interpreter_dentry = open_namei(elf_interpreter,
0, 0);
current->personality = old_pers;
} else
#endif
interpreter_dentry = open_namei(elf_interpreter,
0, 0);
set_fs(old_fs);
retval = PTR_ERR(interpreter_dentry);
if (IS_ERR(interpreter_dentry))
goto out_free_interp;
retval = permission(interpreter_dentry->d_inode, MAY_EXEC);
if (retval < 0)
goto out_free_dentry;
retval = read_exec(interpreter_dentry, 0, bprm->buf, 128, 1);
if (retval < 0)
goto out_free_dentry;
/* Get the exec headers */
interp_ex = *((struct exec *) bprm->buf);
interp_elf_ex = *((struct elfhdr *) bprm->buf);
}
elf_ppnt++;
}
/* Some simple consistency checks for the interpreter */
if (elf_interpreter) {
interpreter_type = INTERPRETER_ELF | INTERPRETER_AOUT;
/* Now figure out which format our binary is */
if ((N_MAGIC(interp_ex) != OMAGIC) &&
(N_MAGIC(interp_ex) != ZMAGIC) &&
(N_MAGIC(interp_ex) != QMAGIC))
interpreter_type = INTERPRETER_ELF;
if (interp_elf_ex.e_ident[0] != 0x7f ||
strncmp(&interp_elf_ex.e_ident[1], "ELF", 3) != 0)
interpreter_type &= ~INTERPRETER_ELF;
retval = -ELIBBAD;
if (!interpreter_type)
goto out_free_dentry;
/* Make sure only one type was selected */
if ((interpreter_type & INTERPRETER_ELF) &&
interpreter_type != INTERPRETER_ELF) {
printk(KERN_WARNING "ELF: Ambiguous type, using ELF\n");
interpreter_type = INTERPRETER_ELF;
}
}
/* OK, we are done with that, now set up the arg stuff,
and then start this sucker up */
if (!bprm->sh_bang) {
char * passed_p;
if (interpreter_type == INTERPRETER_AOUT) {
sprintf(passed_fileno, "%d", elf_exec_fileno);
passed_p = passed_fileno;
if (elf_interpreter) {
bprm->p = copy_strings(1,&passed_p,bprm->page,bprm->p,2);
bprm->argc++;
}
}
retval = -E2BIG;
if (!bprm->p)
goto out_free_dentry;
}
/* Flush all traces of the currently running executable */
retval = flush_old_exec(bprm);
if (retval)
goto out_free_dentry;
/* OK, This is the point of no return */
current->mm->end_data = 0;
current->mm->end_code = 0;
current->mm->mmap = NULL;
current->flags &= ~PF_FORKNOEXEC;
elf_entry = (unsigned long) elf_ex.e_entry;
/* Do this immediately, since STACK_TOP as used in setup_arg_pages
may depend on the personality. */
SET_PERSONALITY(elf_ex, ibcs2_interpreter);
/* Do this so that we can load the interpreter, if need be. We will
change some of these later */
current->mm->rss = 0;
bprm->p = setup_arg_pages(bprm->p, bprm);
current->mm->start_stack = bprm->p;
/* Try and get dynamic programs out of the way of the default mmap
base, as well as whatever program they might try to exec. This
is because the brk will follow the loader, and is not movable. */
load_bias = ELF_PAGESTART(elf_ex.e_type==ET_DYN ? ELF_ET_DYN_BASE : 0);
/* Now we do a little grungy work by mmaping the ELF image into
the correct location in memory. At this point, we assume that
the image should be loaded at fixed address, not at a variable
address. */
old_fs = get_fs();
set_fs(get_ds());
for(i = 0, elf_ppnt = elf_phdata; i < elf_ex.e_phnum; i++, elf_ppnt++) {
int elf_prot = 0, elf_flags;
unsigned long vaddr;
if (elf_ppnt->p_type != PT_LOAD)
continue;
if (elf_ppnt->p_flags & PF_R) elf_prot |= PROT_READ;
if (elf_ppnt->p_flags & PF_W) elf_prot |= PROT_WRITE;
if (elf_ppnt->p_flags & PF_X) elf_prot |= PROT_EXEC;
elf_flags = MAP_PRIVATE|MAP_DENYWRITE|MAP_EXECUTABLE;
vaddr = elf_ppnt->p_vaddr;
if (elf_ex.e_type == ET_EXEC || load_addr_set) {
elf_flags |= MAP_FIXED;
}
error = do_mmap(file, ELF_PAGESTART(load_bias + vaddr),
(elf_ppnt->p_filesz +
ELF_PAGEOFFSET(elf_ppnt->p_vaddr)),
elf_prot, elf_flags, (elf_ppnt->p_offset -
ELF_PAGEOFFSET(elf_ppnt->p_vaddr)));
if (!load_addr_set) {
load_addr_set = 1;
load_addr = (elf_ppnt->p_vaddr - elf_ppnt->p_offset);
if (elf_ex.e_type == ET_DYN) {
load_bias += error -
ELF_PAGESTART(load_bias + vaddr);
load_addr += error;
}
}
k = elf_ppnt->p_vaddr;
if (k < start_code) start_code = k;
k = elf_ppnt->p_vaddr + elf_ppnt->p_filesz;
if (k > elf_bss)
elf_bss = k;
if ((elf_ppnt->p_flags & PF_X) && end_code < k)
end_code = k;
if (end_data < k)
end_data = k;
k = elf_ppnt->p_vaddr + elf_ppnt->p_memsz;
if (k > elf_brk)
elf_brk = k;
}
set_fs(old_fs);
fput(file); /* all done with the file */
elf_entry += load_bias;
elf_bss += load_bias;
elf_brk += load_bias;
start_code += load_bias;
end_code += load_bias;
end_data += load_bias;
if (elf_interpreter) {
if (interpreter_type == INTERPRETER_AOUT)
elf_entry = load_aout_interp(&interp_ex,
interpreter_dentry);
else
elf_entry = load_elf_interp(&interp_elf_ex,
interpreter_dentry,
&interp_load_addr);
dput(interpreter_dentry);
kfree(elf_interpreter);
if (elf_entry == ~0UL) {
printk(KERN_ERR "Unable to load interpreter\n");
kfree(elf_phdata);
send_sig(SIGSEGV, current, 0);
return 0;
}
}
kfree(elf_phdata);
if (interpreter_type != INTERPRETER_AOUT)
sys_close(elf_exec_fileno);
if (current->exec_domain && current->exec_domain->module)
__MOD_DEC_USE_COUNT(current->exec_domain->module);
if (current->binfmt && current->binfmt->module)
__MOD_DEC_USE_COUNT(current->binfmt->module);
current->exec_domain = lookup_exec_domain(current->personality);
current->binfmt = &elf_format;
if (current->exec_domain && current->exec_domain->module)
__MOD_INC_USE_COUNT(current->exec_domain->module);
if (current->binfmt && current->binfmt->module)
__MOD_INC_USE_COUNT(current->binfmt->module);
#ifndef VM_STACK_FLAGS
current->executable = dget(bprm->dentry);
#endif
compute_creds(bprm);
current->flags &= ~PF_FORKNOEXEC;
bprm->p = (unsigned long)
create_elf_tables((char *)bprm->p,
bprm->argc,
bprm->envc,
(interpreter_type == INTERPRETER_ELF ? &elf_ex : NULL),
load_addr, load_bias,
interp_load_addr,
(interpreter_type == INTERPRETER_AOUT ? 0 : 1));
/* N.B. passed_fileno might not be initialized? */
if (interpreter_type == INTERPRETER_AOUT)
current->mm->arg_start += strlen(passed_fileno) + 1;
current->mm->start_brk = current->mm->brk = elf_brk;
current->mm->end_code = end_code;
current->mm->start_code = start_code;
current->mm->end_data = end_data;
current->mm->start_stack = bprm->p;
/* Calling set_brk effectively mmaps the pages that we need
* for the bss and break sections
*/
set_brk(elf_bss, elf_brk);
padzero(elf_bss);
#if 0
printk("(start_brk) %x\n" , current->mm->start_brk);
printk("(end_code) %x\n" , current->mm->end_code);
printk("(start_code) %x\n" , current->mm->start_code);
printk("(end_data) %x\n" , current->mm->end_data);
printk("(start_stack) %x\n" , current->mm->start_stack);
printk("(brk) %x\n" , current->mm->brk);
#endif
if ( current->personality == PER_SVR4 )
{
/* Why this, you ask??? Well SVr4 maps page 0 as read-only,
and some applications "depend" upon this behavior.
Since we do not have the power to recompile these, we
emulate the SVr4 behavior. Sigh. */
/* N.B. Shouldn't the size here be PAGE_SIZE?? */
error = do_mmap(NULL, 0, 4096, PROT_READ | PROT_EXEC,
MAP_FIXED | MAP_PRIVATE, 0);
}
#ifdef ELF_PLAT_INIT
/*
* The ABI may specify that certain registers be set up in special
* ways (on i386 %edx is the address of a DT_FINI function, for
* example. This macro performs whatever initialization to
* the regs structure is required.
*/
ELF_PLAT_INIT(regs);
#endif
start_thread(regs, elf_entry, bprm->p);
if (current->flags & PF_PTRACED)
send_sig(SIGTRAP, current, 0);
retval = 0;
out:
return retval;
/* error cleanup */
out_free_dentry:
dput(interpreter_dentry);
out_free_interp:
if (elf_interpreter)
kfree(elf_interpreter);
out_free_file:
fput(file);
sys_close(elf_exec_fileno);
out_free_ph:
kfree(elf_phdata);
goto out;
}
static int load_elf_binary(struct linux_binprm *bprm)
{
struct pt_regs regs;
int interpreter_fd = -1;
unsigned long load_addr = 0, load_bias;
int load_addr_set = 0;
char * elf_interpreter = NULL;
unsigned int interpreter_type = INTERPRETER_NONE;
unsigned long error;
struct elf_phdr * elf_ppnt, *elf_phdata;
unsigned long elf_bss, k, elf_brk;
int elf_exec_fileno;
int retval, size, i;
unsigned long elf_entry, interp_load_addr = 0;
unsigned long start_code, end_code, end_data;
struct elfhdr elf_ex;
struct elfhdr interp_elf_ex;
struct exec interp_ex;
char passed_fileno[6];
/* Get the exec-header */
elf_ex = *((struct elfhdr *) bprm->buf);
my_print("[debug]here to run elf\n");
retval = -ENOEXEC;
/* First of all, some simple consistency checks */
if (elf_ex.e_ident[0] != 0x7f ||
strncmp(&elf_ex.e_ident[1], "ELF", 3) != 0)
goto out;
//my_print("[ender]1\n");
if (elf_ex.e_type != ET_EXEC && elf_ex.e_type != ET_DYN)
goto out;
if (!elf_check_arch(elf_ex.e_machine))
goto out;
//my_print("[ender]2\n");
/* Now read in all of the header information */
if (elf_ex.e_phentsize != sizeof(struct elf_phdr) ||
elf_ex.e_phnum < 1 ||
elf_ex.e_phnum > 65536 / sizeof(struct elf_phdr))
goto out;
// my_print("[ender]3\n");
retval = -ENOMEM;
size = elf_ex.e_phentsize * elf_ex.e_phnum;
elf_phdata = (struct elf_phdr *) malloc(size);
if (!elf_phdata)
goto out;
retval = read_exec(bprm->fd, elf_ex.e_phoff, (char *) elf_phdata, size, 1);
if (retval < 0)
goto out_free_ph;
//my_print("[ender]4\n");
elf_exec_fileno = dup(bprm->fd);
lseek(elf_exec_fileno, 0, SEEK_SET);
elf_ppnt = elf_phdata;
elf_bss = 0;
elf_brk = 0;
start_code = ~0UL;
end_code = 0;
end_data = 0;
/* look for interpreter */
for (i = 0; i < elf_ex.e_phnum; i++) {
if (elf_ppnt->p_type == PT_INTERP) {
retval = -ENOEXEC;
if (elf_interpreter ||
elf_ppnt->p_filesz < 2 ||
elf_ppnt->p_filesz > PAGE_SIZE)
goto out_free_dentry;
/* This is the program interpreter used for
* shared libraries - for now assume that this
* is an a.out format binary
*/
retval = -ENOMEM;
elf_interpreter = (char *)malloc(elf_ppnt->p_filesz);
if (!elf_interpreter)
goto out_free_file;
retval = read_exec(bprm->fd, elf_ppnt->p_offset,
elf_interpreter, elf_ppnt->p_filesz, 1);
if (retval < 0)
goto out_free_interp;
elf_interpreter[elf_ppnt->p_filesz - 1] = 0;
#if 0
/* If the program interpreter is one of these two,
* then assume an iBCS2 image. Otherwise assume
* a native linux image.
*/
if (strcmp(elf_interpreter,"/usr/lib/libc.so.1") == 0 ||
strcmp(elf_interpreter,"/usr/lib/ld.so.1") == 0)
ibcs2_interpreter = 1;
#endif
log_debug(LOG_LINEXEC_EXEC, "Using ELF interpreter: %s", elf_interpreter);
if( elf_interpreter[0] == '/'){
char tmp [MAX_PATH];
change_path_to_relative(tmp, elf_interpreter);
free(elf_interpreter);
//elf_interpreter = (char *)malloc(elf_ppnt->p_filesz);
elf_interpreter = (char *)malloc(strlen(tmp)+1);
if (!elf_interpreter)
goto out_free_file;
strcpy(elf_interpreter, tmp);
}
interpreter_fd = open(elf_interpreter, O_RDONLY);
my_print("[debug]open elf_interpreter %s\n", elf_interpreter);
if (interpreter_fd < 0) {
retval = -errno;
goto out_free_interp;
}
#if 0
retval = permission(interpreter_dentry->d_inode, MAY_EXEC);
if (retval < 0)
goto out_free_dentry;
#endif
retval = read_exec(interpreter_fd, 0, bprm->buf, 128, 1);
if (retval < 0)
goto out_free_dentry;
/* Get the exec headers */
interp_ex = *((struct exec *) bprm->buf);
interp_elf_ex = *((struct elfhdr *) bprm->buf);
}
elf_ppnt++;
//my_print("[ender]6\n");
}
/* Some simple consistency checks for the interpreter */
if (elf_interpreter) {
interpreter_type = INTERPRETER_ELF | INTERPRETER_AOUT;
/* Now figure out which format our binary is */
if ((N_MAGIC(interp_ex) != OMAGIC) &&
(N_MAGIC(interp_ex) != ZMAGIC) &&
(N_MAGIC(interp_ex) != QMAGIC))
interpreter_type = INTERPRETER_ELF;
if (interp_elf_ex.e_ident[0] != 0x7f ||
strncmp(&interp_elf_ex.e_ident[1], "ELF", 3) != 0)
interpreter_type &= ~INTERPRETER_ELF;
retval = -ELIBBAD;
if (!interpreter_type)
goto out_free_dentry;
/* Make sure only one type was selected */
if ((interpreter_type & INTERPRETER_ELF) &&
interpreter_type != INTERPRETER_ELF) {
printf("ELF: Ambiguous type, using ELF\n");
interpreter_type = INTERPRETER_ELF;
}
}
//my_print("[ender]7\n");
/* OK, we are done with that, now set up the arg stuff,
and then start this sucker up */
if (!bprm->sh_bang) {
char * passed_p;
if (interpreter_type == INTERPRETER_AOUT) {
sprintf(passed_fileno, "%d", elf_exec_fileno);
passed_p = passed_fileno;
if (elf_interpreter) {
bprm->p = copy_strings(1,&passed_p,bprm->page,bprm->p);
bprm->argc++;
}
}
retval = -E2BIG;
if (!bprm->p)
goto out_free_dentry;
}
#if 0
/* Flush all traces of the currently running executable */
retval = flush_old_exec(bprm);
if (retval)
goto out_free_dentry;
#endif
/* OK, This is the point of no return */
current->end_data = 0;
current->end_code = 0;
#if 0
current->mm->mmap = NULL;
current->flags &= ~PF_FORKNOEXEC;
#endif
elf_entry = (unsigned long) elf_ex.e_entry;
//printf("[ender]8\n");
#if 0
/* Do this immediately, since STACK_TOP as used in setup_arg_pages
may depend on the personality. */
SET_PERSONALITY(elf_ex, ibcs2_interpreter);
#endif
/* Do this so that we can load the interpreter, if need be. We will
change some of these later */
// current->mm->rss = 0;
bprm->p = setup_arg_pages(bprm->p, bprm);
current->start_stack = bprm->p;
/* Try and get dynamic programs out of the way of the default mmap
base, as well as whatever program they might try to exec. This
is because the brk will follow the loader, and is not movable. */
load_bias = ELF_PAGESTART(elf_ex.e_type==ET_DYN ? ELF_ET_DYN_BASE : 0);
#ifdef __VERBOSE__
printf("load_bias: %08lX\n", load_bias);
#endif
/* Now we do a little grungy work by mmaping the ELF image into
the correct location in memory. At this point, we assume that
the image should be loaded at fixed address, not at a variable
address. */
for(i = 0, elf_ppnt = elf_phdata; i < elf_ex.e_phnum; i++, elf_ppnt++) {
int elf_prot = 0, elf_flags;
unsigned long vaddr;
if (elf_ppnt->p_type != PT_LOAD)
continue;
if (elf_ppnt->p_flags & PF_R) elf_prot |= PROT_READ;
if (elf_ppnt->p_flags & PF_W) elf_prot |= PROT_WRITE;
if (elf_ppnt->p_flags & PF_X) elf_prot |= PROT_EXEC;
elf_flags = MAP_PRIVATE; // |MAP_DENYWRITE|MAP_EXECUTABLE;
vaddr = elf_ppnt->p_vaddr;
if (elf_ex.e_type == ET_EXEC || load_addr_set) {
elf_flags |= MAP_FIXED;
}
//my_print("[ender]9\n");
#ifdef __VERBOSE__
printf("mapping: %08lX\n", ELF_PAGESTART(load_bias + vaddr));
#endif
error = do_mmap(bprm->fd, ELF_PAGESTART(load_bias + vaddr),
(elf_ppnt->p_filesz + ELF_PAGEOFFSET(elf_ppnt->p_vaddr)),
elf_prot, elf_flags,
(elf_ppnt->p_offset - ELF_PAGEOFFSET(elf_ppnt->p_vaddr)));
#ifdef __VERBOSE__
printf("error: %08lX\n", error);
#endif
if (!load_addr_set) {
load_addr_set = 1;
load_addr = (elf_ppnt->p_vaddr - elf_ppnt->p_offset);
#ifdef __VERBOSE__
printf("load_addr: %08lX, vaddr: %08lX\n", load_addr, vaddr);
#endif
if (elf_ex.e_type == ET_DYN) {
load_bias += error - ELF_PAGESTART(load_bias + vaddr);
load_addr += error;
#ifdef __VERBOSE__
printf("new\nload_bias: %08lX, load_addr: %08lX\n", load_bias, load_addr);
#endif
}
}
k = elf_ppnt->p_vaddr;
if (k < start_code) start_code = k;
k = elf_ppnt->p_vaddr + elf_ppnt->p_filesz;
if (k > elf_bss)
elf_bss = k;
if ((elf_ppnt->p_flags & PF_X) && end_code < k)
end_code = k;
if (end_data < k)
end_data = k;
k = elf_ppnt->p_vaddr + elf_ppnt->p_memsz;
if (k > elf_brk)
elf_brk = k;
}
close(bprm->fd);
elf_entry += load_bias;
elf_bss += load_bias;
elf_brk += load_bias;
start_code += load_bias;
end_code += load_bias;
end_data += load_bias;
if (elf_interpreter) {
if (interpreter_type == INTERPRETER_AOUT) {
elf_entry = load_aout_interp(&interp_ex, interpreter_fd);
} else {
elf_entry = load_elf_interp(&interp_elf_ex, interpreter_fd,
&interp_load_addr);
}
close(interpreter_fd);
if (elf_entry == ~0UL) {
printf("Unable to load interpreter %.128s\n", elf_interpreter);
free(elf_interpreter);
free(elf_phdata);
//send_sig(SIGSEGV, current, 0);
exit(1);
return 0;
}
free(elf_interpreter);
}
free(elf_phdata);
if (interpreter_type != INTERPRETER_AOUT)
close(elf_exec_fileno);
#if 0
#ifndef VM_STACK_FLAGS
current->executable = dget(bprm->dentry);
#endif
#endif
bprm->p = (unsigned long)create_elf_tables((char *)bprm->p,
bprm->argc, bprm->envc,
(interpreter_type == INTERPRETER_ELF ? &elf_ex : NULL),
load_addr, load_bias, interp_load_addr,
(interpreter_type == INTERPRETER_AOUT ? 0 : 1));
#if 0
/* N.B. passed_fileno might not be initialized? */
if (interpreter_type == INTERPRETER_AOUT)
current->arg_start += strlen(passed_fileno) + 1;
#endif
current->start_brk = current->brk = elf_brk;
current->end_code = end_code;
current->start_code = start_code;
current->end_data = end_data;
current->start_stack = bprm->p;
/* Calling set_brk effectively mmaps the pages that we need
* for the bss and break sections
*/
set_brk(elf_bss, elf_brk);
padzero(elf_bss);
log_debug(LOG_LINEXEC_EXEC,"start_brk: %lx" , current->start_brk);
log_debug(LOG_LINEXEC_EXEC,"end_code: %lx" , current->end_code);
log_debug(LOG_LINEXEC_EXEC,"start_code: %lx" , current->start_code);
log_debug(LOG_LINEXEC_EXEC,"end_data: %lx" , current->end_data);
log_debug(LOG_LINEXEC_EXEC,"start_stack: %lx" , current->start_stack);
log_debug(LOG_LINEXEC_EXEC,"brk: %lx" , current->brk);
/*
* The ABI may specify that certain registers be set up in special
* ways (on i386 %edx is the address of a DT_FINI function, for
* example. This macro performs whatever initialization to
* the regs structure is required.
*/
ELF_PLAT_INIT((®s));
regs.eip = elf_entry;
regs.esp = bprm->p;
#if 0
if (current->flags & PF_PTRACED)
send_sig(SIGTRAP, current, 0);
#endif
#ifndef __DEBUG__
// dumpMemoryMap();
log_verbose(LOG_LINEXEC_EXEC, "[transfering control to Linux executable]");
//getchar();
//printf("[ender]11\n");
ASM_EXEC_JUMP(regs);
printf("You should never see this message!\n");
#else
printf("execve() finished, but in debug mode. exiting...\n");
#endif
retval = 0;
out:
return retval;
/* error cleanup */
out_free_dentry:
close(interpreter_fd);
out_free_interp:
if (elf_interpreter) {
free(elf_interpreter);
}
out_free_file:
close(elf_exec_fileno);
out_free_ph:
free(elf_phdata);
goto out;
}
void load_setup (void)
{
static char *buffer;
char *profile;
char *inifile;
int i;
#ifdef USE_NETCODE
extern char *ftpfs_proxy_host;
#endif
buffer = concat_dir_and_file (home_dir, PROFILE_NAME);
inifile = concat_dir_and_file (mc_home, "mc.ini");
if (exist_file (buffer)){
profile = buffer;
} else if (exist_file (inifile)){
profile = strdup (inifile);
free (buffer);
} else {
profile = buffer;
}
free (inifile);
profile_name = profile;
/* Load integer boolean options */
for (i = 0; options [i].opt_name; i++)
*options [i].opt_addr =
get_int (profile, options [i].opt_name, *options [i].opt_addr);
load_layout (profile);
load_panelize ();
startup_left_mode = load_mode ("New Left Panel");
startup_right_mode = load_mode ("New Right Panel");
/* At least one of the panels is a listing panel */
if (startup_left_mode != view_listing && startup_right_mode!=view_listing)
startup_left_mode = view_listing;
if (!other_dir){
buffer = (char*) malloc (MC_MAXPATHLEN);
load_string ("Dirs", "other_dir", ".", buffer,
MC_MAXPATHLEN);
if (vfs_file_is_local (buffer))
other_dir = buffer;
else
free (buffer);
}
#ifdef USE_NETCODE
ftpfs_proxy_host = do_load_string ("Misc", "ftp_proxy_host", "gate");
#endif
boot_current_is_left =
GetPrivateProfileInt ("Dirs", "current_is_left", 1, profile);
load_string ("Misc", "find_ignore_dirs", "", setup_color_string,
sizeof (setup_color_string));
if (setup_color_string [0])
find_ignore_dirs = copy_strings (":", setup_color_string, ":", 0);
/* The default color and the terminal dependent color */
load_string ("Colors", "base_color", "", setup_color_string,
sizeof (setup_color_string));
load_string ("Colors", getenv ("TERM"), "",
term_color_string, sizeof (term_color_string));
load_string ("Colors", "color_terminals", "",
color_terminal_string, sizeof (color_terminal_string));
/* Load the directory history */
/* directory_history_load (); */
/* Remove the temporal entries */
profile_clean_section ("Temporal:New Left Panel", profile_name);
profile_clean_section ("Temporal:New Right Panel", profile_name);
#ifdef USE_VFS
#ifdef USE_NETCODE
ftpfs_init_passwd ();
#endif
#endif
}
asmlinkage int exe$creprc(unsigned int *pidadr, void *image, void *input, void *output, void *error, struct _generic_64 *prvadr, unsigned int *quota, void*prcnam, unsigned int baspri, unsigned int uic, unsigned short int mbxunt, unsigned int stsflg,...) {
unsigned long stack_here;
struct _pcb * p, * cur;
int retval;
struct dsc$descriptor * imd = image, * ind = input, * oud = output, * erd = error;
unsigned long clone_flags=CLONE_VFORK;
//check pidadr
ctl$gl_creprc_flags = stsflg;
// check for PRC$M_NOUAF sometime
if (stsflg&PRC$M_DETACH) {
}
if (uic) {
}
//setipl(IPL$_ASTDEL);//postpone this?
cur=ctl$gl_pcb;
vmslock(&SPIN_SCHED, IPL$_SCHED);
vmslock(&SPIN_MMG, IPL$_MMG);
p = alloc_task_struct();
//bzero(p,sizeof(struct _pcb));//not wise?
memset(p,0,sizeof(struct _pcb));
// check more
// compensate for no struct clone/copy
p->sigmask_lock = SPIN_LOCK_UNLOCKED;
p->alloc_lock = SPIN_LOCK_UNLOCKED;
qhead_init(&p->pcb$l_astqfl);
// and enable ast del to all modes
p->pcb$b_type = DYN$C_PCB;
p->pcb$b_asten=15;
p->phd$b_astlvl=4;
p->pr_astlvl=4;
p->psl=0;
p->pslindex=0;
qhead_init(&p->pcb$l_lockqfl);
// set capabilities
p->pcb$l_permanent_capability = sch$gl_default_process_cap;
p->pcb$l_capability = p->pcb$l_permanent_capability;
// set affinity
// set default fileprot
// set arb
// set mbx stuff
// from setprn:
if (prcnam) {
struct dsc$descriptor *s=prcnam;
strncpy(p->pcb$t_lname,s->dsc$a_pointer,s->dsc$w_length);
}
// set priv
p->pcb$l_priv=ctl$gl_pcb->pcb$l_priv;
// set pris
p->pcb$b_prib=31-baspri;
p->pcb$b_pri=31-baspri-6;
// if (p->pcb$b_pri<16) p->pcb$b_pri=16;
p->pcb$w_quant=-QUANTUM;
// set uic
p->pcb$l_uic=ctl$gl_pcb->pcb$l_uic;
// set vms pid
// check process name
// do something with pqb
p->pcb$l_pqb=kmalloc(sizeof(struct _pqb),GFP_KERNEL);
memset(p->pcb$l_pqb,0,sizeof(struct _pqb));
struct _pqb * pqb = p->pcb$l_pqb;
pqb->pqb$q_prvmsk = ctl$gq_procpriv;
if (imd)
memcpy(pqb->pqb$t_image,imd->dsc$a_pointer,imd->dsc$w_length);
if (ind)
memcpy(pqb->pqb$t_input,ind->dsc$a_pointer,ind->dsc$w_length);
if (oud)
memcpy(pqb->pqb$t_output,oud->dsc$a_pointer,oud->dsc$w_length);
if (erd)
memcpy(pqb->pqb$t_error,erd->dsc$a_pointer,erd->dsc$w_length);
if (oud) // temp measure
memcpy(p->pcb$t_terminal,oud->dsc$a_pointer,oud->dsc$w_length);
// translate some logicals
// copy security clearance
// copy msg
// copy flags
// set jib
// do quotas
// process itmlst
// set pcb$l_pqb
#if 0
setipl(IPL$_MMG);
vmslock(&SPIN_SCHED,-1);
// find vacant slot in pcb vector
// and store it
#endif
// make ipid and epid
p->pcb$l_pid=alloc_ipid();
{
unsigned long *vec=sch$gl_pcbvec;
vec[p->pcb$l_pid&0xffff]=p;
}
p->pcb$l_epid=exe$ipid_to_epid(p->pcb$l_pid);
// should invoke sch$chse, put this at bottom?
// setipl(0) and return
// now lots of things from fork
retval = -EAGAIN;
/*
* Check if we are over our maximum process limit, but be sure to
* exclude root. This is needed to make it possible for login and
* friends to set the per-user process limit to something lower
* than the amount of processes root is running. -- Rik
*/
#if 0
if (atomic_read(&p->user->processes) >= p->rlim[RLIMIT_NPROC].rlim_cur
&& !capable(CAP_SYS_ADMIN) && !capable(CAP_SYS_RESOURCE))
goto bad_fork_free;
atomic_inc(&p->user->__count);
atomic_inc(&p->user->processes);
#endif
/*
* Counter increases are protected by
* the kernel lock so nr_threads can't
* increase under us (but it may decrease).
*/
get_exec_domain(p->exec_domain);
if (p->binfmt && p->binfmt->module)
__MOD_INC_USE_COUNT(p->binfmt->module);
p->did_exec = 0;
p->swappable = 0;
p->state = TASK_UNINTERRUPTIBLE;
//copy_flags(clone_flags, p);
// not here? p->pcb$l_pid = alloc_ipid();
p->run_list.next = NULL;
p->run_list.prev = NULL;
p->p_cptr = NULL;
init_waitqueue_head(&p->wait_chldexit);
p->vfork_done = NULL;
spin_lock_init(&p->alloc_lock);
p->sigpending = 0;
init_sigpending(&p->pending);
p->it_real_value = p->it_virt_value = p->it_prof_value = 0;
p->it_real_incr = p->it_virt_incr = p->it_prof_incr = 0;
init_timer(&p->real_timer);
p->real_timer.data = (unsigned long) p;
p->leader = 0; /* session leadership doesn't inherit */
p->tty_old_pgrp = 0;
p->times.tms_utime = p->times.tms_stime = 0;
p->times.tms_cutime = p->times.tms_cstime = 0;
p->lock_depth = -1; /* -1 = no lock */
p->start_time = jiffies;
INIT_LIST_HEAD(&p->local_pages);
p->files = current->files;
p->fs = current->fs;
p->sig = current->sig;
/* copy all the process information */
if (copy_files(clone_flags, p))
goto bad_fork_cleanup;
if (copy_fs(clone_flags, p))
goto bad_fork_cleanup_files;
if (copy_sighand(clone_flags, p))
goto bad_fork_cleanup_fs;
bad_fork_cleanup:
bad_fork_cleanup_files:
bad_fork_cleanup_fs:
// now a hole
// now more from fork
/* ok, now we should be set up.. */
p->swappable = 1;
p->exit_signal = 0;
p->pdeath_signal = 0;
/*
* "share" dynamic priority between parent and child, thus the
* total amount of dynamic priorities in the system doesnt change,
* more scheduling fairness. This is only important in the first
* timeslice, on the long run the scheduling behaviour is unchanged.
*/
/*
* Ok, add it to the run-queues and make it
* visible to the rest of the system.
*
* Let it rip!
*/
retval = p->pcb$l_epid;
INIT_LIST_HEAD(&p->thread_group);
/* Need tasklist lock for parent etc handling! */
write_lock_irq(&tasklist_lock);
/* CLONE_PARENT and CLONE_THREAD re-use the old parent */
p->p_opptr = current->p_opptr;
p->p_pptr = current->p_pptr;
p->p_opptr = current /*->p_opptr*/;
p->p_pptr = current /*->p_pptr*/;
SET_LINKS(p);
nr_threads++;
write_unlock_irq(&tasklist_lock);
// printk("fork befwak\n");
//wake_up_process(p); /* do this last */
// wake_up_process2(p,PRI$_TICOM); /* do this last */
//goto fork_out;//??
// now something from exec
// wait, better do execve itself
memcpy(p->rlim, current->rlim, sizeof(p->rlim));
qhead_init(&p->pcb$l_sqfl);
struct mm_struct * mm = mm_alloc();
p->mm = mm;
p->active_mm = mm;
p->user = INIT_USER;
spin_lock(&mmlist_lock);
#if 0
list_add(&mm->mmlist, &p->p_pptr->mm->mmlist);
#endif
mmlist_nr++;
spin_unlock(&mmlist_lock);
// Now we are getting into the area that is really the swappers
// To be moved to shell.c and swp$shelinit later
p->pcb$l_phd=kmalloc(sizeof(struct _phd),GFP_KERNEL);
init_phd(p->pcb$l_phd);
init_fork_p1pp(p,p->pcb$l_phd,ctl$gl_pcb,ctl$gl_pcb->pcb$l_phd);
#ifdef __x86_64__
shell_init_other(p,ctl$gl_pcb,0x7ff80000-0x1000,0x7fffe000);
shell_init_other(p,ctl$gl_pcb,0x7ff80000-0x2000,0x7fffe000);
shell_init_other(p,ctl$gl_pcb,0x7ff90000-0x1000,0x7fffe000);
shell_init_other(p,ctl$gl_pcb,0x7ff90000-0x2000,0x7fffe000);
shell_init_other(p,ctl$gl_pcb,0x7ffa0000-0x1000,0x7fffe000);
shell_init_other(p,ctl$gl_pcb,0x7ffa0000-0x2000,0x7fffe000);
#else
shell_init_other(p,ctl$gl_pcb,0x7ff80000-0x1000,0x7fffe000);
shell_init_other(p,ctl$gl_pcb,0x7ff80000-0x2000,0x7fffe000);
shell_init_other(p,ctl$gl_pcb,0x7ff90000-0x1000,0x7fffe000);
shell_init_other(p,ctl$gl_pcb,0x7ff90000-0x2000,0x7fffe000);
#endif
int exe$procstrt(struct _pcb * p);
struct pt_regs * regs = &pidadr;
//printk("newthread %x\n",p),
retval = new_thread(0, clone_flags, 0, 0, p, 0);
int eip=0,esp=0;
// start_thread(regs,eip,esp);
sch$chse(p, PRI$_TICOM);
vmsunlock(&SPIN_MMG,-1);
vmsunlock(&SPIN_SCHED,0);
return SS$_NORMAL;
#if 0
return sys_execve(((struct dsc$descriptor *)image)->dsc$a_pointer,0,0);
return SS$_NORMAL;
#endif
#if 0
{
char * filename=((struct dsc$descriptor *)image)->dsc$a_pointer;
char ** argv=0;
char ** envp=0;
struct pt_regs * regs=0;
struct linux_binprm bprm;
struct file *file;
int retval;
int i;
file = open_exec(filename);
retval = PTR_ERR(file);
if (IS_ERR(file))
return retval;
bprm.p = PAGE_SIZE*MAX_ARG_PAGES-sizeof(void *);
memset(bprm.page, 0, MAX_ARG_PAGES*sizeof(bprm.page[0]));
bprm.file = file;
bprm.filename = filename;
bprm.sh_bang = 0;
bprm.loader = 0;
bprm.exec = 0;
if ((bprm.argc = count(argv, bprm.p / sizeof(void *))) < 0) {
allow_write_access(file);
fput(file);
//printk("here 7 %x\n",bprm.argc);
return bprm.argc;
}
if ((bprm.envc = count(envp, bprm.p / sizeof(void *))) < 0) {
allow_write_access(file);
fput(file);
//printk("here 6\n");
return bprm.envc;
}
retval = prepare_binprm(&bprm);
//printk("here 4\n");
if (retval < 0)
goto out;
retval = copy_strings_kernel(1, &bprm.filename, &bprm);
//printk("here 3\n");
if (retval < 0)
goto out;
bprm.exec = bprm.p;
retval = copy_strings(bprm.envc, envp, &bprm);
//printk("here 2\n");
if (retval < 0)
goto out;
retval = copy_strings(bprm.argc, argv, &bprm);
//printk("here 1\n");
if (retval < 0)
goto out;
retval = search_binary_handler(&bprm,regs);
if (retval >= 0)
/* execve success */
return retval;
out:
/* Something went wrong, return the inode and free the argument pages*/
allow_write_access(bprm.file);
if (bprm.file)
fput(bprm.file);
for (i = 0 ; i < MAX_ARG_PAGES ; i++) {
struct page * page = bprm.page[i];
if (page)
__free_page(page);
}
return retval;
}
#endif
fork_out:
return retval;
bad_fork_free:
free_task_struct(p);
goto fork_out;
}
int main()
{
void display_help();
void get_strings();
char *search_strings();
void copy_strings();
void display_results();
char str1[32], str2[4], str3[8], str4[1024];
char *ptr1, *ptr2, *ptr3;
char *start_ptr, *match_ptr, *copy_ptr;
int match_ctr;
ptr1 = ptr2 = ptr3 = NULL;
start_ptr = match_ptr = copy_ptr = NULL;
match_ctr = 0;
display_help();
get_strings( str1, str2, str3 );
ptr1 = str1;
ptr2 = str2;
ptr3 = str3;
start_ptr = str1;
copy_ptr = str4;
// TO DO: while( *start_ptr != '\0' )
while( start_ptr <= ( str1 + strlen( str1 ) ) )
{
if( debug_flag == 1 )
printf( "\n START ptr = %c", *start_ptr );
match_ptr = search_strings( str1, str2, start_ptr );
if( match_ptr )
{
match_ctr ++;
if( debug_flag == 1 )
printf( "\n if - MATCH ctr %d: need to start copy/replace", match_ctr );
// RESULT STRING: copy from archive string start location to match location
copy_strings( start_ptr, match_ptr, str4, copy_ptr );
copy_ptr += match_ptr - start_ptr;
// RESULT STRING: copy entire replacement string, i.e. replace query string
copy_strings( ptr3, ptr3 + strlen( str3 ), str4, copy_ptr );
if( debug_flag == 1 )
printf( "\n MATCH: RESULT STR4: %s", str4 );
start_ptr = match_ptr + strlen(str2);
copy_ptr += strlen( str3 );
if( debug_flag == 1 )
printf( "\n continue searching from %c", *start_ptr );
}
else
{
if( debug_flag == 1 )
printf("\n else - match ctr = %d", match_ctr);
if( match_ctr != 0)
{
// RESULT STRING: copy from archive string last match location until end
if( debug_flag == 1 )
printf( "\n NO MATCH: copy from last match start ptr %c until end", *start_ptr );
copy_strings( start_ptr, str1 + strlen( str1 ), str4, copy_ptr );
if( debug_flag == 1 )
printf( "\n NO MATCH: RESULT STR4: %s", str4 );
break;
}
else
{
strcpy( str4, "The archive string does not contain the query string." );
break;
}
start_ptr ++;
}
}
display_results( str1, str2, str3, str4 );
return 0;
} // end main()
