static char * get_cert_file(char * email)
{
return get_file(certificates, email);
}
main(int argc, char *argv[])
{
int ch,err,notdone,vowflag,initflag;
errorcount=0;
switcher='~';
true=1;
false=0;
tamilflag=false;
tdelim=1; /* i.e. control-a ::: if yah don't like it, change it */
tspace[0]=tdelim;
tspace[1]=' ';
haccbox();
vowflag=0;
if (argc > 1) input = fopen(argv[1],"rb");
if (input == (FILE *) NULL) {
/* prompt for and open input file */
for ( ; input == (FILE *) NULL ; input=get_file("rb","Enter name of input file: ")) ;
}
/* we are making these binary, as we have no guarantee what kind */
/* of character may be in the transcription: we don't care about */
/* ends of lines, as we are reading character by character */
if (argc > 2) output = fopen(argv[2],"wb");
if (output == (FILE *) NULL) {
for ( ; output == (FILE *) NULL ; output=get_file("wb","Enter name of output file: ")) ;
/* prompt for and open output file */
}
while ((ch = getc(input)) != EOF) {
if (ch == switcher) changestate();
else {
if (ch == '|') {
vowflag=1;
notdone=1;
initflag=2;
while (notdone) {
ch=getc(input);
if (isalnum(ch)) {
initflag--;
if (vowflag==0) {
if (! isvowel(ch)) stringout("\\-");
}
if (isvowel(ch)) vowflag=1;
else vowflag=0;
}
else {
vowflag=1;
initflag=2;
}
if (ch==EOF) notdone=0;
else {
switch(ch) {
case '2': stringout("\\ndot{}");
break;
case '3': stringout("\\nndot{}");
break;
case '4': stringout("\\skts{}");
break;
case '5': stringout("\\paln{}");
break;
case '6': stringout("\\rdot{}");
break;
case '7': stringout("\\rdotdot{}");
break;
case 'T': stringout("\\tdot{}");
break;
case 'D': stringout("\\dotd{}");
break;
case '8':
if ( initflag > 0 ) stringout("\\tdot{}");
else {
err=getc(input);
if (err == '8') stringout("\\tdot{}\\tdot{}");
else {
stringout("\\dotd{}");
pushback(err);
}
}
break;
case '9': stringout("\\dotl{}");
break;
case '|': notdone=0;
break;
default: putc(ch,output);
} /* endcase */
} /* end else */
} /* endwhile */
} /* endif */
else putc(ch,output);
} /* endelse */
} /* endwhile */
fclose(input);
fclose(output);
puts("Tamilize is done.");
}
int main(int argc, char **argv){
Buffer_Set buffers;
File_Data file;
float *widths_data;
float *wrap_ys;
float font_height;
float max_width;
void *scratch;
int scratch_size;
Stats_Log log;
int do_replay = 0;
char *replay_filename = 0;
if (argc < 2){
printf("usage: buffer_test <filename> <message> [-h <.hst file>]\n");
exit(1);
}
setup();
for (int i = 3; i < argc; ++i){
if (do_replay){
replay_filename = argv[i];
do_replay = 0;
}
if (strcmp(argv[i], "-h") == 0){
if (replay_filename != 0){
printf("found -h twice, ignoring duplicates\n");
}
else{
do_replay = 1;
}
}
}
do_replay = (replay_filename != 0);
memzero_4tech(buffers);
log.max = 1 << 20;
log.size = 0;
log.out = (char*)malloc(log.max);
log.sec_max = 32;
log.sec_top = 0;
log.sections = (Log_Section*)malloc(sizeof(Log_Section)*log.sec_max);
log.error = 0;
scratch_size = 1 << 20;
scratch = malloc(scratch_size);
file = get_file(argv[1]);
if (!file.data) exit(1);
widths_data = get_font_data("LiberationSans-Regular.ttf", &font_height);
max_width = 500.f;
log_begin_section(&log, litstr("which-test"));
{
log_write_str(&log, argv[1], (int)strlen(argv[1]));
log_write_int(&log, file.size);
log_write_str(&log, argv[2], (int)strlen(argv[2]));
}
log_end_section(&log);
log_begin_section(&log, litstr("file-open"));
{
Record_Statistics init_rec, starts_widths_rec, wraps_rec;
initialization_test(&log, &buffers, file, reps, scratch, scratch_size, &init_rec);
stream_check_test(&buffers, scratch, scratch_size);
measure_starts_widths_test(&log, &buffers, reps, scratch, scratch_size,
&starts_widths_rec, widths_data);
measure_check_test(&buffers);
wrap_ys = measure_wraps_test(&log, &buffers, reps, scratch, scratch_size,
&wraps_rec, font_height, max_width);
Time_Record expected_file_open;
expected_file_open = init_rec.expected + starts_widths_rec.expected + wraps_rec.expected;
printf("average file open:\n");
print_record(expected_file_open);
printf("\n");
log_time_record(&log, litstr("average"), expected_file_open);
}
log_end_section(&log);
log_begin_section(&log, litstr("cursor-seek"));
{
Record_Statistics full_cursor;
Time_Record full_cursor_average;
log_begin_section(&log, litstr("to-pos"));
{
memzero_4tech(full_cursor_average);
for (int i = 0; i < 5; ++i){
silence_test();
int pos = (file.size*i) / 5;
full_cursor_test(&log, &buffers, pos,
wrap_ys, widths_data, font_height, max_width,
5, scratch, scratch_size, &full_cursor);
full_cursor_average = full_cursor_average + full_cursor.expected;
}
full_cursor_average /= 5;
printf("average cursor from position:\n");
print_record(full_cursor_average);
printf("\n");
log_time_record(&log, litstr("average"), full_cursor_average);
}
log_end_section(&log);
log_begin_section(&log, litstr("to-line-character"));
{
memzero_4tech(full_cursor_average);
for (int i = 0; i < 5; ++i){
silence_test();
int line = (buffers.buffer.line_count*i) / 5;
full_cursor_line_test(&log, &buffers, line, 20,
wrap_ys, widths_data, font_height, max_width,
5, scratch, scratch_size, &full_cursor);
full_cursor_average = full_cursor_average + full_cursor.expected;
}
full_cursor_average /= 5;
printf("average cursor from line & character:\n");
print_record(full_cursor_average);
printf("\n");
log_time_record(&log, litstr("average"), full_cursor_average);
}
log_end_section(&log);
log_begin_section(&log, litstr("to-unwrapped-x-y"));
{
memzero_4tech(full_cursor_average);
for (int i = 0; i < 5; ++i){
silence_test();
float y = font_height * (buffers.buffer.line_count*i) / 4.f;
full_cursor_xy_test(&log, &buffers, y, 37.f, 0,
wrap_ys, widths_data, font_height, max_width,
5, scratch, scratch_size, &full_cursor);
full_cursor_average = full_cursor_average + full_cursor.expected;
}
full_cursor_average /= 5;
printf("average cursor from line & character:\n");
print_record(full_cursor_average);
printf("\n");
log_time_record(&log, litstr("average"), full_cursor_average);
}
log_end_section(&log);
}
log_end_section(&log);
log_begin_section(&log, litstr("word-seek"));
{
Record_Statistics word_seek;
{
char word[] = "not-going-to-find-this";
int word_len = sizeof(word) - 1;
word_seek_test(&log, &buffers, reps, 0, word, word_len, scratch, scratch_size, &word_seek);
}
{
char word[] = "return";
int word_len = sizeof(word) - 1;
word_seek_test(&log, &buffers, reps, 1, word, word_len, scratch, scratch_size, &word_seek);
printf("average normal word seek:\n");
print_record(word_seek.expected);
printf("\n");
}
}
log_end_section(&log);
log_begin_section(&log, litstr("one-hundred-single-edits"));
{
Record_Statistics edits;
insert_bottom_test(&log, &buffers, reps, widths_data, 100, scratch, scratch_size, &edits);
insert_top_test(&log, &buffers, reps, widths_data, 100, scratch, scratch_size, &edits);
delete_bottom_test(&log, &buffers, reps, widths_data, 100, scratch, scratch_size, &edits);
delete_top_test(&log, &buffers, reps, widths_data, 100, scratch, scratch_size, &edits);
}
log_end_section(&log);
File_Data replay_file = {};
Replay replay;
if (do_replay){
replay_file = get_file(replay_filename);
prepare_replay(replay_file, &replay);
}
if (replay_file.data){
log_begin_section(&log, litstr("natural-edits"));
{
Record_Statistics edits;
natural_edits_test(&log, &buffers, reps, widths_data, &replay,
scratch, scratch_size, &edits);
}
log_end_section(&log);
}
else{
printf("skipped natural-edits test\n\n");
}
log_begin_section(&log, litstr("batch-edit"));
{
Buffer_Edit *batch;
char *str_base;
int batch_size, str_size;
batch_size = 1000;
str_size = 10000;
batch = (Buffer_Edit*)malloc(sizeof(Buffer_Edit)*batch_size);
str_base = (char*)malloc(str_size);
int character_stride;
character_stride = buffer_size(&buffers.buffer);
if (character_stride < batch_size * 10){
batch_size = character_stride / 10;
character_stride = 10;
}
else{
character_stride = (character_stride / batch_size);
}
int p, curs;
curs = 0;
p = 0;
for (int i = 0; i < batch_size; ++i){
Buffer_Edit edit;
edit.start = p;
edit.end = p+8;
p += character_stride;
edit.str_start = curs;
if (i & 1){
edit.len = 9;
memcpy_4tech(str_base + curs, "123456789", 9);
curs += 9;
}
else{
edit.len = 7;
memcpy_4tech(str_base + curs, "abcdefg", 7);
curs += 7;
}
batch[i] = edit;
}
Record_Statistics batch_stats;
batch_edit_test(&log, &buffers, reps, widths_data, batch, str_base, batch_size,
scratch, scratch_size, &batch_stats);
}
log_end_section(&log);
log_finish(&log);
return(0);
}
/* Looks at the RVA/Size pairs in the PE header and creates an SgAsmGenericSection object for each one. This must be done
* after we build the mapping from virtual addresses to file offsets. */
void
SgAsmPEFileHeader::create_table_sections()
{
/* First, only create the sections. */
for (size_t i=0; i<p_rvasize_pairs->get_pairs().size(); i++) {
SgAsmPERVASizePair *pair = p_rvasize_pairs->get_pairs()[i];
if (0==pair->get_e_size())
continue;
/* Table names come from PE file specification and are hard coded by RVA/Size pair index */
const char *tabname_short;
std::string tabname = rvasize_pair_name((PairPurpose)i, &tabname_short);
/* Find the starting offset in the file.
* FIXME: We have a potential problem here in that ROSE sections are always contiguous in the file but a section created
* from an RVA/Size pair is not necessarily contiguous in the file. Normally such sections are in fact
* contiguous and we'll just ignore this for now. In any case, as long as these sections only ever read their
* data via the same MemoryMap that we use here, everything should be fine. [RPM 2009-08-17] */
MemoryMap *map = get_loader_map();
ROSE_ASSERT(map!=NULL);
const MemoryMap::MapElement *elmt = map->find(get_base_va() + pair->get_e_rva());
if (!elmt) {
fprintf(stderr, "SgAsmPEFileHeader::create_table_sections: warning: pair-%zu, rva=0x%08"PRIx64", size=%"PRIu64
" bytes \"%s\": unable to find a mapping for the virtual address (skipping)\n",
i, pair->get_e_rva().get_rva(), pair->get_e_size(), tabname.c_str());
continue;
}
rose_addr_t file_offset = elmt->is_anonymous() ? 0 : elmt->get_va_offset(get_base_va() + pair->get_e_rva(), 1);
/* Create the new section */
SgAsmGenericSection *tabsec = NULL;
switch (i) {
case 0: {
/* Sometimes export sections are represented by a ".edata" section, and sometimes they're represented by an
* RVA/Size pair, and sometimes both point to the same part of the file. We don't want the exports duplicated
* in the AST, so we only create this table as exports if we haven't already seen some other export section. */
SgAsmGenericSectionPtrList §ions = get_sections()->get_sections();
bool seen_exports = false;
for (SgAsmGenericSectionPtrList::iterator si=sections.begin(); !seen_exports && si!=sections.end(); ++si)
seen_exports = isSgAsmPEExportSection(*si);
if (seen_exports) {
tabsec = new SgAsmGenericSection(get_file(), this);
} else {
tabsec = new SgAsmPEExportSection(this);
}
break;
}
case 1: {
/* Sometimes import sections are represented by a ".idata" section, and sometimes they're represented by an
* RVA/Size pair, and sometimes both point to the same part of the file. We don't want the imports duplicated
* in the AST, so we only create this table as imports if we haven't already seen some other import section. */
SgAsmGenericSectionPtrList §ions = get_sections()->get_sections();
bool seen_imports = false;
for (SgAsmGenericSectionPtrList::iterator si=sections.begin(); !seen_imports && si!=sections.end(); ++si)
seen_imports = isSgAsmPEImportSection(*si);
if (seen_imports) {
tabsec = new SgAsmGenericSection(get_file(), this);
} else {
tabsec = new SgAsmPEImportSection(this);
}
break;
}
default: {
tabsec = new SgAsmGenericSection(get_file(), this);
break;
}
}
tabsec->set_name(new SgAsmBasicString(tabname));
tabsec->set_short_name(tabname_short);
tabsec->set_synthesized(true);
tabsec->set_purpose(SP_HEADER);
tabsec->set_offset(file_offset);
tabsec->set_size(pair->get_e_size());
tabsec->set_file_alignment(1);
tabsec->set_mapped_alignment(1);
tabsec->set_mapped_preferred_rva(pair->get_e_rva().get_rva());
tabsec->set_mapped_actual_va(pair->get_e_rva().get_rva()+get_base_va()); /*FIXME: not sure this is correct. [RPM 2009-09-11]*/
tabsec->set_mapped_size(pair->get_e_size());
tabsec->set_mapped_rperm(true);
tabsec->set_mapped_wperm(false);
tabsec->set_mapped_xperm(false);
pair->set_section(tabsec);
pair->set_e_rva(pair->get_e_rva().set_section(tabsec));
}
/* Now parse the sections */
for (size_t i=0; i<p_rvasize_pairs->get_pairs().size(); i++) {
SgAsmPERVASizePair *pair = p_rvasize_pairs->get_pairs()[i];
SgAsmGenericSection *tabsec = pair->get_section();
if (tabsec)
tabsec->parse();
}
}
void scm_detach_fds(struct msghdr *msg, struct scm_cookie *scm)
{
struct cmsghdr __user *cm
= (__force struct cmsghdr __user*)msg->msg_control;
int fdmax = 0;
int fdnum = scm->fp->count;
struct file **fp = scm->fp->fp;
int __user *cmfptr;
int err = 0, i;
if (MSG_CMSG_COMPAT & msg->msg_flags) {
scm_detach_fds_compat(msg, scm);
return;
}
if (msg->msg_controllen > sizeof(struct cmsghdr))
fdmax = ((msg->msg_controllen - sizeof(struct cmsghdr))
/ sizeof(int));
if (fdnum < fdmax)
fdmax = fdnum;
for (i=0, cmfptr=(__force int __user *)CMSG_DATA(cm); i<fdmax;
i++, cmfptr++)
{
int new_fd;
err = security_file_receive(fp[i]);
if (err)
break;
err = get_unused_fd_flags(MSG_CMSG_CLOEXEC & msg->msg_flags
? O_CLOEXEC : 0);
if (err < 0)
break;
new_fd = err;
err = put_user(new_fd, cmfptr);
if (err) {
put_unused_fd(new_fd);
break;
}
/* Bump the usage count and install the file. */
get_file(fp[i]);
fd_install(new_fd, fp[i]);
}
if (i > 0)
{
int cmlen = CMSG_LEN(i*sizeof(int));
err = put_user(SOL_SOCKET, &cm->cmsg_level);
if (!err)
err = put_user(SCM_RIGHTS, &cm->cmsg_type);
if (!err)
err = put_user(cmlen, &cm->cmsg_len);
if (!err) {
cmlen = CMSG_SPACE(i*sizeof(int));
msg->msg_control += cmlen;
msg->msg_controllen -= cmlen;
}
}
if (i < fdnum || (fdnum && fdmax <= 0))
msg->msg_flags |= MSG_CTRUNC;
/*
* All of the files that fit in the message have had their
* usage counts incremented, so we just free the list.
*/
__scm_destroy(scm);
}
load_file (char *filename, bool initial)
{
char *line;
gfc_linebuf *b;
gfc_file *f;
FILE *input;
int len, line_len;
for (f = current_file; f; f = f->up)
if (strcmp (filename, f->filename) == 0)
{
gfc_error_now ("File '%s' is being included recursively", filename);
return FAILURE;
}
if (initial)
{
input = gfc_open_file (filename);
if (input == NULL)
{
gfc_error_now ("Can't open file '%s'", filename);
return FAILURE;
}
}
else
{
input = gfc_open_included_file (filename, false);
if (input == NULL)
{
gfc_error_now ("Can't open included file '%s'", filename);
return FAILURE;
}
}
/* Load the file. */
f = get_file (filename, initial ? LC_RENAME : LC_ENTER);
f->up = current_file;
current_file = f;
current_file->line = 1;
line = NULL;
line_len = 0;
for (;;)
{
int trunc = load_line (input, &line, &line_len);
len = strlen (line);
if (feof (input) && len == 0)
break;
/* There are three things this line can be: a line of Fortran
source, an include line or a C preprocessor directive. */
if (line[0] == '#')
{
preprocessor_line (line);
continue;
}
if (include_line (line))
{
current_file->line++;
continue;
}
/* Add line. */
b = gfc_getmem (gfc_linebuf_header_size + len + 1);
#ifdef USE_MAPPED_LOCATION
b->location
= linemap_line_start (&line_table, current_file->line++, 120);
#else
b->linenum = current_file->line++;
#endif
b->file = current_file;
b->truncated = trunc;
strcpy (b->line, line);
if (line_head == NULL)
line_head = b;
else
line_tail->next = b;
line_tail = b;
}
/* Release the line buffer allocated in load_line. */
gfc_free (line);
fclose (input);
current_file = current_file->up;
#ifdef USE_MAPPED_LOCATION
linemap_add (&line_table, LC_LEAVE, 0, NULL, 0);
#endif
return SUCCESS;
}
static inline int dup_mmap(struct mm_struct * mm, struct mm_struct * oldmm)
{
struct vm_area_struct * mpnt, *tmp, **pprev;
struct rb_node **rb_link, *rb_parent;
int retval;
unsigned long charge;
struct mempolicy *pol;
down_write(&oldmm->mmap_sem);
flush_cache_mm(current->mm);
mm->locked_vm = 0;
mm->mmap = NULL;
mm->mmap_cache = NULL;
mm->free_area_cache = oldmm->mmap_base;
mm->map_count = 0;
mm->rss = 0;
mm->anon_rss = 0;
cpus_clear(mm->cpu_vm_mask);
mm->mm_rb = RB_ROOT;
rb_link = &mm->mm_rb.rb_node;
rb_parent = NULL;
pprev = &mm->mmap;
for (mpnt = current->mm->mmap ; mpnt ; mpnt = mpnt->vm_next) {
struct file *file;
if (mpnt->vm_flags & VM_DONTCOPY) {
__vm_stat_account(mm, mpnt->vm_flags, mpnt->vm_file,
-vma_pages(mpnt));
continue;
}
charge = 0;
if (mpnt->vm_flags & VM_ACCOUNT) {
unsigned int len = (mpnt->vm_end - mpnt->vm_start) >> PAGE_SHIFT;
if (security_vm_enough_memory(len))
goto fail_nomem;
charge = len;
}
tmp = kmem_cache_alloc(vm_area_cachep, SLAB_KERNEL);
if (!tmp)
goto fail_nomem;
*tmp = *mpnt;
pol = mpol_copy(vma_policy(mpnt));
retval = PTR_ERR(pol);
if (IS_ERR(pol))
goto fail_nomem_policy;
vma_set_policy(tmp, pol);
tmp->vm_flags &= ~VM_LOCKED;
tmp->vm_mm = mm;
tmp->vm_next = NULL;
anon_vma_link(tmp);
file = tmp->vm_file;
if (file) {
struct inode *inode = file->f_dentry->d_inode;
get_file(file);
if (tmp->vm_flags & VM_DENYWRITE)
atomic_dec(&inode->i_writecount);
/* insert tmp into the share list, just after mpnt */
spin_lock(&file->f_mapping->i_mmap_lock);
tmp->vm_truncate_count = mpnt->vm_truncate_count;
flush_dcache_mmap_lock(file->f_mapping);
vma_prio_tree_add(tmp, mpnt);
flush_dcache_mmap_unlock(file->f_mapping);
spin_unlock(&file->f_mapping->i_mmap_lock);
}
/*
* Link in the new vma and copy the page table entries:
* link in first so that swapoff can see swap entries,
* and try_to_unmap_one's find_vma find the new vma.
*/
spin_lock(&mm->page_table_lock);
*pprev = tmp;
pprev = &tmp->vm_next;
__vma_link_rb(mm, tmp, rb_link, rb_parent);
rb_link = &tmp->vm_rb.rb_right;
rb_parent = &tmp->vm_rb;
mm->map_count++;
retval = copy_page_range(mm, current->mm, tmp);
spin_unlock(&mm->page_table_lock);
if (tmp->vm_ops && tmp->vm_ops->open)
tmp->vm_ops->open(tmp);
if (retval)
goto out;
}
/** Check if a stream has an error.
*
* @param s file stream
* @return 1 if has an error, 0 otherwise
*/
static int file_error(IOStream *s){
return ferror(get_file(s));
}
/** Close a file stream.
*
* @param s file stream to close
* @return result of the close
*/
static int file_close(IOStream *s){
int result = 0;
result = fclose(get_file(s));
return result;
}
/** Read from the underlying stream using fread();
*
* @param stream input
* @param buf where to put input
* @param n number of bytes to read
* @return number of bytes read
*/
static int file_read(IOStream *s, void *buf, size_t n){
return fread(buf, 1, n, get_file(s));
}
/** Fush the underlying stream using fflush().
*
* @param s file stream
* @return 0 on success, error code otherwise
*/
static int file_flush(IOStream *s){
return fflush(get_file(s));
}
/** Write to the underlying stream using fwrite();
*
* @param stream input
* @param buf where to put input
* @param n number of bytes to write
* @return number of bytes written
*/
static int file_write(IOStream *s, const void *buf, size_t n){
return fwrite(buf, 1, n, get_file(s));
}
/** Control buffering on the underlying stream, like setvbuf().
*
* @param io file stream
* @param buf buffer
* @param mode buffering mode (see man setvbuf())
* @param size buffer size
* @return 0 on success, non-zero otherwise
*/
int file_stream_setvbuf(IOStream *io, char *buf, int mode, size_t size){
return setvbuf(get_file(io), buf, mode, size);
}
static char * get_private_key_file(char * email)
{
return get_file(private_keys, email);
}
/**
* Hack -- change name
*/
void do_cmd_change_name(void)
{
ui_event ke;
int mode = 0;
const char *p;
bool more = true;
/* Prompt */
p = "['c' to change name, 'f' to file, 'h' to change mode, or ESC]";
/* Save screen */
screen_save();
/* Forever */
while (more) {
/* Display the player */
display_player(mode);
/* Prompt */
Term_putstr(2, 23, -1, COLOUR_WHITE, p);
/* Query */
ke = inkey_ex();
if ((ke.type == EVT_KBRD)||(ke.type == EVT_BUTTON)) {
switch (ke.key.code) {
case ESCAPE: more = false; break;
case 'c': {
if(arg_force_name)
msg("You are not allowed to change your name!");
else {
char namebuf[32] = "";
/* Set player name */
if (get_character_name(namebuf, sizeof namebuf))
my_strcpy(player->full_name, namebuf,
sizeof(player->full_name));
}
break;
}
case 'f': {
char buf[1024];
char fname[80];
/* Get the filesystem-safe name and append .txt */
player_safe_name(fname, sizeof(fname), player->full_name, false);
my_strcat(fname, ".txt", sizeof(fname));
if (get_file(fname, buf, sizeof buf)) {
if (dump_save(buf))
msg("Character dump successful.");
else
msg("Character dump failed!");
}
break;
}
case 'h':
case ARROW_LEFT:
case ' ':
mode = (mode + 1) % INFO_SCREENS;
break;
case 'l':
case ARROW_RIGHT:
mode = (mode - 1) % INFO_SCREENS;
break;
}
} else if (ke.type == EVT_MOUSE) {
if (ke.mouse.button == 1) {
/* Flip through the screens */
mode = (mode + 1) % INFO_SCREENS;
} else if (ke.mouse.button == 2) {
/* exit the screen */
more = false;
} else {
/* Flip backwards through the screens */
mode = (mode - 1) % INFO_SCREENS;
}
}
/* Flush messages */
event_signal(EVENT_MESSAGE_FLUSH);
}
/* Load screen */
screen_load();
}
G_MODULE_EXPORT gboolean create_warning_span_event(GtkWidget * widget, gpointer data)
{
GtkBuilder *warnings;
GtkWidget *dialog = NULL;
GtkWidget *spinner = NULL;
GtkWidget *tmpwidget = NULL;
GtkWidget *cbutton = NULL;
MtxWarningRange *range = NULL;
gfloat lbound = 0.0;
gfloat ubound = 0.0;
gchar * filename = NULL;
gint result = 0;
GError *error = NULL;
gchar *pathstub = NULL;
if (!GTK_IS_WIDGET(gauge))
return FALSE;
pathstub = g_build_filename(GAUGEDESIGNER_GLADE_DIR,"w_range.ui",NULL);
filename = get_file(NULL,pathstub,NULL);
g_free(pathstub);
if (filename)
{
warnings = gtk_builder_new();
if(!gtk_builder_add_from_file(warnings,filename,&error))
{
g_warning ("Couldn't load builder file: %s", error->message);
g_error_free(error);
exit(-1);
}
g_free(filename);
}
else
{
printf("Can't locate primary ui file!!!!\n");
exit(-1);
}
gtk_builder_connect_signals(warnings,NULL);
dialog = GTK_WIDGET (gtk_builder_get_object(warnings,"w_range_dialog"));
cbutton = GTK_WIDGET (gtk_builder_get_object(warnings,"range_day_colorbutton"));
gtk_color_button_set_color(GTK_COLOR_BUTTON(cbutton),&white);
cbutton = GTK_WIDGET (gtk_builder_get_object(warnings,"range_nite_colorbutton"));
gtk_color_button_set_color(GTK_COLOR_BUTTON(cbutton),&black);
if (!GTK_IS_WIDGET(dialog))
{
return FALSE;
}
/* Set the controls to sane ranges corresponding to the gauge */
mtx_gauge_face_get_attribute(MTX_GAUGE_FACE(gauge), LBOUND, &lbound);
mtx_gauge_face_get_attribute(MTX_GAUGE_FACE(gauge), UBOUND, &ubound);
spinner = GTK_WIDGET (gtk_builder_get_object(warnings,"range_lowpoint_spin"));
OBJ_SET(spinner,"builder",warnings);
gtk_spin_button_set_range(GTK_SPIN_BUTTON(spinner),lbound,ubound);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(spinner),(ubound-lbound)/2.0);
spinner = GTK_WIDGET (gtk_builder_get_object(warnings,"range_highpoint_spin"));
OBJ_SET(spinner,"builder",warnings);
gtk_spin_button_set_range(GTK_SPIN_BUTTON(spinner),lbound,ubound);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(spinner),ubound);
result = gtk_dialog_run(GTK_DIALOG(dialog));
switch (result)
{
case GTK_RESPONSE_APPLY:
range = g_new0(MtxWarningRange, 1);
range->lowpoint = gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(warnings,"range_lowpoint_spin")));
range->highpoint = gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(warnings,"range_highpoint_spin")));
range->inset = gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(warnings,"range_inset_spin")));
range->lwidth = gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(warnings,"range_lwidth_spin")));
gtk_color_button_get_color(GTK_COLOR_BUTTON(gtk_builder_get_object(warnings,"range_day_colorbutton")),&range->color[MTX_DAY]);
gtk_color_button_get_color(GTK_COLOR_BUTTON(gtk_builder_get_object(warnings,"range_nite_colorbutton")),&range->color[MTX_NITE]);
changed = TRUE;
mtx_gauge_face_set_warning_range_struct(MTX_GAUGE_FACE(gauge),range);
g_free(range);
update_onscreen_w_ranges();
break;
default:
break;
}
if (GTK_IS_WIDGET(dialog))
gtk_widget_destroy(dialog);
return (FALSE);
}
int
main (int argc, char **argv)
{
int res = 0, i, next_option, undelete = 0;
int flags = 0;
fosfat_disk_t type = FOSFAT_AD;
char *device = NULL, *mode = NULL, *node = NULL, *path = NULL;
fosfat_t *fosfat;
global_info_t *ginfo = NULL;
const char *const short_options = "afhluv";
const struct option long_options[] = {
{ "harddisk", no_argument, NULL, 'a' },
{ "floppydisk", no_argument, NULL, 'f' },
{ "help", no_argument, NULL, 'h' },
{ "fos-logger", no_argument, NULL, 'l' },
{ "undelete", no_argument, NULL, 'u' },
{ "version", no_argument, NULL, 'v' },
{ NULL, 0, NULL, 0 }
};
/* check options */
do
{
next_option = getopt_long (argc, argv, short_options, long_options, NULL);
switch (next_option)
{
default : /* unknown */
case '?': /* invalid option */
case 'h': /* -h or --help */
print_info ();
return -1;
case 'v': /* -v or --version */
print_version ();
return -1;
case 'a': /* -a or --harddisk */
type = FOSFAT_HD;
break ;
case 'f': /* -f or --floppydisk */
type = FOSFAT_FD;
break ;
case 'l': /* -l or --fos-logger */
fosfat_logger (1);
break ;
case 'u': /* -u or --undelete */
undelete = 1;
break ;
case -1: /* end */
break ;
}
} while (next_option != -1);
if (argc < optind + 2)
{
print_info ();
return -1;
}
for (i = optind; i < argc; i++)
{
if (i == optind)
device = strdup (argv[optind]);
else if (i == optind + 1)
mode = strdup (argv[optind + 1]);
else if (i == optind + 2)
node = strdup (argv[optind + 2]);
else if (i == optind + 3)
path = strdup (argv[optind + 3]);
}
if (undelete)
flags = F_UNDELETE;
/* Open the floppy disk (or hard disk) */
if (!(fosfat = fosfat_open (device, type, flags)))
{
fprintf (stderr, "Could not open %s for reading!\n", device);
res = -1;
}
/* Get globals informations on the disk */
if (!res && (ginfo = get_ginfo (fosfat)))
{
printf ("Smaky disk %s\n", ginfo->name);
/* Show the list of a directory */
if (!strcasecmp (mode, "list"))
{
if (!node)
{
if (!list_dir (fosfat, "/"))
res = -1;
}
else if (node)
{
if (!list_dir (fosfat, node))
res = -1;
free (node);
}
}
/* Get a file from the disk */
else if (!strcmp (mode, "get") && node)
{
get_file (fosfat, node, path ? path : "./");
free (node);
free (path);
}
else
print_info ();
free (ginfo);
}
/* Close the disk */
fosfat_close (fosfat);
free (device);
free (mode);
return res;
}
int main(int argc, char** argv)
{
if(argc<4) {
printf("Usage: ./wserver cert-file priv-key-file pub-key-file.\n");
exit(0);
}
else {
CERTFILE = argv[1];
KEYFILE = argv[2];
PUBFILE = argv[3];
const char* PROMPT = "Enter password for Old Key file: ";
if(argc == 5) {
OLDKEY = argv[4];
PASSWORD = getpass(PROMPT);
OLDPASS = (char*) calloc(1, strlen(PASSWORD)+1);
strcpy(OLDPASS, PASSWORD);
}
PROMPT = "Enter password for Key file: ";
PASSWORD = getpass(PROMPT);
}
int sock,s;
BIO *sbio;
SSL_CTX *ctx;
SSL *ssl;
int r;
pid_t pid;
char buf[BUFSIZZ];
char *owner = (char*) calloc(1,256);
ctx=initialize_ctx(CERTFILE,KEYFILE,PASSWORD);
load_dh_params(ctx,DHFILE);
sock=tcp_listen();
if((s=accept(sock,0,0))<0) err_exit("Problem accepting");
sbio=BIO_new_socket(s,BIO_NOCLOSE);
ssl=SSL_new(ctx);
SSL_set_bio(ssl,sbio,sbio);
SSL_set_verify(ssl,SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT,0);
if((r=SSL_accept(ssl)<=0)) berr_exit("SSL accept error");
if(check_cert(ssl, ctx, &owner)<=0) {
send_data(ssl, "Revoked");
printf("Connection Closed.\n");
close_SSL(ssl, sock);
destroy_ctx(ctx);
exit(0);
}
send_data(ssl, "Approved");
printf("User connected: %s\n", owner);
if((pid=fork())){
close(s);
}
else {
if(argc == 5) {recrypt();}
while(1){
memset((void*)buf, 0, BUFSIZZ);
if(rec_data(buf, ssl)>0)
{
printf("Command received: %s\n", buf);
if(starts_with(buf, "PUT")){
put_file(ssl, buf, owner);
}
else if(starts_with(buf, "GET")){
get_file(ssl, buf, owner);
}
else if(starts_with(buf, "DELEGATE")){
delegate(ssl, buf, owner);
}
else if(starts_with(buf, "END")){
close_SSL(ssl, sock);
break;
}
else {
printf("Command not recognized\n");
}
}
else{
perror("Error receiving command\n");
break;
}
}
}
destroy_ctx(ctx);
exit(0);
}
static void
preprocessor_line (char *c)
{
bool flag[5];
int i, line;
char *filename;
gfc_file *f;
int escaped;
c++;
while (*c == ' ' || *c == '\t')
c++;
if (*c < '0' || *c > '9')
goto bad_cpp_line;
line = atoi (c);
c = strchr (c, ' ');
if (c == NULL)
{
/* No file name given. Set new line number. */
current_file->line = line;
return;
}
/* Skip spaces. */
while (*c == ' ' || *c == '\t')
c++;
/* Skip quote. */
if (*c != '"')
goto bad_cpp_line;
++c;
filename = c;
/* Make filename end at quote. */
escaped = false;
while (*c && ! (! escaped && *c == '"'))
{
if (escaped)
escaped = false;
else
escaped = *c == '\\';
++c;
}
if (! *c)
/* Preprocessor line has no closing quote. */
goto bad_cpp_line;
*c++ = '\0';
/* Get flags. */
flag[1] = flag[2] = flag[3] = flag[4] = false;
for (;;)
{
c = strchr (c, ' ');
if (c == NULL)
break;
c++;
i = atoi (c);
if (1 <= i && i <= 4)
flag[i] = true;
}
/* Interpret flags. */
if (flag[1]) /* Starting new file. */
{
f = get_file (filename, LC_RENAME);
f->up = current_file;
current_file = f;
}
if (flag[2]) /* Ending current file. */
{
if (!current_file->up
|| strcmp (current_file->up->filename, filename) != 0)
{
gfc_warning_now ("%s:%d: file %s left but not entered",
current_file->filename, current_file->line,
filename);
return;
}
current_file = current_file->up;
}
/* The name of the file can be a temporary file produced by
cpp. Replace the name if it is different. */
if (strcmp (current_file->filename, filename) != 0)
{
gfc_free (current_file->filename);
current_file->filename = gfc_getmem (strlen (filename) + 1);
strcpy (current_file->filename, filename);
}
/* Set new line number. */
current_file->line = line;
return;
bad_cpp_line:
gfc_warning_now ("%s:%d: Illegal preprocessor directive",
current_file->filename, current_file->line);
current_file->line++;
}
static int
load_som_binary(struct linux_binprm * bprm, struct pt_regs * regs)
{
int som_exec_fileno;
int retval;
unsigned int size;
unsigned long som_entry;
struct som_hdr *som_ex;
struct som_exec_auxhdr *hpuxhdr;
/* Get the exec-header */
som_ex = (struct som_hdr *) bprm->buf;
retval = check_som_header(som_ex);
if (retval != 0)
goto out;
/* Now read in the auxiliary header information */
retval = -ENOMEM;
size = som_ex->aux_header_size;
if (size > SOM_PAGESIZE)
goto out;
hpuxhdr = kmalloc(size, GFP_KERNEL);
if (!hpuxhdr)
goto out;
retval = kernel_read(bprm->file, som_ex->aux_header_location,
(char *) hpuxhdr, size);
if (retval != size) {
if (retval >= 0)
retval = -EIO;
goto out_free;
}
retval = get_unused_fd();
if (retval < 0)
goto out_free;
get_file(bprm->file);
fd_install(som_exec_fileno = retval, bprm->file);
/* Flush all traces of the currently running executable */
retval = flush_old_exec(bprm);
if (retval)
goto out_free;
/* OK, This is the point of no return */
current->flags &= ~PF_FORKNOEXEC;
current->personality = PER_HPUX;
/* Set the task size for HP-UX processes such that
* the gateway page is outside the address space.
* This can be fixed later, but for now, this is much
* easier.
*/
current->thread.task_size = 0xc0000000;
/* Set map base to allow enough room for hp-ux heap growth */
current->thread.map_base = 0x80000000;
retval = map_som_binary(bprm->file, hpuxhdr);
if (retval < 0)
goto out_free;
som_entry = hpuxhdr->exec_entry;
kfree(hpuxhdr);
set_binfmt(&som_format);
install_exec_creds(bprm);
setup_arg_pages(bprm, STACK_TOP, EXSTACK_DEFAULT);
create_som_tables(bprm);
current->mm->start_stack = bprm->p;
#if 0
printk("(start_brk) %08lx\n" , (unsigned long) current->mm->start_brk);
printk("(end_code) %08lx\n" , (unsigned long) current->mm->end_code);
printk("(start_code) %08lx\n" , (unsigned long) current->mm->start_code);
printk("(end_data) %08lx\n" , (unsigned long) current->mm->end_data);
printk("(start_stack) %08lx\n" , (unsigned long) current->mm->start_stack);
printk("(brk) %08lx\n" , (unsigned long) current->mm->brk);
#endif
map_hpux_gateway_page(current,current->mm);
start_thread_som(regs, som_entry, bprm->p);
return 0;
/* error cleanup */
out_free:
kfree(hpuxhdr);
out:
return retval;
}
static int copy_files(unsigned long clone_flags, struct task_struct * tsk)
{
struct files_struct *oldf, *newf;
struct file **old_fds, **new_fds;
int open_files, size, i, error = 0, expand;
/*
* A background process may not have any files ...
*/
oldf = current->files;
if (!oldf)
goto out;
/* 如果是共享进程的文件信息，则直接增加引用计数即可 */
if (clone_flags & CLONE_FILES) {
atomic_inc(&oldf->count);
goto out;
}
/*
* Note: we may be using current for both targets (See exec.c)
* This works because we cache current->files (old) as oldf. Don't
* break this.
*/
tsk->files = NULL;
error = -ENOMEM;
newf = kmem_cache_alloc(files_cachep, SLAB_KERNEL);
if (!newf)
goto out;
atomic_set(&newf->count, 1);
spin_lock_init(&newf->file_lock);
newf->next_fd = 0;
newf->max_fds = NR_OPEN_DEFAULT;
newf->max_fdset = __FD_SETSIZE;
newf->close_on_exec = &newf->close_on_exec_init;
newf->open_fds = &newf->open_fds_init;
newf->fd = &newf->fd_array[0];
spin_lock(&oldf->file_lock);
/* 获取当前进程文件打开的数量 */
open_files = count_open_files(oldf, oldf->max_fdset);
expand = 0;
/*
* Check whether we need to allocate a larger fd array or fd set.
* Note: we're not a clone task, so the open count won't change.
*/
if (open_files > newf->max_fdset) {
newf->max_fdset = 0;
expand = 1;
}
if (open_files > newf->max_fds) {
newf->max_fds = 0;
expand = 1;
}
/* if the old fdset gets grown now, we'll only copy up to "size" fds */
if (expand) {
spin_unlock(&oldf->file_lock);
spin_lock(&newf->file_lock);
error = expand_files(newf, open_files-1);
spin_unlock(&newf->file_lock);
if (error < 0)
goto out_release;
spin_lock(&oldf->file_lock);
}
old_fds = oldf->fd;
new_fds = newf->fd;
memcpy(newf->open_fds->fds_bits, oldf->open_fds->fds_bits, open_files/8);
memcpy(newf->close_on_exec->fds_bits, oldf->close_on_exec->fds_bits, open_files/8);
for (i = open_files; i != 0; i--) {
struct file *f = *old_fds++;
if (f) {
get_file(f);
} else {
/*
* The fd may be claimed in the fd bitmap but not yet
* instantiated in the files array if a sibling thread
* is partway through open(). So make sure that this
* fd is available to the new process.
*/
FD_CLR(open_files - i, newf->open_fds);
}
*new_fds++ = f;
}
spin_unlock(&oldf->file_lock);
/* compute the remainder to be cleared */
size = (newf->max_fds - open_files) * sizeof(struct file *);
/* This is long word aligned thus could use a optimized version */
memset(new_fds, 0, size);
if (newf->max_fdset > open_files) {
int left = (newf->max_fdset-open_files)/8;
int start = open_files / (8 * sizeof(unsigned long));
memset(&newf->open_fds->fds_bits[start], 0, left);
memset(&newf->close_on_exec->fds_bits[start], 0, left);
}
tsk->files = newf;
error = 0;
out:
return error;
out_release:
free_fdset (newf->close_on_exec, newf->max_fdset);
free_fdset (newf->open_fds, newf->max_fdset);
free_fd_array(newf->fd, newf->max_fds);
kmem_cache_free(files_cachep, newf);
goto out;
}
/*
* Allocate a new files structure and copy contents from the
* passed in files structure.
* errorp will be valid only when the returned files_struct is NULL.
*/
static struct files_struct *dup_fd(struct files_struct *oldf, int *errorp)
{
struct files_struct *newf;
struct file **old_fds, **new_fds;
int open_files, size, i, expand;
struct fdtable *old_fdt, *new_fdt;
*errorp = -ENOMEM;
newf = alloc_files();
if (!newf)
goto out;
spin_lock(&oldf->file_lock);
old_fdt = files_fdtable(oldf);
new_fdt = files_fdtable(newf);
size = old_fdt->max_fdset;
open_files = count_open_files(old_fdt);
expand = 0;
/*
* Check whether we need to allocate a larger fd array or fd set.
* Note: we're not a clone task, so the open count won't change.
*/
if (open_files > new_fdt->max_fdset) {
new_fdt->max_fdset = 0;
expand = 1;
}
if (open_files > new_fdt->max_fds) {
new_fdt->max_fds = 0;
expand = 1;
}
/* if the old fdset gets grown now, we'll only copy up to "size" fds */
if (expand) {
spin_unlock(&oldf->file_lock);
spin_lock(&newf->file_lock);
*errorp = expand_files(newf, open_files-1);
spin_unlock(&newf->file_lock);
if (*errorp < 0)
goto out_release;
new_fdt = files_fdtable(newf);
/*
* Reacquire the oldf lock and a pointer to its fd table
* who knows it may have a new bigger fd table. We need
* the latest pointer.
*/
spin_lock(&oldf->file_lock);
old_fdt = files_fdtable(oldf);
}
old_fds = old_fdt->fd;
new_fds = new_fdt->fd;
memcpy(new_fdt->open_fds->fds_bits, old_fdt->open_fds->fds_bits, open_files/8);
memcpy(new_fdt->close_on_exec->fds_bits, old_fdt->close_on_exec->fds_bits, open_files/8);
for (i = open_files; i != 0; i--) {
struct file *f = *old_fds++;
if (f) {
get_file(f);
} else {
/*
* The fd may be claimed in the fd bitmap but not yet
* instantiated in the files array if a sibling thread
* is partway through open(). So make sure that this
* fd is available to the new process.
*/
FD_CLR(open_files - i, new_fdt->open_fds);
}
rcu_assign_pointer(*new_fds++, f);
}
spin_unlock(&oldf->file_lock);
/* compute the remainder to be cleared */
size = (new_fdt->max_fds - open_files) * sizeof(struct file *);
/* This is long word aligned thus could use a optimized version */
memset(new_fds, 0, size);
if (new_fdt->max_fdset > open_files) {
int left = (new_fdt->max_fdset-open_files)/8;
int start = open_files / (8 * sizeof(unsigned long));
memset(&new_fdt->open_fds->fds_bits[start], 0, left);
memset(&new_fdt->close_on_exec->fds_bits[start], 0, left);
}
out:
return newf;
out_release:
free_fdset (new_fdt->close_on_exec, new_fdt->max_fdset);
free_fdset (new_fdt->open_fds, new_fdt->max_fdset);
free_fd_array(new_fdt->fd, new_fdt->max_fds);
kmem_cache_free(files_cachep, newf);
return NULL;
}
/* Change size of PE header based on word size */
bool
SgAsmPEFileHeader::reallocate()
{
bool reallocated = SgAsmGenericHeader::reallocate();
/* Resize if necessary */
rose_addr_t need = sizeof(PEFileHeader_disk);
if (4==get_word_size()) {
need += sizeof(PE32OptHeader_disk);
} else if (8==get_word_size()) {
need += sizeof(PE64OptHeader_disk);
} else {
throw FormatError("unsupported PE word size");
}
need += p_rvasize_pairs->get_pairs().size() * sizeof(SgAsmPERVASizePair::RVASizePair_disk);
if (need<get_size()) {
if (is_mapped()) {
ROSE_ASSERT(get_mapped_size()==get_size());
set_mapped_size(need);
}
set_size(need);
reallocated = true;
} else if (need>get_size()) {
get_file()->shift_extend(this, 0, need-get_size(), SgAsmGenericFile::ADDRSP_ALL, SgAsmGenericFile::ELASTIC_HOLE);
reallocated = true;
}
/* Make sure the RVA/Size pairs at the end of the header are consistent with the sections to which they point. Reallocate()
* has already been called recursively for the sections. */
update_rvasize_pairs();
/* Make sure header is consistent with sections. Reallocate() has already been called recursively for the sections.
* Count the number of sections in the table and update the header's e_nsections member. */
if (p_section_table) {
ROSE_ASSERT(p_section_table->get_header()==this);
SgAsmGenericSectionList *all = get_sections();
p_e_nsections = 0;
for (size_t i=0; i<all->get_sections().size(); i++) {
SgAsmPESection *pesec = dynamic_cast<SgAsmPESection*>(all->get_sections()[i]);
if (pesec && pesec->get_section_entry()!=NULL)
p_e_nsections++;
}
rose_addr_t header_size = ALIGN_UP(p_section_table->get_offset() + p_section_table->get_size(),
p_e_file_align>0 ? p_e_file_align : 1);
#if 1
/* The PE Specification regarding e_header_size (known as "SizeOfHeader" on page 14 of "Microsoft Portable Executable
* and Common Object File Format Specification: Revision 8.1 February 15, 2008" is not always followed. We recompute
* it here as being the minimum RVA from all the sections defined in the PE Section Table, but not smaller
* than the value according to the specification. This alternate value is kept if it's already in the parse tree,
* otherwise we use the correct value. (RPM 2008-10-21) */
rose_addr_t min_offset = 0;
for (size_t i=0, nfound=0; i<all->get_sections().size(); i++) {
SgAsmPESection *pesec = dynamic_cast<SgAsmPESection*>(all->get_sections()[i]);
if (pesec && pesec->get_section_entry()!=NULL) {
if (0==nfound++) {
min_offset = pesec->get_offset();
} else {
min_offset = std::min(min_offset, pesec->get_offset() );
}
}
}
rose_addr_t header_size2 = std::max(header_size, min_offset);
if (p_e_header_size==header_size2)
header_size = header_size2;
/* If the original header size was zero then don't change that--leave it at zero. Some tiny executables have a zero
* value here and as a result, since this is near the end of the NT Optional Header, they can truncate the file and
* the loader will fill the optional header with zeros when reading. (RPM 2008-11-11) */
if (p_e_header_size==0)
header_size = 0;
#endif
p_e_header_size = header_size;
}
/* The size of the optional header. If there's a section table then we use its offset to calculate the optional header
* size in order to be compatible with the PE loader. Otherwise use the actual optional header size. */
if (p_section_table) {
ROSE_ASSERT(p_section_table->get_offset() >= get_offset() + sizeof(PEFileHeader_disk));
p_e_nt_hdr_size = p_section_table->get_offset() - (get_offset() + sizeof(PEFileHeader_disk));
} else if (4==get_word_size()) {
p_e_nt_hdr_size = sizeof(PE32OptHeader_disk);
} else if (8==get_word_size()) {
p_e_nt_hdr_size = sizeof(PE64OptHeader_disk);
} else {
throw FormatError("invalid PE word size");
}
/* Update COFF symbol table related data members in the file header */
if (get_coff_symtab()) {
ROSE_ASSERT(get_coff_symtab()->get_header()==this);
set_e_coff_symtab(get_coff_symtab()->get_offset());
set_e_coff_nsyms(get_coff_symtab()->get_nslots());
}
/* Update some additional header fields */
set_e_num_rvasize_pairs(get_rvasize_pairs()->get_pairs().size());
set_e_opt_magic(4==get_word_size() ? 0x010b : 0x020b);
set_e_lmajor((get_exec_format()->get_version() >> 16) & 0xffff);
set_e_lminor(get_exec_format()->get_version() & 0xffff);
/* Adjust the COFF Header's e_nt_hdr_size to accommodate the NT Optional Header in such a way that EXEs from tinype.com
* don't change (i.e., don't increase e_nt_hdr_size if the bytes beyond it are zero anyway, and if they aren't then adjust
* it as little as possible. The RVA/Size pairs are considered to be part of the NT Optional Header. */
size_t oh_size = p_rvasize_pairs->get_pairs().size() * sizeof(SgAsmPERVASizePair::RVASizePair_disk);
size_t rvasize_offset; /*offset with respect to "oh" buffer allocated below*/
if (4==get_word_size()) {
oh_size += sizeof(PE32OptHeader_disk);
} else if (8==get_word_size()) {
oh_size += sizeof(PE64OptHeader_disk);
} else {
throw FormatError("unsupported PE word size");
}
unsigned char *oh = new unsigned char[oh_size];
if (4==get_word_size()) {
encode((PE32OptHeader_disk*)oh);
rvasize_offset = sizeof(PE32OptHeader_disk);
} else if (8==get_word_size()) {
encode((PE64OptHeader_disk*)oh);
rvasize_offset = sizeof(PE64OptHeader_disk);
} else {
delete[] oh;
throw FormatError("unsupported PE word size");
}
while (oh_size>p_e_nt_hdr_size) {
if (0!=oh[oh_size-1]) break;
--oh_size;
}
set_e_nt_hdr_size(oh_size);
return reallocated;
}
static int CVE_2010_0307_linux2_6_27_31_load_elf_binary(struct linux_binprm *bprm, struct pt_regs *regs)
{
struct file *interpreter = NULL; /* to shut gcc up */
unsigned long load_addr = 0, load_bias = 0;
int load_addr_set = 0;
char * elf_interpreter = NULL;
unsigned long error;
struct elf_phdr *elf_ppnt, *elf_phdata;
unsigned long elf_bss, elf_brk;
int elf_exec_fileno;
int retval, i;
unsigned int size;
unsigned long elf_entry;
unsigned long interp_load_addr = 0;
unsigned long start_code, end_code, start_data, end_data;
unsigned long reloc_func_desc = 0;
int executable_stack = EXSTACK_DEFAULT;
unsigned long def_flags = 0;
struct {
struct elfhdr elf_ex;
struct elfhdr interp_elf_ex;
} *loc;
loc = kmalloc(sizeof(*loc), GFP_KERNEL);
if (!loc) {
retval = -ENOMEM;
goto out_ret;
}
/* Get the exec-header */
loc->elf_ex = *((struct elfhdr *)bprm->buf);
retval = -ENOEXEC;
/* First of all, some simple consistency checks */
if (memcmp(loc->elf_ex.e_ident, ELFMAG, SELFMAG) != 0)
goto out;
if (loc->elf_ex.e_type != ET_EXEC && loc->elf_ex.e_type != ET_DYN)
goto out;
if (!elf_check_arch(&loc->elf_ex))
goto out;
if (!bprm->file->f_op||!bprm->file->f_op->mmap)
goto out;
/* Now read in all of the header information */
if (loc->elf_ex.e_phentsize != sizeof(struct elf_phdr))
goto out;
if (loc->elf_ex.e_phnum < 1 ||
loc->elf_ex.e_phnum > 65536U / sizeof(struct elf_phdr))
goto out;
size = loc->elf_ex.e_phnum * sizeof(struct elf_phdr);
retval = -ENOMEM;
elf_phdata = kmalloc(size, GFP_KERNEL);
if (!elf_phdata)
goto out;
retval = kernel_read(bprm->file, loc->elf_ex.e_phoff,
(char *)elf_phdata, size);
if (retval != size) {
if (retval >= 0)
retval = -EIO;
goto out_free_ph;
}
retval = get_unused_fd();
if (retval < 0)
goto out_free_ph;
get_file(bprm->file);
fd_install(elf_exec_fileno = retval, bprm->file);
elf_ppnt = elf_phdata;
elf_bss = 0;
elf_brk = 0;
start_code = ~0UL;
end_code = 0;
start_data = 0;
end_data = 0;
for (i = 0; i < loc->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
*/
retval = -ENOEXEC;
if (elf_ppnt->p_filesz > PATH_MAX ||
elf_ppnt->p_filesz < 2)
goto out_free_file;
retval = -ENOMEM;
elf_interpreter = kmalloc(elf_ppnt->p_filesz,
GFP_KERNEL);
if (!elf_interpreter)
goto out_free_file;
retval = kernel_read(bprm->file, elf_ppnt->p_offset,
elf_interpreter,
elf_ppnt->p_filesz);
if (retval != elf_ppnt->p_filesz) {
if (retval >= 0)
retval = -EIO;
goto out_free_interp;
}
/* make sure path is NULL terminated */
retval = -ENOEXEC;
if (elf_interpreter[elf_ppnt->p_filesz - 1] != '\0')
goto out_free_interp;
/*
* The early SET_PERSONALITY here is so that the lookup
* for the interpreter happens in the namespace of the
* to-be-execed image. SET_PERSONALITY can select an
* alternate root.
*
* However, SET_PERSONALITY is NOT allowed to switch
* this task into the new images's memory mapping
* policy - that is, TASK_SIZE must still evaluate to
* that which is appropriate to the execing application.
* This is because exit_mmap() needs to have TASK_SIZE
* evaluate to the size of the old image.
*
* So if (say) a 64-bit application is execing a 32-bit
* application it is the architecture's responsibility
* to defer changing the value of TASK_SIZE until the
* switch really is going to happen - do this in
* flush_thread(). - akpm
*/
SET_PERSONALITY(loc->elf_ex, 0);
interpreter = open_exec(elf_interpreter);
retval = PTR_ERR(interpreter);
if (IS_ERR(interpreter))
goto out_free_interp;
/*
* If the binary is not readable then enforce
* mm->dumpable = 0 regardless of the interpreter's
* permissions.
*/
if (file_permission(interpreter, MAY_READ) < 0)
bprm->interp_flags |= BINPRM_FLAGS_ENFORCE_NONDUMP;
retval = kernel_read(interpreter, 0, bprm->buf,
BINPRM_BUF_SIZE);
if (retval != BINPRM_BUF_SIZE) {
if (retval >= 0)
retval = -EIO;
goto out_free_dentry;
}
/* Get the exec headers */
loc->interp_elf_ex = *((struct elfhdr *)bprm->buf);
break;
}
elf_ppnt++;
}
elf_ppnt = elf_phdata;
for (i = 0; i < loc->elf_ex.e_phnum; i++, elf_ppnt++)
if (elf_ppnt->p_type == PT_GNU_STACK) {
if (elf_ppnt->p_flags & PF_X)
executable_stack = EXSTACK_ENABLE_X;
else
executable_stack = EXSTACK_DISABLE_X;
break;
}
/* Some simple consistency checks for the interpreter */
if (elf_interpreter) {
retval = -ELIBBAD;
/* Not an ELF interpreter */
if (memcmp(loc->interp_elf_ex.e_ident, ELFMAG, SELFMAG) != 0)
goto out_free_dentry;
/* Verify the interpreter has a valid arch */
if (!elf_check_arch(&loc->interp_elf_ex))
goto out_free_dentry;
} else {
/* Executables without an interpreter also need a personality */
SET_PERSONALITY(loc->elf_ex, 0);
}
/* 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->flags &= ~PF_FORKNOEXEC;
current->mm->def_flags = def_flags;
/* Do this immediately, since STACK_TOP as used in setup_arg_pages
may depend on the personality. */
SET_PERSONALITY(loc->elf_ex, 0);
if (elf_read_implies_exec(loc->elf_ex, executable_stack))
current->personality |= READ_IMPLIES_EXEC;
if (!(current->personality & ADDR_NO_RANDOMIZE) && randomize_va_space)
current->flags |= PF_RANDOMIZE;
arch_pick_mmap_layout(current->mm);
/* Do this so that we can load the interpreter, if need be. We will
change some of these later */
current->mm->free_area_cache = current->mm->mmap_base;
current->mm->cached_hole_size = 0;
retval = setup_arg_pages(bprm, randomize_stack_top(STACK_TOP),
executable_stack);
if (retval < 0) {
send_sig(SIGKILL, current, 0);
goto out_free_dentry;
}
current->mm->start_stack = bprm->p;
/* Now we do a little grungy work by mmaping the ELF image into
the correct location in memory. */
for(i = 0, elf_ppnt = elf_phdata;
i < loc->elf_ex.e_phnum; i++, elf_ppnt++) {
int elf_prot = 0, elf_flags;
unsigned long k, vaddr;
if (elf_ppnt->p_type != PT_LOAD)
continue;
if (unlikely (elf_brk > elf_bss)) {
unsigned long nbyte;
/* There was a PT_LOAD segment with p_memsz > p_filesz
before this one. Map anonymous pages, if needed,
and clear the area. */
retval = set_brk (elf_bss + load_bias,
elf_brk + load_bias);
if (retval) {
send_sig(SIGKILL, current, 0);
goto out_free_dentry;
}
nbyte = ELF_PAGEOFFSET(elf_bss);
if (nbyte) {
nbyte = ELF_MIN_ALIGN - nbyte;
if (nbyte > elf_brk - elf_bss)
nbyte = elf_brk - elf_bss;
if (clear_user((void __user *)elf_bss +
load_bias, nbyte)) {
/*
* This bss-zeroing can fail if the ELF
* file specifies odd protections. So
* we don't check the return value
*/
}
}
}
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 (loc->elf_ex.e_type == ET_EXEC || load_addr_set) {
elf_flags |= MAP_FIXED;
} else if (loc->elf_ex.e_type == ET_DYN) {
/* 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. */
#ifdef CONFIG_X86
load_bias = 0;
#else
load_bias = ELF_PAGESTART(ELF_ET_DYN_BASE - vaddr);
#endif
}
error = elf_map(bprm->file, load_bias + vaddr, elf_ppnt,
elf_prot, elf_flags, 0);
if (BAD_ADDR(error)) {
send_sig(SIGKILL, current, 0);
retval = IS_ERR((void *)error) ?
PTR_ERR((void*)error) : -EINVAL;
goto out_free_dentry;
}
if (!load_addr_set) {
load_addr_set = 1;
load_addr = (elf_ppnt->p_vaddr - elf_ppnt->p_offset);
if (loc->elf_ex.e_type == ET_DYN) {
load_bias += error -
ELF_PAGESTART(load_bias + vaddr);
load_addr += load_bias;
reloc_func_desc = load_bias;
}
}
k = elf_ppnt->p_vaddr;
if (k < start_code)
start_code = k;
if (start_data < k)
start_data = k;
/*
* Check to see if the section's size will overflow the
* allowed task size. Note that p_filesz must always be
* <= p_memsz so it is only necessary to check p_memsz.
*/
if (BAD_ADDR(k) || elf_ppnt->p_filesz > elf_ppnt->p_memsz ||
elf_ppnt->p_memsz > TASK_SIZE ||
TASK_SIZE - elf_ppnt->p_memsz < k) {
/* set_brk can never work. Avoid overflows. */
send_sig(SIGKILL, current, 0);
retval = -EINVAL;
goto out_free_dentry;
}
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;
}
loc->elf_ex.e_entry += load_bias;
elf_bss += load_bias;
elf_brk += load_bias;
start_code += load_bias;
end_code += load_bias;
start_data += load_bias;
end_data += load_bias;
/* Calling set_brk effectively mmaps the pages that we need
* for the bss and break sections. We must do this before
* mapping in the interpreter, to make sure it doesn't wind
* up getting placed where the bss needs to go.
*/
retval = set_brk(elf_bss, elf_brk);
if (retval) {
send_sig(SIGKILL, current, 0);
goto out_free_dentry;
}
if (likely(elf_bss != elf_brk) && unlikely(padzero(elf_bss))) {
send_sig(SIGSEGV, current, 0);
retval = -EFAULT; /* Nobody gets to see this, but.. */
goto out_free_dentry;
}
if (elf_interpreter) {
unsigned long uninitialized_var(interp_map_addr);
elf_entry = load_elf_interp(&loc->interp_elf_ex,
interpreter,
&interp_map_addr,
load_bias);
if (!IS_ERR((void *)elf_entry)) {
/*
* load_elf_interp() returns relocation
* adjustment
*/
interp_load_addr = elf_entry;
elf_entry += loc->interp_elf_ex.e_entry;
}
if (BAD_ADDR(elf_entry)) {
force_sig(SIGSEGV, current);
retval = IS_ERR((void *)elf_entry) ?
(int)elf_entry : -EINVAL;
goto out_free_dentry;
}
reloc_func_desc = interp_load_addr;
allow_write_access(interpreter);
fput(interpreter);
kfree(elf_interpreter);
} else {
elf_entry = loc->elf_ex.e_entry;
if (BAD_ADDR(elf_entry)) {
force_sig(SIGSEGV, current);
retval = -EINVAL;
goto out_free_dentry;
}
}
kfree(elf_phdata);
sys_close(elf_exec_fileno);
set_binfmt(&elf_format);
#ifdef ARCH_HAS_SETUP_ADDITIONAL_PAGES
retval = arch_setup_additional_pages(bprm, executable_stack);
if (retval < 0) {
send_sig(SIGKILL, current, 0);
goto out;
}
#endif /* ARCH_HAS_SETUP_ADDITIONAL_PAGES */
compute_creds(bprm);
current->flags &= ~PF_FORKNOEXEC;
retval = create_elf_tables(bprm, &loc->elf_ex,
load_addr, interp_load_addr);
if (retval < 0) {
send_sig(SIGKILL, current, 0);
goto out;
}
/* N.B. passed_fileno might not be initialized? */
current->mm->end_code = end_code;
current->mm->start_code = start_code;
current->mm->start_data = start_data;
current->mm->end_data = end_data;
current->mm->start_stack = bprm->p;
#ifdef arch_randomize_brk
if ((current->flags & PF_RANDOMIZE) && (randomize_va_space > 1))
current->mm->brk = current->mm->start_brk =
arch_randomize_brk(current->mm);
#endif
if (current->personality & MMAP_PAGE_ZERO) {
/* 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. */
down_write(¤t->mm->mmap_sem);
error = do_mmap(NULL, 0, PAGE_SIZE, PROT_READ | PROT_EXEC,
MAP_FIXED | MAP_PRIVATE, 0);
up_write(¤t->mm->mmap_sem);
}
#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. In addition, it may also specify (eg, PowerPC64 ELF)
* that the e_entry field is the address of the function descriptor
* for the startup routine, rather than the address of the startup
* routine itself. This macro performs whatever initialization to
* the regs structure is required as well as any relocations to the
* function descriptor entries when executing dynamically links apps.
*/
ELF_PLAT_INIT(regs, reloc_func_desc);
#endif
start_thread(regs, elf_entry, bprm->p);
retval = 0;
out:
kfree(loc);
out_ret:
return retval;
/* error cleanup */
out_free_dentry:
allow_write_access(interpreter);
if (interpreter)
fput(interpreter);
out_free_interp:
kfree(elf_interpreter);
out_free_file:
sys_close(elf_exec_fileno);
out_free_ph:
kfree(elf_phdata);
goto out;
}
static int dup_mmap(struct mm_struct *mm, struct mm_struct *oldmm)
{
struct vm_area_struct *mpnt, *tmp, *prev, **pprev;
struct rb_node **rb_link, *rb_parent;
int retval;
unsigned long charge;
uprobe_start_dup_mmap();
down_write(&oldmm->mmap_sem);
flush_cache_dup_mm(oldmm);
uprobe_dup_mmap(oldmm, mm);
/*
* Not linked in yet - no deadlock potential:
*/
down_write_nested(&mm->mmap_sem, SINGLE_DEPTH_NESTING);
/* No ordering required: file already has been exposed. */
RCU_INIT_POINTER(mm->exe_file, get_mm_exe_file(oldmm));
mm->total_vm = oldmm->total_vm;
mm->shared_vm = oldmm->shared_vm;
mm->exec_vm = oldmm->exec_vm;
mm->stack_vm = oldmm->stack_vm;
rb_link = &mm->mm_rb.rb_node;
rb_parent = NULL;
pprev = &mm->mmap;
retval = ksm_fork(mm, oldmm);
if (retval)
goto out;
retval = khugepaged_fork(mm, oldmm);
if (retval)
goto out;
prev = NULL;
for (mpnt = oldmm->mmap; mpnt; mpnt = mpnt->vm_next) {
struct file *file;
if (mpnt->vm_flags & VM_DONTCOPY) {
vm_stat_account(mm, mpnt->vm_flags, mpnt->vm_file,
-vma_pages(mpnt));
continue;
}
charge = 0;
if (mpnt->vm_flags & VM_ACCOUNT) {
unsigned long len = vma_pages(mpnt);
if (security_vm_enough_memory_mm(oldmm, len)) /* sic */
goto fail_nomem;
charge = len;
}
tmp = kmem_cache_alloc(vm_area_cachep, GFP_KERNEL);
if (!tmp)
goto fail_nomem;
*tmp = *mpnt;
INIT_LIST_HEAD(&tmp->anon_vma_chain);
retval = vma_dup_policy(mpnt, tmp);
if (retval)
goto fail_nomem_policy;
tmp->vm_mm = mm;
if (anon_vma_fork(tmp, mpnt))
goto fail_nomem_anon_vma_fork;
tmp->vm_flags &= ~VM_LOCKED;
tmp->vm_next = tmp->vm_prev = NULL;
file = tmp->vm_file;
if (file) {
struct inode *inode = file_inode(file);
struct address_space *mapping = file->f_mapping;
get_file(file);
if (tmp->vm_flags & VM_DENYWRITE)
atomic_dec(&inode->i_writecount);
i_mmap_lock_write(mapping);
if (tmp->vm_flags & VM_SHARED)
atomic_inc(&mapping->i_mmap_writable);
flush_dcache_mmap_lock(mapping);
/* insert tmp into the share list, just after mpnt */
vma_interval_tree_insert_after(tmp, mpnt,
&mapping->i_mmap);
flush_dcache_mmap_unlock(mapping);
i_mmap_unlock_write(mapping);
}
/*
* Clear hugetlb-related page reserves for children. This only
* affects MAP_PRIVATE mappings. Faults generated by the child
* are not guaranteed to succeed, even if read-only
*/
if (is_vm_hugetlb_page(tmp))
reset_vma_resv_huge_pages(tmp);
/*
* Link in the new vma and copy the page table entries.
*/
*pprev = tmp;
pprev = &tmp->vm_next;
tmp->vm_prev = prev;
prev = tmp;
__vma_link_rb(mm, tmp, rb_link, rb_parent);
rb_link = &tmp->vm_rb.rb_right;
rb_parent = &tmp->vm_rb;
mm->map_count++;
retval = copy_page_range(mm, oldmm, mpnt);
if (tmp->vm_ops && tmp->vm_ops->open)
tmp->vm_ops->open(tmp);
if (retval)
goto out;
}
/* a new mm has just been created */
arch_dup_mmap(oldmm, mm);
retval = 0;
out:
up_write(&mm->mmap_sem);
flush_tlb_mm(oldmm);
up_write(&oldmm->mmap_sem);
uprobe_end_dup_mmap();
return retval;
fail_nomem_anon_vma_fork:
mpol_put(vma_policy(tmp));
fail_nomem_policy:
kmem_cache_free(vm_area_cachep, tmp);
fail_nomem:
retval = -ENOMEM;
vm_unacct_memory(charge);
goto out;
}
static void
on_ok_clicked (GtkButton *button, GtkamSave *save)
{
guint i, count, j = 1;
int result = -1;
GtkWidget *s, *dialog;
unsigned int id = 0;
GtkamSaveData *data;
gchar *progname, *command;
GError *error = NULL;
if (count_items (save) == 0) {
if (!save->priv->err_shown) {
dialog = gtkam_error_new (result, NULL,
GTK_WIDGET (save), _("There is nothing to be saved."));
gtk_widget_show (dialog);
}
return;
}
store_save_settings(save);
gtk_widget_hide (GTK_WIDGET (save));
count = g_slist_length (save->priv->data);
if (count == 1)
s = gtkam_cancel_new (_("Downloading file"));
else
s = gtkam_cancel_new (_("Downloading %i files"), count);
gtk_window_set_transient_for (GTK_WINDOW (s), save->priv->main_window);
gtk_widget_show (s);
if (count > 1)
id = gp_context_progress_start (
GTKAM_CANCEL (s)->context->context, count,
_("Downloading %i files..."), count);
if (!save->priv->toggle_filename_camera->active)
j = gtk_spin_button_get_value_as_int (
GTK_SPIN_BUTTON (save->priv->spin_entry));
for (i = 0; i < count; i++) {
data = g_slist_nth_data (save->priv->data, i);
/* Check for shutdown */
if (!GTKAM_IS_SAVE (save))
return;
if (save->priv->toggle_normal &&
save->priv->toggle_normal->active)
result = get_file (save, data->camera,
data->folder, data->name,
GP_FILE_TYPE_NORMAL, i + j,
GTKAM_CANCEL (s)->context);
if (save->priv->toggle_preview &&
save->priv->toggle_preview->active &&
(!result < 0))
result = get_file (save, data->camera,
data->folder, data->name,
GP_FILE_TYPE_PREVIEW, i + j,
GTKAM_CANCEL (s)->context);
if (save->priv->toggle_raw &&
save->priv->toggle_raw->active &&
(!result < 0))
result = get_file (save, data->camera,
data->folder, data->name, GP_FILE_TYPE_RAW,
i + j, GTKAM_CANCEL (s)->context);
if (save->priv->toggle_audio &&
save->priv->toggle_audio->active &&
(!result < 0))
result = get_file (save, data->camera,
data->folder, data->name, GP_FILE_TYPE_AUDIO,
i + j, GTKAM_CANCEL (s)->context);
if (save->priv->toggle_exif &&
save->priv->toggle_exif->active &&
(!result < 0))
result = get_file (save, data->camera,
data->folder, data->name, GP_FILE_TYPE_EXIF,
i + j, GTKAM_CANCEL (s)->context);
if (result < 0)
{
if (count > 1)
gp_context_progress_stop (GTKAM_CANCEL (s)->context->context, id);
if (!save->priv->err_shown) {
dialog = gtkam_error_new (result, GTKAM_CANCEL (s)->context,
GTK_WIDGET (save), _("Problem getting '%s' "
"from folder '%s'."),
data->name, data->folder);
gtk_widget_show (dialog);
save->priv->err_shown = TRUE;
}
gtk_object_destroy (GTK_OBJECT (s));
gtk_object_destroy (GTK_OBJECT (save));
return;
}
if (count > 1)
gp_context_progress_update (
GTKAM_CANCEL (s)->context->context, id, i + 1);
gp_context_idle (GTKAM_CANCEL (s)->context->context);
if (gp_context_cancel (GTKAM_CANCEL (s)->context->context) ==
GP_CONTEXT_FEEDBACK_CANCEL)
break;
}
if (count > 1)
gp_context_progress_stop (
GTKAM_CANCEL (s)->context->context, id);
gtk_object_destroy (GTK_OBJECT (s));
/* If file(s) were saved and a program specified, load the program
passing the filenames */
if (result >= 0)
{
progname = gtk_entry_get_text (save->priv->program);
if (progname && progname[0] != '\0') {
command = g_strdup_printf ("%s%s", progname, save->priv->filelist->str);
/* FIXME Report any arising errors */
if (!g_spawn_command_line_async (command, &error)) {
g_warning ("Error running command\n");
g_error_free (error);
}
g_free (command);
g_string_free (save->priv->filelist, TRUE);
}
}
gtk_object_destroy (GTK_OBJECT (save));
}
static int dup_mmap(struct mm_struct *mm, struct mm_struct *oldmm)
{
struct vm_area_struct *mpnt, *tmp, *prev, **pprev;
struct rb_node **rb_link, *rb_parent;
int retval;
unsigned long charge;
struct mempolicy *pol;
down_write(&oldmm->mmap_sem);
flush_cache_dup_mm(oldmm);
/*
* Not linked in yet - no deadlock potential:
*/
down_write_nested(&mm->mmap_sem, SINGLE_DEPTH_NESTING);
mm->locked_vm = 0;
mm->mmap = NULL;
mm->mmap_cache = NULL;
mm->free_area_cache = oldmm->mmap_base;
mm->cached_hole_size = ~0UL;
mm->map_count = 0;
cpumask_clear(mm_cpumask(mm));
mm->mm_rb = RB_ROOT;
rb_link = &mm->mm_rb.rb_node;
rb_parent = NULL;
pprev = &mm->mmap;
retval = ksm_fork(mm, oldmm);
if (retval)
goto out;
retval = khugepaged_fork(mm, oldmm);
if (retval)
goto out;
prev = NULL;
for (mpnt = oldmm->mmap; mpnt; mpnt = mpnt->vm_next) {
struct file *file;
if (mpnt->vm_flags & VM_DONTCOPY) {
long pages = vma_pages(mpnt);
mm->total_vm -= pages;
vm_stat_account(mm, mpnt->vm_flags, mpnt->vm_file,
-pages);
continue;
}
charge = 0;
if (mpnt->vm_flags & VM_ACCOUNT) {
unsigned int len = (mpnt->vm_end - mpnt->vm_start) >> PAGE_SHIFT;
if (security_vm_enough_memory(len))
goto fail_nomem;
charge = len;
}
tmp = kmem_cache_alloc(vm_area_cachep, GFP_KERNEL);
if (!tmp)
goto fail_nomem;
*tmp = *mpnt;
INIT_LIST_HEAD(&tmp->anon_vma_chain);
pol = mpol_dup(vma_policy(mpnt));
retval = PTR_ERR(pol);
if (IS_ERR(pol))
goto fail_nomem_policy;
vma_set_policy(tmp, pol);
tmp->vm_mm = mm;
if (anon_vma_fork(tmp, mpnt))
goto fail_nomem_anon_vma_fork;
tmp->vm_flags &= ~VM_LOCKED;
tmp->vm_next = tmp->vm_prev = NULL;
file = tmp->vm_file;
if (file) {
struct inode *inode = file->f_path.dentry->d_inode;
struct address_space *mapping = file->f_mapping;
get_file(file);
if (tmp->vm_flags & VM_DENYWRITE)
atomic_dec(&inode->i_writecount);
spin_lock(&mapping->i_mmap_lock);
if (tmp->vm_flags & VM_SHARED)
mapping->i_mmap_writable++;
tmp->vm_truncate_count = mpnt->vm_truncate_count;
flush_dcache_mmap_lock(mapping);
/* insert tmp into the share list, just after mpnt */
vma_prio_tree_add(tmp, mpnt);
flush_dcache_mmap_unlock(mapping);
spin_unlock(&mapping->i_mmap_lock);
}
/*
* Clear hugetlb-related page reserves for children. This only
* affects MAP_PRIVATE mappings. Faults generated by the child
* are not guaranteed to succeed, even if read-only
*/
if (is_vm_hugetlb_page(tmp))
reset_vma_resv_huge_pages(tmp);
/*
* Link in the new vma and copy the page table entries.
*/
*pprev = tmp;
pprev = &tmp->vm_next;
tmp->vm_prev = prev;
prev = tmp;
__vma_link_rb(mm, tmp, rb_link, rb_parent);
rb_link = &tmp->vm_rb.rb_right;
rb_parent = &tmp->vm_rb;
mm->map_count++;
retval = copy_page_range(mm, oldmm, mpnt);
if (tmp->vm_ops && tmp->vm_ops->open)
tmp->vm_ops->open(tmp);
if (retval)
goto out;
}
static int load_elf_binary(struct linux_binprm * bprm, struct pt_regs * regs)
{
struct file *interpreter = NULL; /* to shut gcc up */
unsigned long load_addr = 0, load_bias = 0;
int load_addr_set = 0;
char * elf_interpreter = NULL;
unsigned int interpreter_type = INTERPRETER_NONE;
unsigned char ibcs2_interpreter = 0;
unsigned long error;
struct elf_phdr * elf_ppnt, *elf_phdata;
unsigned long elf_bss, k, elf_brk;
int elf_exec_fileno;
int retval, i;
unsigned int size;
unsigned long elf_entry, interp_load_addr = 0;
unsigned long start_code, end_code, start_data, end_data;
unsigned long reloc_func_desc = 0;
struct elfhdr elf_ex;
struct elfhdr interp_elf_ex;
struct exec interp_ex;
char passed_fileno[6];
struct files_struct *files;
/* Get the exec-header */
elf_ex = *((struct elfhdr *) bprm->buf);
retval = -ENOEXEC;
/* First of all, some simple consistency checks */
if (memcmp(elf_ex.e_ident, ELFMAG, SELFMAG) != 0)
goto out;
if (elf_ex.e_type != ET_EXEC && elf_ex.e_type != ET_DYN)
goto out;
if (!elf_check_arch(&elf_ex))
goto out;
if (!bprm->file->f_op||!bprm->file->f_op->mmap)
goto out;
/* Now read in all of the header information */
retval = -ENOMEM;
if (elf_ex.e_phentsize != sizeof(struct elf_phdr))
goto out;
if (elf_ex.e_phnum > 65536U / sizeof(struct elf_phdr))
goto out;
size = elf_ex.e_phnum * sizeof(struct elf_phdr);
elf_phdata = (struct elf_phdr *) kmalloc(size, GFP_KERNEL);
if (!elf_phdata)
goto out;
retval = kernel_read(bprm->file, elf_ex.e_phoff, (char *) elf_phdata, size);
if (retval < 0)
goto out_free_ph;
files = current->files; /* Refcounted so ok */
retval = unshare_files();
if (retval < 0)
goto out_free_ph;
if (files == current->files) {
put_files_struct(files);
files = NULL;
}
/* exec will make our files private anyway, but for the a.out
loader stuff we need to do it earlier */
retval = get_unused_fd();
if (retval < 0)
goto out_free_fh;
get_file(bprm->file);
fd_install(elf_exec_fileno = retval, bprm->file);
elf_ppnt = elf_phdata;
elf_bss = 0;
elf_brk = 0;
start_code = ~0UL;
end_code = 0;
start_data = 0;
end_data = 0;
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
*/
retval = -ENOMEM;
if (elf_ppnt->p_filesz > PATH_MAX)
goto out_free_file;
elf_interpreter = (char *) kmalloc(elf_ppnt->p_filesz,
GFP_KERNEL);
if (!elf_interpreter)
goto out_free_file;
retval = kernel_read(bprm->file, elf_ppnt->p_offset,
elf_interpreter,
elf_ppnt->p_filesz);
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
SET_PERSONALITY(elf_ex, ibcs2_interpreter);
interpreter = open_exec(elf_interpreter);
retval = PTR_ERR(interpreter);
if (IS_ERR(interpreter))
goto out_free_interp;
retval = kernel_read(interpreter, 0, bprm->buf, BINPRM_BUF_SIZE);
if (retval < 0)
goto out_free_dentry;
/* Get the exec headers */
interp_ex = *((struct exec *) bprm->buf);
interp_elf_ex = *((struct elfhdr *) bprm->buf);
break;
}
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 (memcmp(interp_elf_ex.e_ident, ELFMAG, SELFMAG) != 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) {
// FIXME - ratelimit this before re-enabling
// printk(KERN_WARNING "ELF: Ambiguous type, using ELF\n");
interpreter_type = INTERPRETER_ELF;
}
/* Verify the interpreter has a valid arch */
if ((interpreter_type == INTERPRETER_ELF) &&
!elf_check_arch(&interp_elf_ex))
goto out_free_dentry;
} else {
/* Executables without an interpreter also need a personality */
SET_PERSONALITY(elf_ex, ibcs2_interpreter);
}
/* 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) {
retval = copy_strings_kernel(1,&passed_p,bprm);
if (retval)
goto out_free_dentry;
bprm->argc++;
}
}
}
/* Flush all traces of the currently running executable */
retval = flush_old_exec(bprm);
if (retval)
goto out_free_dentry;
/* Discard our unneeded old files struct */
if (files) {
steal_locks(files);
put_files_struct(files);
files = NULL;
}
/* OK, This is the point of no return */
current->mm->start_data = 0;
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 so that we can load the interpreter, if need be. We will
change some of these later */
current->mm->rss = 0;
retval = setup_arg_pages(bprm);
if (retval < 0) {
send_sig(SIGKILL, current, 0);
return retval;
}
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. */
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 (unlikely (elf_brk > elf_bss)) {
unsigned long nbyte;
/* There was a PT_LOAD segment with p_memsz > p_filesz
before this one. Map anonymous pages, if needed,
and clear the area. */
set_brk (elf_bss + load_bias, elf_brk + load_bias);
nbyte = ELF_PAGEOFFSET(elf_bss);
if (nbyte) {
nbyte = ELF_MIN_ALIGN - nbyte;
if (nbyte > elf_brk - elf_bss)
nbyte = elf_brk - elf_bss;
clear_user((void *) elf_bss + load_bias, nbyte);
}
}
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;
} else if (elf_ex.e_type == ET_DYN) {
/* 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_ET_DYN_BASE - vaddr);
}
error = elf_map(bprm->file, load_bias + vaddr, elf_ppnt, elf_prot, elf_flags);
if (BAD_ADDR(error))
continue;
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 += load_bias;
reloc_func_desc = load_addr;
}
}
k = elf_ppnt->p_vaddr;
if (k < start_code) start_code = k;
if (start_data < k) start_data = 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;
}
elf_entry += load_bias;
elf_bss += load_bias;
elf_brk += load_bias;
start_code += load_bias;
end_code += load_bias;
start_data += load_bias;
end_data += load_bias;
if (elf_interpreter) {
if (interpreter_type == INTERPRETER_AOUT)
elf_entry = load_aout_interp(&interp_ex,
interpreter);
else
elf_entry = load_elf_interp(&interp_elf_ex,
interpreter,
&interp_load_addr);
if (BAD_ADDR(elf_entry)) {
printk(KERN_ERR "Unable to load interpreter\n");
send_sig(SIGSEGV, current, 0);
retval = -ENOEXEC; /* Nobody gets to see this, but.. */
goto out_free_dentry;
}
reloc_func_desc = interp_load_addr;
allow_write_access(interpreter);
fput(interpreter);
kfree(elf_interpreter);
}
kfree(elf_phdata);
if (interpreter_type != INTERPRETER_AOUT)
sys_close(elf_exec_fileno);
set_binfmt(&elf_format);
compute_creds(bprm);
current->flags &= ~PF_FORKNOEXEC;
bprm->p = (unsigned long)
create_elf_tables((char *)bprm->p,
bprm->argc,
bprm->envc,
&elf_ex,
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->start_data = start_data;
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) %lx\n" , (long) current->mm->start_brk);
printk("(end_code) %lx\n" , (long) current->mm->end_code);
printk("(start_code) %lx\n" , (long) current->mm->start_code);
printk("(start_data) %lx\n" , (long) current->mm->start_data);
printk("(end_data) %lx\n" , (long) current->mm->end_data);
printk("(start_stack) %lx\n" , (long) current->mm->start_stack);
printk("(brk) %lx\n" , (long) current->mm->brk);
#endif
if (current->personality & MMAP_PAGE_ZERO) {
/* 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?? */
down_write(¤t->mm->mmap_sem);
error = do_mmap(NULL, 0, 4096, PROT_READ | PROT_EXEC,
MAP_FIXED | MAP_PRIVATE, 0);
up_write(¤t->mm->mmap_sem);
}
#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. In addition, it may also specify (eg, PowerPC64 ELF)
* that the e_entry field is the address of the function descriptor
* for the startup routine, rather than the address of the startup
* routine itself. This macro performs whatever initialization to
* the regs structure is required as well as any relocations to the
* function descriptor entries when executing dynamically linked apps.
*/
ELF_PLAT_INIT(regs, reloc_func_desc);
#endif
start_thread(regs, elf_entry, bprm->p);
if (current->ptrace & PT_PTRACED)
send_sig(SIGTRAP, current, 0);
retval = 0;
out:
return retval;
/* error cleanup */
out_free_dentry:
allow_write_access(interpreter);
if (interpreter)
fput(interpreter);
out_free_interp:
if (elf_interpreter)
kfree(elf_interpreter);
out_free_file:
sys_close(elf_exec_fileno);
out_free_fh:
if (files) {
put_files_struct(current->files);
current->files = files;
}
out_free_ph:
kfree(elf_phdata);
goto out;
}
int
main( int argc, char **argv)
{
/* Print help if there are no parameters */
if (argc < 2)
print_help();
/* Parse input line */
int opt;
int stoken_size = 1;
bool diff = false;
bool quiet = false;
while (opt = getopt( argc, argv, "dqs:"), opt != -1)
switch (opt) {
case 's':
stoken_size = atoi( optarg);
break;
case 'd':
diff = true;
break;
case 'q':
quiet = true;
break;
case 'h':
default:
print_help();
/* Unreachable */
}
if (stoken_size <= 0) {
fprintf( stderr, "Error: Invalid super-token size\n");
return 6;
}
if (diff) {
if (argc-optind < 2) {
fprintf( stderr, "Error: At least two files must be specified.\n");
return 7;
}
argc = optind+2;
}
/* Do the work */
uint64_t hash1, hash2;
int c = 0;
for (c=optind; c<argc; c++) {
char *data;
long data_length;
get_file( argv[ c], &data, &data_length);
hash2 = hash1;
hash1 = stoken_size == 1
? charikar_hash64( data, data_length) /* Fast version */
: charikar_hash64_wide( data, data_length, stoken_size); /* Fast version */
free( data);
if (!quiet)
printf( "%016llx %s\n", (long long)hash1, argv[ c]);
}
/* Print results */
if (diff) {
uint64_t hashx = hash1^hash2;
int hamm = hamming_dist( hash1, hash2);
if (quiet) {
printf( "%d\n", hamm);
} else {
printf( "%016llx\n", (long long)hashx);
printf( "difference: %d\n", hamm);
}
}
return 0;
}
/**
* Look whether the global file table contains a special file descriptor.
*
* @param fd file descriptor
* @return operation status
*/
bool contains_file(file_nr fd)
{
return ( get_file(fd) != NULL);
}