/* Generate the thread data we need for this group. We must call
** thread_close() before calling this again.
*/
void
thread_open()
{
if (!msgid_hash)
msgid_hash = hashcreate(201, msgid_cmp); /*TODO: pick a better size */
if (ThreadedGroup) {
/* Parse input and use msgid_hash for quick article lookups. */
/* If cached but not threaded articles exist, set up to thread them. */
if (first_subject) {
first_cached = firstart;
last_cached = firstart - 1;
parsed_art = 0;
}
}
if (sel_mode == SM_ARTICLE)
set_selector(sel_mode, sel_artsort);
else
set_selector(sel_threadmode, sel_threadsort);
#ifdef USE_MT
if (try_mt && !first_subject)
if (!mt_data())
return;
#endif
#ifdef USE_OV
if (try_ov && first_cached > last_cached)
if (thread_always)
(void) ov_data(absfirst, lastart, FALSE);
else if (firstart > lastart) {
/* If no unread articles, see if ov. exists as quick as possible */
(void) ov_data(absfirst, absfirst, FALSE);
first_cached = last_cached+1;
} else
(void) ov_data(firstart, lastart, FALSE);
#endif
#ifdef USE_NNTP
if (!ov_opened)
setmissingbits();
#endif
if (last_cached > lastart) {
toread[ng] += (ART_UNREAD)(last_cached-lastart);
/* ensure getngsize() knows the new maximum */
ngmax[ng] = lastart = last_cached;
}
thread_grow(); /* thread any new articles not yet in the database */
added_articles = 0;
sel_page_sp = 0;
sel_page_app = 0;
}
//--------------------------------------------------------------------------
static void load_subspaces(linput_t *li, header &h, long fpos, int n)
{
if ( !n ) return;
char buf[MAXSTR];
for ( int i=0; i < n; i++ )
{
subspace_dictionary_record sr;
qlseek(li, fpos + i*sizeof(sr));
lread(li, &sr, sizeof(sr));
sr.swap();
if ( !sr.is_loadable() || !sr.subspace_length ) continue;
if ( sr.fixup_request_quantity ) complain_fixup();
ea_t start = sr.subspace_start;
ea_t end = start + sr.initialization_length;
file2base(li, sr.file_loc_init_value, start, end, FILEREG_PATCHABLE);
end = start + sr.subspace_length;
char *name = get_space_name(li, h, sr.name.n_strx, buf, sizeof(buf));
set_selector(i, 0);
const char *sclass = strstr(name, "CODE") ? CLASS_CODE : CLASS_DATA;
add_segm(i, start, end, name, sclass);
if ( i == first_text_subspace_idx )
first_text_subspace_fpos = sr.file_loc_init_value;
// sr.alignment,
}
}
//-----------------------------------------------------------------------
static void show_extdefs(linput_t *li, uint32 offset, uint32 length)
{
if ( offset == 0 || length == 0 ) return;
qlseek(li, offset);
inf.specsegs = 1;
int segsize = 4 * h.num_externals;
sel_t sel = h.num_segs+1;
set_selector(sel, 0);
xea = freechunk(inf.maxEA, segsize, -15);
add_segm(sel, xea, xea+segsize, "XTRN", "XTRN");
set_segm_addressing(getseg(xea), true);
int n = 0;
for ( int i=0; i < length; n++ )
{
extdef p;
const int size = offsetof(extdef, allocate_len);
lread(li, &p, size);
p.allocate_len.len_4 = 0;
if ( p.allocate )
{
ask_for_feedback("extdef.allocate\n");
lread(li, &p.allocate_len.len_4, sizeof(p.allocate_len.len_4));
}
int nlen = read_pstring(li, p.sym_name, sizeof(p.sym_name));
i += size + 1 + nlen;
ea_t a = xea + 4*n;
set_name(a, p.sym_name);
if ( p.allocate )
put_long(a, p.allocate_len.len_4);
}
}
//-----------------------------------------------------------------------
static void show_segdefs(linput_t *li, uint32 offset, uint32 length)
{
if ( offset == 0 || length == 0 ) return;
qlseek(li, offset);
int n = 0;
for ( int i=0; i < length; )
{
segdef s;
const int size = offsetof(segdef, combine_name);
lread(li, &s, size);
int nlen = read_pstring(li, s.combine_name, sizeof(s.combine_name));
i += size + 1 + nlen;
n++;
const char *sname = s.combine_name;
const char *sclas = sname;
if ( strnicmp(sname, "CODE", 4) == 0 ) sclas = "CODE";
if ( strnicmp(sname, "DATA", 4) == 0 ) sclas = "DATA";
if ( strnicmp(sname, "CONST", 5) == 0 ) sclas = "CONST";
if ( stricmp(sname, "STACK") == 0 ) sclas = "STACK";
if ( strchr(sname, ':') != NULL ) continue;
int segsize = s.slimit + 1;
if ( strcmp(sname, "DATA") == 0 ) dsel = n;
set_selector(n, 0);
ea_t ea = freechunk(inf.maxEA, segsize, -(1<<s.align));
add_segm(n, ea, ea+segsize, sname, sclas);
set_segm_addressing(getseg(ea), true);
if ( strcmp(sclas, "STACK") == 0 )
doByte(ea, segsize);
}
}
//--------------------------------------------------------------------------
// Create a section.
static void create_section(ushort sel, ea_t startEA, ea_t endEA,
const char *name, const char *classname)
{
set_selector(sel, 0);
if( !add_segm(sel, startEA, endEA, name, classname) )
loader_failure();
segment_t *s = getseg(startEA);
set_arm_segm_flags(startEA, 2 << 10); // alignment
s->update();
}
void
build_cache()
{
if (cached_ng == ng && cached_absfirst == absfirst
&& time((time_t*)NULL) < cached_time + 6*60*60L) {
grow_cache(lastart);
rc_to_bits();
if (sel_mode == SM_ARTICLE)
set_selector(sel_mode, sel_artsort);
else
set_selector(sel_threadmode, sel_threadsort);
thread_grow();
return;
}
close_cache();
cached_ng = ng;
cached_absfirst = absfirst;
cached_time = time((time_t*)NULL);
cached_cnt = lastart-absfirst+2 + 5;
article_list = (ARTICLE*)
safemalloc((MEM_SIZE)(cached_cnt * sizeof (ARTICLE)));
bzero((char*)article_list, cached_cnt * sizeof (ARTICLE));
subj_hash = hashcreate(201, subject_cmp); /*TODO: pick a better size */
rc_to_bits(); /* sets firstart */
first_cached = thread_always? absfirst : firstart;
last_cached = first_cached-1;
cached_all_in_range = FALSE;
#ifdef PENDING
subj_to_get = xref_to_get = firstart;
#endif
#ifndef USE_NNTP
setmissingbits();
#endif
/* Cache as much data in advance as possible, possibly threading
** articles as we go. */
thread_open();
}
//----------------------------------------------------------------------
static void process_loader(char *ptr, pef_section_t *sec, int nsec) {
int i;
pef_loader_t &pl = *(pef_loader_t *)ptr;
pef_library_t *pil = (pef_library_t *)(&pl + 1);
swap_pef_loader(pl);
uint32 *impsym = (uint32 *)(pil + pl.importLibraryCount);
pef_reloc_header_t *prh =
(pef_reloc_header_t *)(impsym + pl.totalImportedSymbolCount);
uint16 *relptr = (uint16 *)(ptr + pl.relocInstrOffset);
uint32 *hash = (uint32 *)(ptr + pl.exportHashOffset);
uint32 hashsize = (1 << pl.exportHashTablePower);
uint32 *keytable = hash + hashsize;
pef_export_t *pe = (pef_export_t *)(keytable + pl.exportedSymbolCount);
#if !__MF__
for ( i=0; i < pl.importLibraryCount; i++ )
swap_pef_library(pil[i]);
for ( i=0; i < pl.relocSectionCount; i++ )
swap_pef_reloc_header(prh[i]);
for ( i=0; i < pl.exportedSymbolCount; i++ )
swap_pef_export(pe[i]);
#endif
char *stable = ptr + pl.loaderStringsOffset;
if ( pl.totalImportedSymbolCount != 0 ) {
uint32 size = pl.totalImportedSymbolCount*4;
ea_t undef = freechunk(inf.maxEA, size, -0xF);
ea_t end = undef + size;
set_selector(nsec+1, 0);
if(!add_segm(nsec+1, undef, end, "IMPORT", "XTRN")) loader_failure();
for ( i=0; i < pl.importLibraryCount; i++ ) {
ea_t ea = undef + 4*pil[i].firstImportedSymbol;
add_long_cmt(ea, 1, "Imports from library %s", stable+pil[i].nameOffset);
if ( pil[i].options & PEF_LIB_WEAK )
add_long_cmt(ea, 1, "Library is weak");
}
inf.specsegs = 1;
for ( i=0; i < pl.totalImportedSymbolCount; i++ ) {
uint32 sym = mflong(impsym[i]);
uchar sclass = uchar(sym >> 24);
ea_t ea = undef+4*i;
set_name(ea, get_impsym_name(stable,impsym,i));
if ( (sclass & kPEFWeak) != 0 ) make_name_weak(ea);
doDwrd(ea,4);
put_long(ea, 0);
impsym[i] = (uint32)ea;
}
}
void idaapi load_file(linput_t *fp, ushort neflag, const char * /*fileformatname*/)
{
// Hello here I am
msg("---------------------------------------\n");
msg("Nintendo REL Loader Plugin 0.1\n");
msg("---------------------------------------\n");
// we need PowerPC support to do anything with rels
if (ph.id != PLFM_PPC)
set_processor_type("PPC", SETPROC_ALL | SETPROC_FATAL);
set_compiler_id(COMP_GNU);
rel_track track(fp);
inf.beginEA = START;
// map selector 1 to 0
set_selector(1, 0);
track.apply_patches();
}
uint8_t scan_line(uint8_t selector) {
set_selector(selector);
_delay_us(100);
return(read_keys());
}
char *wd_filemask(const char *mask)
{
int button;
int i;
XDINFO info;
boolean stop = FALSE, redraw, dc, ok;
FTYPE *f;
SNAME name, newmask; /* HR 240203 */
char *result;
SLIDER sl;
sl.type = 1;
sl.up_arrow = FTUP;
sl.down_arrow = FTDOWN;
sl.slider = FTSLIDER;
sl.sparent = FTSPAR;
sl.lines = NLINES;
sl.n = cnt_types();
sl.line = 0;
sl.set_selector = set_selector;
sl.first = FTYPE1;
sl.findsel = find_selected;
/* DjV 004 290103 ---vvv--- */
if ( mask == NULL )
{
setmask[FILETYPE].ob_state |= DISABLED;
*setmask[FILETYPE].ob_spec.tedinfo->te_ptext = 0;
}
else
{
/* DjV 004 290103 ---^^^--- */
cv_fntoform(setmask + FILETYPE, mask); /* HR 240103 */
setmask[FILETYPE].ob_state &= ~DISABLED; /* DjV 004 290103 */
} /* DjV 004 290103 */
/* DjV 004 020103 Put file attributes buttons into right state */
set_opt( setmask, options.attribs, FA_HIDDEN, MSKHID );
set_opt( setmask, options.attribs, FA_SYSTEM, MSKSYS );
set_opt( setmask, options.attribs, FA_SUBDIR, MSKDIR );
set_opt( setmask, options.attribs, FA_PARDIR, MSKPAR );
sl_init(setmask, &sl);
xd_open(setmask, &info);
while (stop == FALSE)
{
redraw = FALSE;
button = sl_form_do(setmask, FILETYPE, &sl, &info);
dc = (button & 0x8000) ? TRUE : FALSE;
button &= 0x7FFF;
if ((button < FTYPE1) || (button > FTYPE4))
{
switch (button)
{
case FTADD:
name[0] = 0;
if (filetype_dialog(name) == TRUE)
{
add(name);
sl.n = cnt_types();
redraw = TRUE;
sl_set_slider(setmask, &sl, &info);
}
break;
case FTDELETE:
i = find_selected() + sl.line;
if ((f = get_item(i)) != NULL)
{
rem(f);
sl.n = cnt_types();
redraw = TRUE;
sl_set_slider(setmask, &sl, &info);
}
break;
default:
ok = (button == FTOK) ? TRUE : FALSE;
stop = TRUE;
break;
}
xd_change(&info, button, NORMAL, (stop == FALSE) ? 1 : 0);
}
else if ( button >= MSKHID && button <= MSKPAR )
{
/* DjV 004 020103 do nothing until exit */
}
else
{
strcpy(filetype, setmask[button].ob_spec.tedinfo->te_ptext);
xd_draw(&info, FILETYPE, 1);
if (dc == TRUE)
{
ok = TRUE;
stop = TRUE;
}
}
if (redraw == TRUE)
set_selector(&sl, TRUE, &info);
}
xd_close(&info);
if (ok == TRUE)
{
/* DjV 004 030103 ---vvv--- */
get_opt( setmask, &options.attribs, FA_HIDDEN, MSKHID );
get_opt( setmask, &options.attribs, FA_SYSTEM, MSKSYS );
get_opt( setmask, &options.attribs, FA_SUBDIR, MSKDIR ); /* DjV 004 280103 wrongly was MSKHID */
get_opt( setmask, &options.attribs, FA_PARDIR, MSKPAR );
/* DjV 004 020103 ---^^^--- */
if ( mask == NULL ) /* DjV 004 290103 */
return NULL; /* DjV 004 290103 */
else /* DjV 004 290103 */
{ /* DjV 004 290103 */
cv_formtofn(newmask, filetype);
if ((result = malloc(strlen(newmask) + 1)) != NULL)
strcpy(result, newmask);
else
xform_error(ENSMEM);
return result;
} /* DjV 004 290103 */
}
else
return NULL;
}
int check_mixer_ioctls(int fd_mixer)
{
int nb_err, err = 0;
int ret, val;
ret = ioctl(fd_mixer, SOUND_MIXER_READ_DEVMASK, &val);
if (ret != 0) {
DPRINTF
("Returned Value Error with IOCTL SOUND_MIXER_READ_DEVMASK %d\n",
ret);
err++;
}
#ifdef CONFIG_MX21ADS
if (val != (SOUND_MASK_VOLUME | SOUND_MASK_LINE | SOUND_MASK_MIC)) {
#else
if (val != (SOUND_MASK_VOLUME | SOUND_MASK_PCM | SOUND_MASK_SPEAKER |
SOUND_MASK_PHONEOUT | SOUND_MASK_LINE |
SOUND_MASK_PHONEIN | SOUND_MASK_MIC)) {
#endif
DPRINTF("Error with IOCTL SOUND_MIXER_READ_DEVMASK %x\n", val);
err++;
}
ret = ioctl(fd_mixer, SOUND_MIXER_READ_RECMASK, &val);
if (ret != 0) {
DPRINTF
("Returned Value Error with IOCTL SOUND_MIXER_READ_RECMASK\n");
err++;
}
#ifdef CONFIG_MX21ADS
if (val != (SOUND_MASK_LINE | SOUND_MASK_MIC)) {
#else
if (val != (SOUND_MASK_LINE | SOUND_MASK_PHONEIN | SOUND_MASK_MIC)) {
#endif
DPRINTF("Error with IOCTL SOUND_MIXER_READ_RECMASK %x\n", val);
err++;
}
ret = ioctl(fd_mixer, SOUND_MIXER_READ_OUTMASK, &val);
if (ret != 0) {
DPRINTF
("Returned Value Error with IOCTL SOUND_MIXER_READ_OUTMASK\n");
err++;
}
#ifdef CONFIG_MX21ADS
if (val != SOUND_MASK_VOLUME) {
#else
if (val != (SOUND_MASK_VOLUME | SOUND_MASK_PCM | SOUND_MASK_SPEAKER
| SOUND_MASK_PHONEOUT)) {
#endif
DPRINTF("Error with IOCTL SOUND_MIXER_READ_OUTMASK\n");
err++;
}
ret = ioctl(fd_mixer, SOUND_MIXER_READ_STEREODEVS, &val);
if (ret != 0) {
DPRINTF
("Returned Value Error with IOCTL SOUND_MIXER_READ_STEREODEVS\n");
err++;
}
#ifdef CONFIG_MX21ADS
if (val != (SOUND_MASK_VOLUME | SOUND_MASK_LINE)) {
#else
if (val != (SOUND_MASK_VOLUME | SOUND_MASK_PHONEIN | SOUND_MASK_PCM)) {
#endif
DPRINTF("Error with IOCTL SOUND_MIXER_READ_STEREODEVS\n");
err++;
}
ret = ioctl(fd_mixer, SOUND_MIXER_READ_CAPS, &val);
if (ret != 0) {
DPRINTF
("Returned Value Error with IOCTL SOUND_MIXER_READ_CAPS\n");
err++;
}
if (val != SOUND_CAP_EXCL_INPUT) {
DPRINTF("Error with IOCTL SOUND_MIXER_READ_CAPS\n");
err++;
}
ret = ioctl(fd_mixer, SOUND_MIXER_READ_RECSRC, &val);
if (ret != 0) {
DPRINTF
("Returned Value Error with IOCTL SOUND_MIXER_READ_RECSRC\n");
err++;
}
#ifdef CONFIG_MX21ADS
if ((val != SOUND_MASK_LINE) && (val != SOUND_MASK_MIC)) {
#else
if ((val != SOUND_MASK_LINE) && (val != SOUND_MASK_PHONEIN) &&
(val != SOUND_MASK_MIC)) {
#endif
DPRINTF("Error with IOCTL SOUND_MIXER_READ_RECSRC\n");
err++;
}
/** Input source selection and volume control */
#ifndef CONFIG_MX21ADS
nb_err = set_input_device(fd_mixer, SOUND_MASK_PHONEIN);
if (nb_err) {
DPRINTF
("Error with IOCTL SOUND_MIXER_WRITE_RECSRC (SOUND_MASK_PHONEIN)\n");
err += nb_err;
}
#endif
nb_err = set_input_device(fd_mixer, SOUND_MASK_LINE);
if (nb_err) {
DPRINTF
("Error with IOCTL SOUND_MIXER_WRITE_RECSRC (SOUND_MASK_LINE)\n");
err += nb_err;
}
nb_err = set_input_device(fd_mixer, SOUND_MASK_MIC);
if (nb_err) {
DPRINTF
("Error with IOCTL SOUND_MIXER_WRITE_RECSRC (SOUND_MASK_MIC)\n");
err += nb_err;
}
#ifndef CONFIG_MX21ADS
nb_err = set_input_device(fd_mixer, SOUND_MASK_PHONEIN);
if (nb_err) {
DPRINTF
("Error with IOCTL SOUND_MIXER_WRITE_RECSRC (SOUND_MASK_PHONEIN)\n");
err += nb_err;
}
#endif
#ifndef CONFIG_MX21ADS
nb_err = set_input_device(fd_mixer, SOUND_MASK_PHONEIN);
if (nb_err) {
DPRINTF
("Error with IOCTL SOUND_MIXER_WRITE_RECSRC (SOUND_MASK_PHONEIN)\n");
err += nb_err;
}
#endif
/** Output source selection and volume control */
nb_err = set_output_device(fd_mixer, SOUND_MASK_VOLUME);
if (nb_err) {
DPRINTF
("Error with IOCTL SOUND_MIXER_WRITE_OUTSRC (SOUND_MASK_VOLUME) \n");
err += nb_err;
}
#ifndef CONFIG_MX21ADS
nb_err = set_output_device(fd_mixer, SOUND_MASK_PCM);
if (nb_err) {
DPRINTF
("Error with IOCTL SOUND_MIXER_WRITE_OUTSRC (SOUND_MASK_PCM)\n");
err += nb_err;
}
#endif
#ifndef CONFIG_MX21ADS
nb_err = set_output_device(fd_mixer, SOUND_MASK_SPEAKER);
if (nb_err) {
DPRINTF
("Error with IOCTL SOUND_MIXER_WRITE_OUTSRC (SOUND_MASK_SPEAKER)\n");
err += nb_err;
}
#endif
#ifndef CONFIG_MX21ADS
nb_err = set_output_device(fd_mixer, SOUND_MASK_PHONEOUT);
if (nb_err) {
DPRINTF
("Error with IOCTL SOUND_MIXER_WRITE_OUTSRC (SOUND_MASK_PHONEOUT)\n");
err += nb_err;
}
#endif
nb_err = set_output_device(fd_mixer, SOUND_MASK_VOLUME);
if (nb_err) {
DPRINTF
("Error with IOCTL SOUND_MIXER_WRITE_OUTSRC (SOUND_MASK_VOLUME)\n");
err += nb_err;
}
return err;
}
/*! Supposes that StDac is selected. Selects all output lines */
int setup_sound_driver(int fd_audio)
{
int err = 0;
err += set_selector(fd_audio, SOUND_MASK_VOLUME | SOUND_MASK_PCM |
SOUND_MASK_SPEAKER | SOUND_MASK_PHONEOUT);
return err;
}
int main(int ac, char *av[])
{
int fd_audio, fd_mixer;
int err = 0;
DPRINTF("Hi... \n");
if (ac == 1) {
DPRINTF
("This program checks that IOCTLs are correctly implemented \n");
DPRINTF(" --> main <no_arg>\n\n");
}
if ((fd_audio = open("/dev/sound/dsp1", O_WRONLY)) < 0) {
DPRINTF("Error opening /dev/dsp\n");
return 0;
}
if ((fd_mixer = open("/dev/sound/mixer", O_RDWR)) < 0) {
DPRINTF("Error opening /dev/mixer\n");
return 0;
}
if (setup_sound_driver(fd_audio)) {
return 1;
}
/*************************************** MIXER IOCTLs ****************************************/
err += check_mixer_ioctls(fd_mixer);
/*************************************** AUDIO IOCTLs ****************************************/
err += check_audio_ioctls(fd_audio);
/*************************************** END ****************************************/
close(fd_audio);
close(fd_mixer);
if (!err) {
printf("All tests passed with success\n");
} else {
printf("Encountered %d errors\n", err);
}
return 0;
}
static void iret() {
set_selector(&cs, RPL_USER, SEG_USER_CODE);
set_selector(&ss, RPL_USER, SEG_USER_DATA);
}
void do_irq() {
set_selector(&ss, RPL_KERNEL, SEG_KERNEL_DATA);
set_selector(&cs, RPL_KERNEL, SEG_KERNEL_CODE);
/* now the system is in kernel mode */
}
