void
get16s(u16int *p, int n)
{
while(n--)
*p++ = get16();
}
void
loadstate(char *file)
{
bp = Bopen(file, OREAD);
if(bp == nil){
message("open: %r");
return;
}
Bread(bp, reg, sizeof(reg));
Bread(bp, mem, sizeof(mem));
Bread(bp, vram, sizeof(vram));
Bread(bp, oam, sizeof(oam));
Bread(bp, spcmem, sizeof(spcmem));
Bread(bp, dsp, sizeof(dsp));
get16s(cgram, nelem(cgram));
ppuclock = get32();
spcclock = get32();
dspclock = get32();
stimerclock = get32();
rA = get16();
rX = get16();
rY = get16();
rS = get16();
rP = get8();
rD = get16();
rDB = get8()<<16;
pc = get16();
rPB = get8()<<16;
emu = get8();
irq = get8();
nmi = get8();
dma = get8();
hdma = get32();
wai = get8();
mdr = get8();
mdr1 = get8();
mdr2 = get8();
oamaddr = get16();
vramlatch = get16();
keylatch = get32();
ppux = get16();
ppuy = get16();
htime = reg[0x4207] | reg[0x4208] << 8 & 0x100;
vtime = reg[0x4209] | reg[0x420a] << 8 & 0x100;
subcolor = get16();
get16s(hofs, nelem(hofs));
get16s(vofs, nelem(vofs));
get16s((u16int*) m7, nelem(m7));
sA = get8();
sX = get8();
sY = get8();
sS = get8();
sP = get8();
dspstate = get8();
dspcounter = get16();
noise = get16();
Bread(bp, spctimer, sizeof(spctimer));
dspload();
Bterm(bp);
}
static int
update_stats (KEYBOXBLOB blob, struct file_stats_s *s)
{
const unsigned char *buffer;
size_t length;
int type;
unsigned long n;
buffer = _keybox_get_blob_image (blob, &length);
if (length < 32)
{
s->too_short_blobs++;
return -1;
}
n = get32( buffer );
if (n > length)
s->too_large_blobs++;
else
length = n; /* ignore the rest */
s->total_blob_count++;
type = buffer[4];
switch (type)
{
case BLOBTYPE_EMPTY:
s->empty_blob_count++;
return 0;
case BLOBTYPE_HEADER:
s->header_blob_count++;
return 0;
case BLOBTYPE_PGP:
s->pgp_blob_count++;
break;
case BLOBTYPE_X509:
s->x509_blob_count++;
break;
default:
s->unknown_blob_count++;
return 0;
}
if (length < 40)
{
s->too_short_blobs++;
return -1;
}
n = get16 (buffer + 6);
if (n)
{
if ((n & 1))
s->secret_flagged++;
if ((n & 2))
s->ephemeral_flagged++;
}
else
s->non_flagged++;
return 0;
}
int
loadstl(FILE *fp, char *comment, float **vertp, vertex_t *nvertp, vertex_t **trip, uint16_t **attrp, triangle_t *ntrip)
{
uint8_t buf[128];
triangle_t i, ti;
vertex_t *tris;
triangle_t ntris;
vertex_t *vht, vi, nverts, vhtcap;
uint32_t *verts;
uint16_t *attrs;
// the comment and triangle count
if(fread(buf, 84, 1, fp) != 1){
fprintf(stderr, "loadstl: short read at header\n");
return -1;
}
if(comment != NULL)
memcpy(comment, buf, 80);
ntris = get32(buf+80);
tris = malloc(ntris * 3*sizeof tris[0]);
attrs = malloc(ntris * sizeof attrs[0]);
verts = malloc(3*ntris * 3*sizeof verts[0]);
vhtcap = nextpow2(4*ntris);
vht = malloc(vhtcap * sizeof vht[0]);
memset(vht, 0, vhtcap * sizeof vht[0]);
fprintf(stderr, "loadstl: number of triangles: %u, vhtcap %d\n", ntris, vhtcap);
nverts = 0;
for(i = 0; i < ntris; i++){
if(fread(buf, 50, 1, fp) != 1){
fprintf(stderr, "loadstl: short read at triangle %d/%d\n", i, ntris);
goto exit_fail;
}
// there's a normal vector at buf[0..11] which we are ignoring
for(ti = 0; ti < 3; ti++){
uint32_t vert[3];
vert[0] = get32(buf+12 + 4*3*ti);
vert[1] = get32(buf+12 + 4*3*ti+4);
vert[2] = get32(buf+12 + 4*3*ti+8);
vi = vertex(verts, nverts, vht, vhtcap, vert);
if(vi == ~(uint32_t)0){
fprintf(stderr, "loadstl: vertex hash full at triangle %d/%d\n", i, ntris);
goto exit_fail;
}
if(vi == nverts){
copy96(verts + 3*nverts, vert);
nverts++;
} else {
}
tris[3*i+ti] = vi;
}
attrs[i] = get16(buf + 48);
}
fprintf(stderr, "loadstl: number of verts: %u\n", nverts);
free(vht);
verts = realloc(verts, nverts * 3*sizeof verts[0]);
*vertp = (float *)verts;
*nvertp = nverts;
*trip = tris;
*attrp = attrs;
*ntrip = ntris;
return 0;
exit_fail:
free(vht);
free(verts);
free(tris);
free(attrs);
return -1;
}
/* Dump one block to FP */
int
_keybox_dump_blob (KEYBOXBLOB blob, FILE *fp)
{
const byte *buffer;
size_t length;
int type;
ulong n, nkeys, keyinfolen;
ulong nuids, uidinfolen;
ulong nsigs, siginfolen;
ulong rawdata_off, rawdata_len;
ulong nserial;
const byte *p;
buffer = _keybox_get_blob_image (blob, &length);
if (length < 32)
{
fprintf (fp, "[blob too short]\n");
return -1;
}
n = get32( buffer );
if (n > length)
fprintf (fp, "[blob larger than length - output truncated]\n");
else
length = n; /* ignore the rest */
fprintf (fp, "Length: %lu\n", n );
type = buffer[4];
switch (type)
{
case BLOBTYPE_EMPTY:
fprintf (fp, "Type: Empty\n");
return 0;
case BLOBTYPE_HEADER:
fprintf (fp, "Type: Header\n");
return dump_header_blob (buffer, length, fp);
case BLOBTYPE_PGP:
fprintf (fp, "Type: OpenPGP\n");
break;
case BLOBTYPE_X509:
fprintf (fp, "Type: X.509\n");
break;
default:
fprintf (fp, "Type: %d\n", type);
fprintf (fp, "[can't dump this blob type]\n");
return 0;
}
fprintf (fp, "Version: %d\n", buffer[5]);
if (length < 40)
{
fprintf (fp, "[blob too short]\n");
return -1;
}
n = get16 (buffer + 6);
fprintf( fp, "Blob-Flags: %04lX", n);
if (n)
{
int any = 0;
fputs (" (", fp);
if ((n & 1))
{
fputs ("secret", fp);
any++;
}
if ((n & 2))
{
if (any)
putc (',', fp);
fputs ("ephemeral", fp);
any++;
}
putc (')', fp);
}
putc ('\n', fp);
rawdata_off = get32 (buffer + 8);
rawdata_len = get32 (buffer + 12);
fprintf( fp, "Data-Offset: %lu\n", rawdata_off );
fprintf( fp, "Data-Length: %lu\n", rawdata_len );
if (rawdata_off > length || rawdata_len > length
|| rawdata_off+rawdata_off > length)
fprintf (fp, "[Error: raw data larger than blob]\n");
nkeys = get16 (buffer + 16);
fprintf (fp, "Key-Count: %lu\n", nkeys );
if (!nkeys)
fprintf (fp, "[Error: no keys]\n");
if (nkeys > 1 && type == BLOBTYPE_X509)
fprintf (fp, "[Error: only one key allowed for X509]\n");
keyinfolen = get16 (buffer + 18 );
fprintf (fp, "Key-Info-Length: %lu\n", keyinfolen);
/* fixme: check bounds */
p = buffer + 20;
for (n=0; n < nkeys; n++, p += keyinfolen)
{
int i;
ulong kidoff, kflags;
fprintf (fp, "Key-Fpr[%lu]: ", n );
for (i=0; i < 20; i++ )
fprintf (fp, "%02X", p[i]);
kidoff = get32 (p + 20);
fprintf (fp, "\nKey-Kid-Off[%lu]: %lu\n", n, kidoff );
fprintf (fp, "Key-Kid[%lu]: ", n );
/* fixme: check bounds */
for (i=0; i < 8; i++ )
fprintf (fp, "%02X", buffer[kidoff+i] );
kflags = get16 (p + 24 );
fprintf( fp, "\nKey-Flags[%lu]: %04lX\n", n, kflags);
}
/* serial number */
fputs ("Serial-No: ", fp);
nserial = get16 (p);
p += 2;
if (!nserial)
fputs ("none", fp);
else
{
for (; nserial; nserial--, p++)
fprintf (fp, "%02X", *p);
}
putc ('\n', fp);
/* user IDs */
nuids = get16 (p);
fprintf (fp, "Uid-Count: %lu\n", nuids );
uidinfolen = get16 (p + 2);
fprintf (fp, "Uid-Info-Length: %lu\n", uidinfolen);
/* fixme: check bounds */
p += 4;
for (n=0; n < nuids; n++, p += uidinfolen)
{
ulong uidoff, uidlen, uflags;
uidoff = get32( p );
uidlen = get32( p+4 );
if (type == BLOBTYPE_X509 && !n)
{
fprintf (fp, "Issuer-Off: %lu\n", uidoff );
fprintf (fp, "Issuer-Len: %lu\n", uidlen );
fprintf (fp, "Issuer: \"");
}
else if (type == BLOBTYPE_X509 && n == 1)
{
fprintf (fp, "Subject-Off: %lu\n", uidoff );
fprintf (fp, "Subject-Len: %lu\n", uidlen );
fprintf (fp, "Subject: \"");
}
else
{
fprintf (fp, "Uid-Off[%lu]: %lu\n", n, uidoff );
fprintf (fp, "Uid-Len[%lu]: %lu\n", n, uidlen );
fprintf (fp, "Uid[%lu]: \"", n );
}
print_string (fp, buffer+uidoff, uidlen, '\"');
fputs ("\"\n", fp);
uflags = get16 (p + 8);
if (type == BLOBTYPE_X509 && !n)
{
fprintf (fp, "Issuer-Flags: %04lX\n", uflags );
fprintf (fp, "Issuer-Validity: %d\n", p[10] );
}
else if (type == BLOBTYPE_X509 && n == 1)
{
fprintf (fp, "Subject-Flags: %04lX\n", uflags );
fprintf (fp, "Subject-Validity: %d\n", p[10] );
}
else
{
fprintf (fp, "Uid-Flags[%lu]: %04lX\n", n, uflags );
fprintf (fp, "Uid-Validity[%lu]: %d\n", n, p[10] );
}
}
nsigs = get16 (p);
fprintf (fp, "Sig-Count: %lu\n", nsigs );
siginfolen = get16 (p + 2);
fprintf (fp, "Sig-Info-Length: %lu\n", siginfolen );
/* fixme: check bounds */
p += 4;
for (n=0; n < nsigs; n++, p += siginfolen)
{
ulong sflags;
sflags = get32 (p);
fprintf (fp, "Sig-Expire[%lu]: ", n );
if (!sflags)
fputs ("[not checked]", fp);
else if (sflags == 1 )
fputs ("[missing key]", fp);
else if (sflags == 2 )
fputs ("[bad signature]", fp);
else if (sflags < 0x10000000)
fprintf (fp, "[bad flag %0lx]", sflags);
else if (sflags == 0xffffffff)
fputs ("0", fp );
else
fputs ("a time"/*strtimestamp( sflags )*/, fp );
putc ('\n', fp );
}
fprintf (fp, "Ownertrust: %d\n", p[0] );
fprintf (fp, "All-Validity: %d\n", p[1] );
p += 4;
n = get32 (p); p += 4;
fprintf (fp, "Recheck-After: %lu\n", n );
n = get32 (p ); p += 4;
fprintf( fp, "Latest-Timestamp: %lu\n", n );
n = get32 (p ); p += 4;
fprintf (fp, "Created-At: %lu\n", n );
n = get32 (p ); p += 4;
fprintf (fp, "Reserved-Space: %lu\n", n );
/* check that the keyblock is at the correct offset and other bounds */
/*fprintf (fp, "Blob-Checksum: [MD5-hash]\n");*/
return 0;
}
/* Pull TCP header off mbuf */
int
ntohtcp(
struct tcp *tcph,
struct mbuf **bpp
){
int hdrlen,i,optlen,kind;
register int flags;
uint8 hdrbuf[TCPLEN],*cp;
uint8 options[TCP_MAXOPT];
memset(tcph,0,sizeof(struct tcp));
i = pullup(bpp,hdrbuf,TCPLEN);
/* Note that the results will be garbage if the header is too short.
* We don't check for this because returned ICMP messages will be
* truncated, and we at least want to get the port numbers.
*/
tcph->source = get16(&hdrbuf[0]);
tcph->dest = get16(&hdrbuf[2]);
tcph->seq = get32(&hdrbuf[4]);
tcph->ack = get32(&hdrbuf[8]);
hdrlen = (hdrbuf[12] & 0xf0) >> 2;
flags = hdrbuf[13];
tcph->flags.congest = (flags & 64) ? 1 : 0;
tcph->flags.urg = (flags & 32) ? 1 : 0;
tcph->flags.ack = (flags & 16) ? 1 : 0;
tcph->flags.psh = (flags & 8) ? 1 : 0;
tcph->flags.rst = (flags & 4) ? 1 : 0;
tcph->flags.syn = (flags & 2) ? 1 : 0;
tcph->flags.fin = (flags & 1) ? 1 : 0;
tcph->wnd = get16(&hdrbuf[14]);
tcph->checksum = get16(&hdrbuf[16]);
tcph->up = get16(&hdrbuf[18]);
optlen = hdrlen - TCPLEN;
/* Check for option field */
if(i < TCPLEN || hdrlen < TCPLEN)
return -1; /* Header smaller than legal minimum */
if(optlen == 0)
return (int)hdrlen; /* No options, all done */
if(optlen > len_p(*bpp)){
/* Remainder too short for options length specified */
return -1;
}
pullup(bpp,options,optlen); /* "Can't fail" */
/* Process options */
for(cp=options,i=optlen; i > 0;){
kind = *cp++;
i--;
/* Process single-byte options */
switch(kind){
case EOL_KIND:
return (int)hdrlen; /* End of options list */
case NOOP_KIND:
continue; /* Go look for next option */
}
/* All other options have a length field */
optlen = *cp++;
/* Process valid multi-byte options */
switch(kind){
case MSS_KIND:
if(optlen == MSS_LENGTH){
tcph->mss = get16(cp);
tcph->flags.mss = 1;
}
break;
case WSCALE_KIND:
if(optlen == WSCALE_LENGTH){
tcph->wsopt = *cp;
tcph->flags.wscale = 1;
}
break;
case TSTAMP_KIND:
if(optlen == TSTAMP_LENGTH){
tcph->tsval = get32(cp);
tcph->tsecr = get32(cp+4);
tcph->flags.tstamp = 1;
}
break;
}
optlen = max(2,optlen); /* Enforce legal minimum */
i -= optlen;
cp += optlen - 2;
}
return (int)hdrlen;
}
static void sdt_cb(MpegTSFilter *filter, const uint8_t *section, int section_len)
{
MpegTSContext *ts = filter->u.section_filter.opaque;
SectionHeader h1, *h = &h1;
const uint8_t *p, *p_end, *desc_list_end, *desc_end;
int onid, val, sid, desc_list_len, desc_tag, desc_len, service_type;
char *name, *provider_name;
#ifdef DEBUG
dprintf(ts->stream, "SDT:\n");
av_hex_dump_log(ts->stream, AV_LOG_DEBUG, (uint8_t *)section, section_len);
#endif
p_end = section + section_len - 4;
p = section;
if (parse_section_header(h, &p, p_end) < 0)
return;
if (h->tid != SDT_TID)
return;
onid = get16(&p, p_end);
if (onid < 0)
return;
val = get8(&p, p_end);
if (val < 0)
return;
for(;;) {
sid = get16(&p, p_end);
if (sid < 0)
break;
val = get8(&p, p_end);
if (val < 0)
break;
desc_list_len = get16(&p, p_end) & 0xfff;
if (desc_list_len < 0)
break;
desc_list_end = p + desc_list_len;
if (desc_list_end > p_end)
break;
for(;;) {
desc_tag = get8(&p, desc_list_end);
if (desc_tag < 0)
break;
desc_len = get8(&p, desc_list_end);
desc_end = p + desc_len;
if (desc_end > desc_list_end)
break;
dprintf(ts->stream, "tag: 0x%02x len=%d\n",
desc_tag, desc_len);
switch(desc_tag) {
case 0x48:
service_type = get8(&p, p_end);
if (service_type < 0)
break;
provider_name = getstr8(&p, p_end);
if (!provider_name)
break;
name = getstr8(&p, p_end);
if (name) {
AVProgram *program = av_new_program(ts->stream, sid);
if(program) {
av_metadata_set(&program->metadata, "name", name);
av_metadata_set(&program->metadata, "provider_name", provider_name);
}
}
av_free(name);
av_free(provider_name);
break;
default:
break;
}
p = desc_end;
}
p = desc_list_end;
}
}
static void pmt_cb(MpegTSFilter *filter, const uint8_t *section, int section_len)
{
MpegTSContext *ts = filter->u.section_filter.opaque;
SectionHeader h1, *h = &h1;
PESContext *pes;
AVStream *st;
const uint8_t *p, *p_end, *desc_list_end, *desc_end;
int program_info_length, pcr_pid, pid, stream_type;
int desc_list_len, desc_len, desc_tag;
int comp_page, anc_page;
char language[4];
uint32_t prog_reg_desc = 0; /* registration descriptor */
#ifdef DEBUG
dprintf(ts->stream, "PMT: len %i\n", section_len);
av_hex_dump_log(ts->stream, AV_LOG_DEBUG, (uint8_t *)section, section_len);
#endif
p_end = section + section_len - 4;
p = section;
if (parse_section_header(h, &p, p_end) < 0)
return;
dprintf(ts->stream, "sid=0x%x sec_num=%d/%d\n",
h->id, h->sec_num, h->last_sec_num);
if (h->tid != PMT_TID)
return;
clear_program(ts, h->id);
pcr_pid = get16(&p, p_end) & 0x1fff;
if (pcr_pid < 0)
return;
add_pid_to_pmt(ts, h->id, pcr_pid);
dprintf(ts->stream, "pcr_pid=0x%x\n", pcr_pid);
program_info_length = get16(&p, p_end) & 0xfff;
if (program_info_length < 0)
return;
while(program_info_length >= 2) {
uint8_t tag, len;
tag = get8(&p, p_end);
len = get8(&p, p_end);
if(len > program_info_length - 2)
//something else is broken, exit the program_descriptors_loop
break;
program_info_length -= len + 2;
if(tag == 0x05 && len >= 4) { // registration descriptor
prog_reg_desc = bytestream_get_le32(&p);
len -= 4;
}
p += len;
}
p += program_info_length;
if (p >= p_end)
return;
// stop parsing after pmt, we found header
if (!ts->stream->nb_streams)
ts->stop_parse = 1;
for(;;) {
st = 0;
stream_type = get8(&p, p_end);
if (stream_type < 0)
break;
pid = get16(&p, p_end) & 0x1fff;
if (pid < 0)
break;
/* now create ffmpeg stream */
if (ts->pids[pid] && ts->pids[pid]->type == MPEGTS_PES) {
pes = ts->pids[pid]->u.pes_filter.opaque;
st = pes->st;
} else {
if (ts->pids[pid]) mpegts_close_filter(ts, ts->pids[pid]); //wrongly added sdt filter probably
pes = add_pes_stream(ts, pid, pcr_pid, stream_type);
if (pes)
st = new_pes_av_stream(pes, prog_reg_desc, 0);
}
if (!st)
return;
add_pid_to_pmt(ts, h->id, pid);
av_program_add_stream_index(ts->stream, h->id, st->index);
desc_list_len = get16(&p, p_end) & 0xfff;
if (desc_list_len < 0)
break;
desc_list_end = p + desc_list_len;
if (desc_list_end > p_end)
break;
for(;;) {
desc_tag = get8(&p, desc_list_end);
if (desc_tag < 0)
break;
desc_len = get8(&p, desc_list_end);
if (desc_len < 0)
break;
desc_end = p + desc_len;
if (desc_end > desc_list_end)
break;
dprintf(ts->stream, "tag: 0x%02x len=%d\n",
desc_tag, desc_len);
if (st->codec->codec_id == CODEC_ID_NONE &&
stream_type == STREAM_TYPE_PRIVATE_DATA)
mpegts_find_stream_type(st, desc_tag, DESC_types);
switch(desc_tag) {
case 0x59: /* subtitling descriptor */
language[0] = get8(&p, desc_end);
language[1] = get8(&p, desc_end);
language[2] = get8(&p, desc_end);
language[3] = 0;
get8(&p, desc_end);
comp_page = get16(&p, desc_end);
anc_page = get16(&p, desc_end);
st->codec->sub_id = (anc_page << 16) | comp_page;
av_metadata_set(&st->metadata, "language", language);
break;
case 0x0a: /* ISO 639 language descriptor */
language[0] = get8(&p, desc_end);
language[1] = get8(&p, desc_end);
language[2] = get8(&p, desc_end);
language[3] = 0;
av_metadata_set(&st->metadata, "language", language);
break;
case 0x05: /* registration descriptor */
st->codec->codec_tag = bytestream_get_le32(&p);
dprintf(ts->stream, "reg_desc=%.4s\n", (char*)&st->codec->codec_tag);
if (st->codec->codec_id == CODEC_ID_NONE &&
stream_type == STREAM_TYPE_PRIVATE_DATA)
mpegts_find_stream_type(st, st->codec->codec_tag, REGD_types);
break;
default:
break;
}
p = desc_end;
}
p = desc_list_end;
}
/* all parameters are there */
mpegts_close_filter(ts, filter);
}
LocalAddressSpace::pint_t
LocalAddressSpace::getEncodedP(pint_t& addr, pint_t end, uint8_t encoding)
{
pint_t startAddr = addr;
const uint8_t* p = (uint8_t*)addr;
pint_t result;
// first get value
switch (encoding & 0x0F) {
case DW_EH_PE_ptr:
result = getP(addr);
p += sizeof(pint_t);
addr = (pint_t)p;
break;
case DW_EH_PE_uleb128:
result = getULEB128(addr, end);
break;
case DW_EH_PE_udata2:
result = get16(addr);
p += 2;
addr = (pint_t)p;
break;
case DW_EH_PE_udata4:
result = get32(addr);
p += 4;
addr = (pint_t)p;
break;
case DW_EH_PE_udata8:
result = get64(addr);
p += 8;
addr = (pint_t)p;
break;
case DW_EH_PE_sleb128:
result = getSLEB128(addr, end);
break;
case DW_EH_PE_sdata2:
result = (int16_t)get16(addr);
p += 2;
addr = (pint_t)p;
break;
case DW_EH_PE_sdata4:
result = (int32_t)get32(addr);
p += 4;
addr = (pint_t)p;
break;
case DW_EH_PE_sdata8:
result = get64(addr);
p += 8;
addr = (pint_t)p;
break;
default:
ABORT("unknown pointer encoding");
}
// then add relative offset
switch ( encoding & 0x70 ) {
case DW_EH_PE_absptr:
// do nothing
break;
case DW_EH_PE_pcrel:
result += startAddr;
break;
case DW_EH_PE_textrel:
ABORT("DW_EH_PE_textrel pointer encoding not supported");
break;
case DW_EH_PE_datarel:
ABORT("DW_EH_PE_datarel pointer encoding not supported");
break;
case DW_EH_PE_funcrel:
ABORT("DW_EH_PE_funcrel pointer encoding not supported");
break;
case DW_EH_PE_aligned:
ABORT("DW_EH_PE_aligned pointer encoding not supported");
break;
default:
ABORT("unknown pointer encoding");
break;
}
if ( encoding & DW_EH_PE_indirect )
result = getP(result);
return result;
}
