bool forecast_from_bridge_dict(DictionaryIterator* dict, Forecast* forecast) {
// TBD: Test results - J. Speicher (8/9/13)
get_int16(dict, DUMMY_INTEGER_KEY, &forecast->dummy_integer);
get_int16(dict, ANOTHER_DUMMY_INTEGER_KEY, &forecast->another_dummy_integer);
get_cstring(dict, DUMMY_STRING_KEY, &forecast->dummy_string);
return true;
};
int main(int argc, char *argv[])
{
unsigned char lb[2];
unsigned char buf[BUFSIZ];
char *user;
char *pwd;
char *mode;
int sid;
int rval;
struct session *sessp;
// test clause
if (argc == 4 ) {
/* ./epam authmodule user passwd */
printf("testing service=%s u=%s pwd=%s\n", argv[1],argv[2], argv[3]);
do_auth(argv[1], argv[2], argv[3], "AS", 33);
exit(0);
}
wstart();
while (1) {
if (read_fill(0, lb, 2) != 2)
exit(1);
rval = get_int16(lb);
if (read_fill(0, buf, rval) != rval)
exit(1);
switch (buf[0]) {
case 'a':
// auth a user
user = (char *)&buf[1];
pwd = user + strlen(user) + 1;
mode= pwd + strlen(pwd) + 1;
sid = atoi(mode + strlen(mode) + 1);
do_auth(argv[1], user, pwd, mode, sid);
break;
case 'c':
// close session
sid = atoi((char *)&buf[1]);
if ((sessp = del_session(&sessions, sid)) == NULL) {
fprintf(stderr, "Couldn't find session %d\r\n", sid);
break;
}
if (sessp->session_mode == 1) {
pam_close_session(sessp->pamh, 0);
/*fprintf(stderr, "did ok close sess \n\r");*/
}
pam_end(sessp->pamh, PAM_SUCCESS);
free(sessp);
break;
default:
fprintf(stderr, "Bad op \n\r");
}
}
}
SLsmg_Char_Type *decode_smg_char_type(char **buf)
{
static SLsmg_Char_Type mbuf[256];
int i;
char *b = *buf;
int len = get_int32(*buf); *buf+=4;
for(i=0; i<len; i++) {
mbuf[i++] = get_int16(*buf); *buf+=2;
}
return mbuf;
}
long
pl_get_int32(const byte *bptr)
{ return ((long)get_int16(bptr) << 16) | get_uint16(bptr + 2);
}
int
pl_get_int16(const byte *bptr)
{ return get_int16(bptr);
}
int read_elf(char *filename, struct _memory *memory, uint8_t *cpu_type, struct _symbols *symbols)
{
FILE *in;
uint8_t e_ident[16];
int e_shoff;
int e_shentsize;
int e_shnum;
int e_shstrndx;
int n;
int start, end;
struct _elf32_shdr elf32_shdr;
long strtab_offset = 0;
get_int16_t get_int16;
get_int32_t get_int32;
memory_clear(memory);
//memset(dirty, 0, memory->size);
start = -1;
end = -1;
in = fopen(filename, "rb");
if (in == 0)
{
return -1;
}
memset(e_ident, 0, 16);
n = fread(e_ident, 1, 16, in);
if (e_ident[0] != 0x7f || e_ident[1] != 'E' ||
e_ident[2] != 'L' || e_ident[3] != 'F')
{
//printf("Not an ELF file.\n");
fclose(in);
return -2;
}
#define EI_CLASS 4 // 1=32 bit, 2=64 bit
#define EI_DATA 5 // 1=little endian, 2=big endian
#define EI_OSABI 7 // 0=SysV, 255=Embedded
if (e_ident[EI_CLASS] != 1) // let's let other stuff in || e_ident[7]!=0xff)
{
printf("ELF Error: e_ident shows incorrect type\n");
fclose(in);
return -1;
}
// EI_DATA
if (e_ident[EI_DATA] == 1)
{
memory->endian = ENDIAN_LITTLE;
get_int16 = get_int16_le;
get_int32 = get_int32_le;
}
else
if (e_ident[EI_DATA] == 2)
{
memory->endian = ENDIAN_BIG;
get_int16 = get_int16_be;
get_int32 = get_int32_be;
}
else
{
printf("ELF Error: EI_DATA incorrect data encoding\n");
fclose(in);
return -1;
}
get_int16(in);
n = get_int16(in);
switch(n)
{
case 8:
case 10:
*cpu_type = CPU_TYPE_MIPS;
break;
case 40:
*cpu_type = CPU_TYPE_ARM;
break;
case 83:
*cpu_type = CPU_TYPE_AVR8;
break;
case 105:
*cpu_type = CPU_TYPE_MSP430;
break;
case 118:
*cpu_type = CPU_TYPE_DSPIC;
break;
default:
printf("ELF Error: e_machine unknown\n");
fclose(in);
return -1;
}
fseek(in, 32, SEEK_SET);
e_shoff = get_int32(in);
fseek(in, 46, SEEK_SET);
e_shentsize = get_int16(in);
e_shnum = get_int16(in);
e_shstrndx = get_int16(in);
//printf("e_shoff=%d\n", e_shoff);
//printf("e_shentsize=%d\n", e_shentsize);
//printf("e_shnum=%d\n", e_shnum);
//printf("e_shstrndx=%d\n", e_shstrndx);
fseek(in, e_shoff + (e_shstrndx * e_shentsize) + 16, SEEK_SET);
int stroffset = get_int32(in);
char name[32];
// Need to find .strtab so we can fill in symbol names
for (n = 0; n < e_shnum; n++)
{
fseek(in, e_shoff + (n * e_shentsize), SEEK_SET);
read_shdr(in, &elf32_shdr, get_int32);
if (elf32_shdr.sh_type == SHT_STRTAB)
{
read_name(in, name, 32, stroffset + elf32_shdr.sh_name);
if (strcmp(name, ".strtab") == 0)
{
strtab_offset = elf32_shdr.sh_offset;
break;
}
}
}
for (n = 0; n < e_shnum; n++)
{
// FIXME - a little inefficient eh?
fseek(in, e_shoff + (n * e_shentsize), SEEK_SET);
read_shdr(in, &elf32_shdr, get_int32);
read_name(in, name, 32, stroffset + elf32_shdr.sh_name);
//printf("name=%s\n", name);
//int is_text = strncmp(name, ".text", 5) == 0 ? 1 : 0;
int is_text = (elf32_shdr.sh_flags & SHF_EXECINSTR) != 0 ? 1 : 0;
if (is_text ||
strncmp(name, ".data", 5) == 0 || strcmp(name, ".vectors") == 0)
{
if (is_text)
{
if (start == -1) { start = elf32_shdr.sh_addr; }
else if (start > elf32_shdr.sh_addr) { start = elf32_shdr.sh_addr; }
if (end == -1) { end = elf32_shdr.sh_addr + elf32_shdr.sh_size - 1; }
else if (end < elf32_shdr.sh_addr + elf32_shdr.sh_size) { end = elf32_shdr.sh_addr+elf32_shdr.sh_size - 1; }
}
long marker = ftell(in);
fseek(in, elf32_shdr.sh_offset, SEEK_SET);
int n;
for (n = 0; n < elf32_shdr.sh_size; n++)
{
if (elf32_shdr.sh_addr + n >= memory->size) break;
memory_write_m(memory, elf32_shdr.sh_addr + n, getc(in));
}
fseek(in, marker, SEEK_SET);
printf("Loaded %d %s bytes from 0x%04x\n", n, name, elf32_shdr.sh_addr);
}
else
if (elf32_shdr.sh_type == SHT_SYMTAB && symbols != NULL)
{
long marker = ftell(in);
fseek(in, elf32_shdr.sh_offset, SEEK_SET);
for (n = 0; n < elf32_shdr.sh_size; n += 16)
{
char name[128];
struct _elf32_sym elf32_sym;
elf32_sym.st_name = get_int32(in);
elf32_sym.st_value = get_int32(in);
elf32_sym.st_size = get_int32(in);
elf32_sym.st_info = getc(in);
elf32_sym.st_other = getc(in);
elf32_sym.st_shndx = get_int16(in);
read_name(in, name, 128, strtab_offset + elf32_sym.st_name);
printf("symbol %12s 0x%04x\n", name, elf32_sym.st_value);
if (elf32_sym.st_info != STT_NOTYPE &&
elf32_sym.st_info != STT_SECTION &&
elf32_sym.st_info != STT_FILE)
{
symbols_append(symbols, name, elf32_sym.st_value);
}
}
fseek(in, marker, SEEK_SET);
}
}
memory->low_address = start;
memory->high_address = end;
fclose(in);
return start;
}
/* Return > 0 Total packet length.in bytes
* = 0 Length unknown, need more data.
* < 0 Error, invalid format.
*/
int packet_get_length(enum PacketParseType htype,
const char* ptr, unsigned n, /* Bytes read so far */
unsigned max_plen, /* Max packet length, 0=no limit */
unsigned trunc_len, /* Truncate (lines) if longer, 0=no limit */
int* statep) /* Protocol specific state */
{
unsigned hlen, plen;
switch (htype) {
case TCP_PB_RAW:
if (n == 0) goto more;
else {
DEBUGF((" => nothing remain packet=%d\r\n", n));
return n;
}
case TCP_PB_1:
/* TCP_PB_1: [L0 | Data] */
hlen = 1;
if (n < hlen) goto more;
plen = get_int8(ptr);
goto remain;
case TCP_PB_2:
/* TCP_PB_2: [L1,L0 | Data] */
hlen = 2;
if (n < hlen) goto more;
plen = get_int16(ptr);
goto remain;
case TCP_PB_4:
/* TCP_PB_4: [L3,L2,L1,L0 | Data] */
hlen = 4;
if (n < hlen) goto more;
plen = get_int32(ptr);
goto remain;
case TCP_PB_RM:
/* TCP_PB_RM: [L3,L2,L1,L0 | Data]
** where MSB (bit) is used to signal end of record
*/
hlen = 4;
if (n < hlen) goto more;
plen = get_int32(ptr) & 0x7fffffff;
goto remain;
case TCP_PB_LINE_LF: {
/* TCP_PB_LINE_LF: [Data ... \n] */
const char* ptr2;
if ((ptr2 = memchr(ptr, '\n', n)) == NULL) {
if (n > max_plen && max_plen != 0) { /* packet full */
DEBUGF((" => packet full (no NL)=%d\r\n", n));
goto error;
}
else if (n >= trunc_len && trunc_len!=0) { /* buffer full */
DEBUGF((" => line buffer full (no NL)=%d\r\n", n));
return trunc_len;
}
goto more;
}
else {
int len = (ptr2 - ptr) + 1; /* including newline */
if (len > max_plen && max_plen!=0) {
DEBUGF((" => packet_size %d exceeded\r\n", max_plen));
goto error;
}
if (len > trunc_len && trunc_len!=0) {
DEBUGF((" => truncated line=%d\r\n", trunc_len));
return trunc_len;
}
DEBUGF((" => nothing remain packet=%d\r\n", len));
return len;
}
}
case TCP_PB_ASN1: {
/* TCP_PB_ASN1: handles long (4 bytes) or short length format */
const char* tptr = ptr;
int length;
int nn = n;
if (n < 2) goto more;
nn--;
if ((*tptr++ & 0x1f) == 0x1f) { /* Long tag format */
while (nn && ((*tptr & 0x80) == 0x80)) {
tptr++;
nn--;
}
if (nn < 2) goto more;
tptr++;
nn--;
}
/* tptr now point to length field and nn characters remain */
length = *tptr & 0x7f;
if ((*tptr & 0x80) == 0x80) { /* Long length format */
tptr++;
nn--;
if (nn < length) goto more;
switch (length) {
case 0: plen = 0; break;
case 1: plen = get_int8(tptr); tptr += 1; break;
case 2: plen = get_int16(tptr); tptr += 2; break;
case 3: plen = get_int24(tptr); tptr += 3; break;
case 4: plen = get_int32(tptr); tptr += 4; break;
default: goto error; /* error */
}
}
else {
tptr++;
plen = length;
}
hlen = (tptr-ptr);
goto remain;
}
case TCP_PB_CDR: {
const struct cdr_head* hp;
hlen = sizeof(struct cdr_head);
if (n < hlen) goto more;
hp = (struct cdr_head*) ptr;
if (sys_memcmp(hp->magic, CDR_MAGIC, 4) != 0)
goto error;
if (hp->flags & 0x01) /* Byte ordering flag */
plen = get_little_int32(hp->message_size);
else
plen = get_int32(hp->message_size);
goto remain;
}
case TCP_PB_FCGI: {
const struct fcgi_head* hp;
hlen = sizeof(struct fcgi_head);
if (n < hlen) goto more;
hp = (struct fcgi_head*) ptr;
if (hp->version != FCGI_VERSION_1)
goto error;
plen = ((hp->contentLengthB1 << 8) | hp->contentLengthB0)
+ hp->paddingLength;
goto remain;
}
case TCP_PB_HTTPH:
case TCP_PB_HTTPH_BIN:
*statep = !0;
case TCP_PB_HTTP:
case TCP_PB_HTTP_BIN:
/* TCP_PB_HTTP: data \r\n(SP data\r\n)* */
plen = n;
if (((plen == 1) && NL(ptr)) || ((plen == 2) && CRNL(ptr)))
goto done;
else {
const char* ptr1 = ptr;
int len = plen;
if (!max_plen) {
/* This is for backward compatibility with old user of decode_packet
* that might use option 'line_length' to limit accepted length of
* http lines.
*/
max_plen = trunc_len;
}
while (1) {
const char* ptr2 = memchr(ptr1, '\n', len);
if (ptr2 == NULL) {
if (max_plen != 0) {
if (n >= max_plen) /* packet full */
goto error;
}
goto more;
}
else {
plen = (ptr2 - ptr) + 1;
if (*statep == 0) {
if (max_plen != 0 && plen > max_plen)
goto error;
goto done;
}
if (plen < n) {
if (SP(ptr2+1) && plen>2) {
/* header field value continue on next line */
ptr1 = ptr2+1;
len = n - plen;
}
else {
if (max_plen != 0 && plen > max_plen)
goto error;
goto done;
}
}
else {
if (max_plen != 0 && plen > max_plen)
goto error;
goto more;
}
}
}
}
case TCP_PB_TPKT: {
const struct tpkt_head* hp;
hlen = sizeof(struct tpkt_head);
if (n < hlen)
goto more;
hp = (struct tpkt_head*) ptr;
if (hp->vrsn == TPKT_VRSN) {
plen = get_int16(hp->packet_length) - hlen;
} else {
goto error;
}
goto remain;
}
case TCP_PB_SSL_TLS:
hlen = 5;
if (n < hlen) goto more;
if ((ptr[0] & 0x80) && ptr[2] == 1) {
/* Ssl-v2 Client hello <<1:1, Len:15, 1:8, Version:16>> */
plen = (get_int16(&ptr[0]) & 0x7fff) - 3;
}
else {
/* <<ContentType:8, Version:16, Length:16>> */
plen = get_int16(&ptr[3]);
}
goto remain;
default:
DEBUGF((" => case error\r\n"));
return -1;
}
more:
return 0;
remain:
{
int tlen = hlen + plen;
if ((max_plen != 0 && plen > max_plen)
|| tlen < (int)hlen) { /* wrap-around protection */
return -1;
}
return tlen;
}
done:
return plen;
error:
return -1;
}
static void do_read(EpmdVars *g,Connection *s)
{
int val, pack_size;
if (s->open == EPMD_FALSE)
{
dbg_printf(g,0,"read on unknown socket");
return;
}
/* Check if we already got the whole packet but we keep the
connection alive to find out when a node is terminated. We then
want to check for a close */
if (s->keep == EPMD_TRUE)
{
val = read(s->fd, s->buf, INBUF_SIZE);
if (val == 0)
{
node_unreg_sock(g,s->fd);
epmd_conn_close(g,s);
}
else if (val < 0)
{
dbg_tty_printf(g,1,"error on ALIVE socket %d (%d; errno=0x%x)",
s->fd, val, errno);
node_unreg_sock(g,s->fd);
epmd_conn_close(g,s);
}
else
{
dbg_tty_printf(g,1,"got more than expected on ALIVE socket %d (%d)",
s->fd,val);
dbg_print_buf(g,s->buf,val);
node_unreg_sock(g,s->fd);
epmd_conn_close(g,s);
}
return;
}
/* If unknown size we request the whole buffer - what we got - 1
We subtract 1 because we will add a "\0" in "do_request()".
This is not needed for R3A or higher versions of Erlang,
because the '\0' is included in the request,
but is kept for backwards compatibility to allow R2D to use
this epmd. */
pack_size = s->want ? s->want : INBUF_SIZE - 1;
val = read(s->fd, s->buf + s->got, pack_size - s->got);
if (val == 0)
{
/* A close when we haven't got all data */
dbg_printf(g,0,"got partial packet only on file descriptor %d (%d)",
s->fd,s->got);
epmd_conn_close(g,s);
return;
}
if (val < 0)
{
dbg_perror(g,"error in read");
epmd_conn_close(g,s);
return;
}
dbg_print_buf(g,s->buf,val);
s->got += val;
if ((s->want == 0) && (s->got >= 2))
{
/* The two byte header that specify the length of the packet
doesn't count the header as part of the packet so we add 2
to "s->want" to make us talk about all bytes we get. */
s->want = get_int16(s->buf) + 2;
if ((s->want < 3) || (s->want >= INBUF_SIZE))
{
dbg_printf(g,0,"invalid packet size (%d)",s->want - 2);
epmd_conn_close(g,s);
return;
}
if (s->got > s->want)
{
dbg_printf(g,0,"got %d bytes in packet, expected %d",
s->got - 2, s->want - 2);
epmd_conn_close(g,s);
return;
}
}
s->mod_time = current_time(g); /* Note activity */
if (s->want == s->got)
{
/* Do action and close up */
/* Skip header bytes */
do_request(g, s->fd, s, s->buf + 2, s->got - 2);
if (!s->keep)
epmd_conn_close(g,s); /* Normal close */
}
}
int ape_parseheaderbuf(unsigned char* buf, struct ape_ctx_t* ape_ctx)
{
unsigned char* header;
memset(ape_ctx,0,sizeof(struct ape_ctx_t));
/* TODO: Skip any leading junk such as id3v2 tags */
ape_ctx->junklength = 0;
memcpy(ape_ctx->magic, buf, 4);
if (memcmp(ape_ctx->magic,"MAC ",4)!=0)
{
return -1;
}
ape_ctx->fileversion = get_int16(buf + 4);
if (ape_ctx->fileversion >= 3980)
{
ape_ctx->padding1 = get_int16(buf + 6);
ape_ctx->descriptorlength = get_uint32(buf + 8);
ape_ctx->headerlength = get_uint32(buf + 12);
ape_ctx->seektablelength = get_uint32(buf + 16);
ape_ctx->wavheaderlength = get_uint32(buf + 20);
ape_ctx->audiodatalength = get_uint32(buf + 24);
ape_ctx->audiodatalength_high = get_uint32(buf + 28);
ape_ctx->wavtaillength = get_uint32(buf + 32);
memcpy(ape_ctx->md5, buf + 36, 16);
header = buf + ape_ctx->descriptorlength;
/* Read header data */
ape_ctx->compressiontype = get_uint16(header + 0);
ape_ctx->formatflags = get_uint16(header + 2);
ape_ctx->blocksperframe = get_uint32(header + 4);
ape_ctx->finalframeblocks = get_uint32(header + 8);
ape_ctx->totalframes = get_uint32(header + 12);
ape_ctx->bps = get_uint16(header + 16);
ape_ctx->channels = get_uint16(header + 18);
ape_ctx->samplerate = get_uint32(header + 20);
ape_ctx->seektablefilepos = ape_ctx->junklength +
ape_ctx->descriptorlength +
ape_ctx->headerlength;
ape_ctx->firstframe = ape_ctx->junklength + ape_ctx->descriptorlength +
ape_ctx->headerlength + ape_ctx->seektablelength +
ape_ctx->wavheaderlength;
} else {
ape_ctx->headerlength = 32;
ape_ctx->compressiontype = get_uint16(buf + 6);
ape_ctx->formatflags = get_uint16(buf + 8);
ape_ctx->channels = get_uint16(buf + 10);
ape_ctx->samplerate = get_uint32(buf + 12);
ape_ctx->wavheaderlength = get_uint32(buf + 16);
ape_ctx->totalframes = get_uint32(buf + 24);
ape_ctx->finalframeblocks = get_uint32(buf + 28);
if (ape_ctx->formatflags & MAC_FORMAT_FLAG_HAS_PEAK_LEVEL)
{
ape_ctx->headerlength += 4;
}
if (ape_ctx->formatflags & MAC_FORMAT_FLAG_HAS_SEEK_ELEMENTS)
{
ape_ctx->seektablelength = get_uint32(buf + ape_ctx->headerlength);
ape_ctx->seektablelength *= sizeof(int32_t);
ape_ctx->headerlength += 4;
} else {
ape_ctx->seektablelength = ape_ctx->totalframes * sizeof(int32_t);
}
if (ape_ctx->formatflags & MAC_FORMAT_FLAG_8_BIT)
ape_ctx->bps = 8;
else if (ape_ctx->formatflags & MAC_FORMAT_FLAG_24_BIT)
ape_ctx->bps = 24;
else
ape_ctx->bps = 16;
if (ape_ctx->fileversion >= 3950)
ape_ctx->blocksperframe = 73728 * 4;
else if ((ape_ctx->fileversion >= 3900) || (ape_ctx->fileversion >= 3800 && ape_ctx->compressiontype >= 4000))
ape_ctx->blocksperframe = 73728;
else
ape_ctx->blocksperframe = 9216;
ape_ctx->seektablefilepos = ape_ctx->junklength + ape_ctx->headerlength +
ape_ctx->wavheaderlength;
ape_ctx->firstframe = ape_ctx->junklength + ape_ctx->headerlength +
ape_ctx->wavheaderlength + ape_ctx->seektablelength;
}
ape_ctx->totalsamples = ape_ctx->finalframeblocks;
if (ape_ctx->totalframes > 1)
ape_ctx->totalsamples += ape_ctx->blocksperframe * (ape_ctx->totalframes-1);
ape_ctx->numseekpoints = APE_MAX(ape_ctx->maxseekpoints,
ape_ctx->seektablelength / sizeof(int32_t));
return 0;
}
static void iconvdrv_from_erlang(ErlDrvData drv_data, char *buf, ErlDrvSSizeT len)
{
t_iconvdrv *iv = (t_iconvdrv *) drv_data;
char ignore = 0;
char tocode[CODE_STR_SZ], fromcode[CODE_STR_SZ];
char *bp=buf;
unsigned int i=0;
iconv_t cd;
i = bp[0];
bp++;
switch (i) {
case IV_OPEN: {
/*
* Format: <to-len:16><tocode><from-len:16><from-buf>
*/
i = get_int16(bp);
bp += 2;
memcpy(tocode, bp, i);
tocode[i] = '\0';
bp += i;
i = get_int16(bp);
bp += 2;
memcpy(fromcode, bp, i);
fromcode[i] = '\0';
iv_open(iv, tocode, fromcode);
break;
}
case IV_CONV: {
/*
* Format: <cd-len:16><cd><ignore><buf-len:32><buf>
*/
i = get_int16(bp);
bp += 2;
memcpy(&cd, bp, i-1);
memcpy(&ignore, bp + i -1, 1);
bp += i;
i = get_int32(bp);
bp += 4;
iv_conv(iv, cd, bp, i, ignore);
break;
}
case IV_CLOSE: {
/*
* Format: <cd-len:16><cd><ignore>
*/
i = get_int16(bp);
bp += 2;
memcpy(&cd, bp, i - 1);
iv_close(iv, cd);
break;
}
} /* switch */
return;
}
static int
decode_data(double **data, const xmlChar * input, dataFormat data_format,
codingTypes coding, byteOrder byte_order, int max_input_len)
{
GArray *data_stream, *debase64_buf, *decoded_data;
char *p, *end_ptr;
unsigned int i;
double val;
int data_count = 0;
gwy_debug("start.");
if (input == NULL) {
g_warning("SPML: decode_data(): NULL input");
*data = NULL;
return 0;
}
switch (coding) {
case ZLIB_COMPR_BASE64:
/*/ XXX: strlen() may not be nice there */
if (decode_b64((char *)input, &debase64_buf, strlen(input)) != 0) {
if (debase64_buf != NULL) {
g_array_free(debase64_buf, TRUE);
}
g_warning("Cannot decode data in BASE64 code.");
*data = NULL;
return 0;
}
if (inflate_dynamic_array(debase64_buf, &data_stream) != 0) {
g_warning("Cannot inflate compressed data.");
g_array_free(debase64_buf, TRUE);
if (data_stream != NULL) {
g_array_free(data_stream, TRUE);
}
*data = NULL;
return 0;
}
g_array_free(debase64_buf, TRUE);
break;
case BASE64:
/*/ XXX: strlen() may not be nice there */
if (decode_b64((char *)input, &data_stream, strlen(input)) != 0) {
g_warning("Cannot decode data in BASE64 code.");
if (data_stream != NULL) {
g_array_free(data_stream, TRUE);
}
*data = NULL;
return 0;
}
break;
case ASCII:
p = (char *)input;
data_stream = g_array_new(FALSE, FALSE, sizeof(double));
while (p != NULL) {
double num;
if (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t') {
p++;
continue;
}
num = g_ascii_strtod(p, &end_ptr);
if (num == 0 && end_ptr == p) {
g_warning("SPML: decode_data(): No conversion performed "
"from ASCII string.");
break;
}
g_array_append_val(data_stream, num);
p = end_ptr;
data_count++;
}
break;
/*/ TODO: */
case HEX:
case BINARY:
g_warning("SPML: decode_data(): Data coding 'HEX' and 'BINARY' "
"not supported.");
break;
case UNKNOWN_CODING:
break;
}
if (coding == ASCII) {
/* we have already decoded data */
if (max_input_len != -1 && data_count != max_input_len) {
/* not enough input data to fill array defined by length
* max_input_len */
g_warning("SPML: decode_data():\n"
"Input has not the same length as declared in "
"dimensions\n"
"(max:%d vs read:%d). Has the channel attribute\n"
"'channelReadMethodName'? The channel may be one\n"
"dimensional data used for axis values but not as\n"
"a source of data for Gwyddion.",
max_input_len, data_count);
g_array_free(data_stream, TRUE);
*data = NULL;
return 0;
}
else {
*data = (double *)data_stream->data;
/* we can free dynamic array, but not */
g_array_free(data_stream, FALSE);
/* containing data. */
gwy_debug("Datacount: %d", data_count);
return data_count;
}
}
decoded_data = g_array_new(FALSE, FALSE, sizeof(double));
p = data_stream->data;
i = 0;
switch (data_format) {
case FLOAT32:
while (i < data_stream->len) {
val = get_float32(&p, byte_order);
g_array_append_val(decoded_data, val);
data_count++;
i += sizeof(float);
}
break;
case FLOAT64:
while (i < data_stream->len) {
val = get_float64(&p, byte_order);
g_array_append_val(decoded_data, val);
i += sizeof(double);
}
break;
case INT8:
while (i < data_stream->len) {
val = get_int8(&p);
g_array_append_val(decoded_data, val);
i += sizeof(gint8);
}
break;
case INT16:
while (i < data_stream->len) {
val = get_int16(&p, byte_order);
g_array_append_val(decoded_data, val);
i += sizeof(gint16);
}
break;
case INT32:
while (i < data_stream->len) {
val = get_int32(&p, byte_order);
g_array_append_val(decoded_data, val);
i += sizeof(gint32);
}
break;
case UINT32:
while (i < data_stream->len) {
val = get_uint32(&p, byte_order);
g_array_append_val(decoded_data, val);
i += sizeof(guint32);
}
break;
case UINT8:
while (i < data_stream->len) {
val = get_uint8(&p);
g_array_append_val(decoded_data, val);
i += sizeof(guint8);
}
break;
case UINT16:
while (i < data_stream->len) {
val = get_uint16(&p, byte_order);
g_array_append_val(decoded_data, val);
i += sizeof(guint16);
}
break;
case STRING:
g_warning
("SPML: decode_data(): Data format 'String' not supported.");
break;
case UNKNOWN_DATAFORMAT:
g_warning("SPML: decode_data(): Unknown dataformat.");
break;
}
g_array_free(data_stream, TRUE);
data_count = decoded_data->len;
if (max_input_len != -1 && data_count != max_input_len) {
g_warning("SPML: decode_data():\n"
"Input has not the same length as declared in dimensions\n"
"(max:%d vs read:%d). Has the channel attribute\n"
"'channelReadMethodName'? The channel may be one\n"
"dimensional data used for axis values but not as\n"
"a source of data for Gwyddion.", max_input_len, data_count);
g_array_free(decoded_data, TRUE);
*data = NULL;
return 0;
}
*data = (double *)decoded_data->data;
g_array_free(decoded_data, FALSE); /* we can free dynamic array, but not */
/* containing data. */
gwy_debug("Datacount: %d", data_count);
return data_count;
}
/* parse and summarize FOND resource information */
static fond_table * parse_fond(FSSpec *spec)
{
OSErr result = noErr;
FSRef specref;
SInt16 ref;
Handle fond = NULL;
unsigned char *res;
fond_table *table = NULL;
int i,j, count, n, start;
/* FSpOpenResFile will fail for data fork resource (.dfont) files.
FSOpenResourceFile can open either, but cannot handle broken resource
maps, as often occurs in font files (the suitcase version of Arial,
for example) Thus, we try one, and then the other. */
result = FSpMakeFSRef(spec,&specref);
#ifdef __CARBON__
if (result == noErr)
result = FSOpenResourceFile(&specref, 0, NULL, fsRdPerm, &ref);
#else
result = bdNamErr; /* simulate failure of the carbon routine above */
#endif
if (result != noErr) {
ref = FSpOpenResFile(spec, fsRdPerm);
result = ResError();
}
if (result != noErr || ref <= 0) {
char path[256];
convertSpecToPath(spec, path, 256);
dlprintf2("unable to open resource file '%s' for font enumeration (error %d)\n",
path, result);
goto fin;
}
/* we've opened the font file, now loop over the FOND resource(s)
and construct a table of the font references */
start = 0; /* number of entries so far */
UseResFile(ref);
count = Count1Resources('FOND');
for (i = 0; i < count; i++) {
fond = Get1IndResource('FOND', i+1);
if (fond == NULL) {
result = ResError();
goto fin;
}
/* The FOND resource structure corresponds to the FamRec and AsscEntry
data structures documented in the FontManager reference. However,
access to these types is deprecated in Carbon. We therefore access the
data by direct offset in the hope that the resource format will not change
even if api access to the in-memory versions goes away. */
HLock(fond);
res = *fond + 52; /* offset to association table */
n = get_int16(res) + 1; res += 2;
table = fond_table_grow(table, n);
for (j = start; j < start + n; j++ ) {
table->refs[j].size = get_int16(res); res += 2;
table->refs[j].style = get_int16(res); res += 2;
table->refs[j].id = get_int16(res); res += 2;
}
start += n;
HUnlock(fond);
}
fin:
CloseResFile(ref);
return table;
}