Example #1
0
File: ctf.c Project: DataIX/src
/*
 * Depending on the size of the type being described, either a ctf_stype_t (for
 * types with size < CTF_LSTRUCT_THRESH) or a ctf_type_t (all others) will be
 * written.  We isolate the determination here so the rest of the writer code
 * doesn't need to care.
 */
static void
write_sized_type_rec(ctf_buf_t *b, ctf_type_t *ctt, size_t size)
{
	if (size > CTF_MAX_SIZE) {
		ctt->ctt_size = CTF_LSIZE_SENT;
		ctt->ctt_lsizehi = CTF_SIZE_TO_LSIZE_HI(size);
		ctt->ctt_lsizelo = CTF_SIZE_TO_LSIZE_LO(size);
		if (target_requires_swap) {
			SWAP_32(ctt->ctt_name);
			SWAP_16(ctt->ctt_info);
			SWAP_16(ctt->ctt_size);
			SWAP_32(ctt->ctt_lsizehi);
			SWAP_32(ctt->ctt_lsizelo);
		}
		ctf_buf_write(b, ctt, sizeof (*ctt));
	} else {
		ctf_stype_t *cts = (ctf_stype_t *)ctt;

		cts->ctt_size = (ushort_t)size;

		if (target_requires_swap) {
			SWAP_32(cts->ctt_name);
			SWAP_16(cts->ctt_info);
			SWAP_16(cts->ctt_size);
		}

		ctf_buf_write(b, cts, sizeof (*cts));
	}
}
Example #2
0
static void testSwap_16(void)
{
    volatile unsigned long t=TEST_VECT_32;
    unsigned long tt;
    LONG x;

    tt = t;
    tt = SWAP_16(tt);
    ASSERT( tt == SWAP_16(TEST_VECT_32));

    /* swapping union with little register pressure */
    {
        unsigned char c;
        x.l = t;

        c = x.c[0];
        x.c[0]=x.c[2];
        x.c[2]=c;
        c = x.c[1];
        x.c[1]=x.c[3];
        x.c[3]=c;

        ASSERT( x.l == SWAP_16(TEST_VECT_32));
    }
}
Example #3
0
SampleFormat PcmDecoder::setHeader(msg::CodecHeader* chunk)
{
	if (chunk->payloadSize < 44)
		throw SnapException("PCM header too small");

    struct riff_wave_header riff_wave_header;
	struct chunk_header chunk_header;
	struct chunk_fmt chunk_fmt;
	chunk_fmt.sample_rate = SWAP_32(0);
	chunk_fmt.bits_per_sample = SWAP_16(0);
	chunk_fmt.num_channels = SWAP_16(0);

	size_t pos(0);
	memcpy(&riff_wave_header, chunk->payload + pos, sizeof(riff_wave_header));
	pos += sizeof(riff_wave_header);
	if ((SWAP_32(riff_wave_header.riff_id) != ID_RIFF) || (SWAP_32(riff_wave_header.wave_id) != ID_WAVE))
		throw SnapException("Not a riff/wave header");

	bool moreChunks(true);
	do
	{
		if (pos + sizeof(chunk_header) > chunk->payloadSize)
			throw SnapException("riff/wave header incomplete");
		memcpy(&chunk_header, chunk->payload + pos, sizeof(chunk_header));
		pos += sizeof(chunk_header);
		switch (SWAP_32(chunk_header.id))
		{
		case ID_FMT:
			if (pos + sizeof(chunk_fmt) > chunk->payloadSize)
				throw SnapException("riff/wave header incomplete");
			memcpy(&chunk_fmt, chunk->payload + pos, sizeof(chunk_fmt));
			pos += sizeof(chunk_fmt);
			/// If the format header is larger, skip the rest
			if (SWAP_32(chunk_header.sz) > sizeof(chunk_fmt))
				pos += (SWAP_32(chunk_header.sz) - sizeof(chunk_fmt));
			break;
		case ID_DATA:
			/// Stop looking for chunks
			moreChunks = false;
			break;
		default:
			/// Unknown chunk, skip bytes
			pos += SWAP_32(chunk_header.sz);
		}
	}
	while (moreChunks);


	if (SWAP_32(chunk_fmt.sample_rate) == 0)
		throw SnapException("Sample format not found");

	SampleFormat sampleFormat(
		SWAP_32(chunk_fmt.sample_rate),
		SWAP_16(chunk_fmt.bits_per_sample),
		SWAP_16(chunk_fmt.num_channels));

	return sampleFormat;
}
Example #4
0
File: ctf.c Project: DataIX/src
static void
write_unsized_type_rec(ctf_buf_t *b, ctf_type_t *ctt)
{
	ctf_stype_t *cts = (ctf_stype_t *)ctt;

	if (target_requires_swap) {
		SWAP_32(cts->ctt_name);
		SWAP_16(cts->ctt_info);
		SWAP_16(cts->ctt_size);
	}

	ctf_buf_write(b, cts, sizeof (*cts));
}
Example #5
0
File: ctf.c Project: DataIX/src
static void
write_functions(iidesc_t *idp, ctf_buf_t *b)
{
	ushort_t fdata[2];
	ushort_t id;
	int nargs;
	int i;

	if (!idp) {
		fdata[0] = 0;
		ctf_buf_write(b, &fdata[0], sizeof (fdata[0]));

		debug(3, "Wrote function (null)\n");
		return;
	}

	nargs = idp->ii_nargs + (idp->ii_vargs != 0);

	if (nargs > CTF_MAX_VLEN) {
		terminate("function %s has too many args: %d > %d\n",
		    idp->ii_name, nargs, CTF_MAX_VLEN);
	}

	fdata[0] = CTF_TYPE_INFO(CTF_K_FUNCTION, 1, nargs);
	fdata[1] = idp->ii_dtype->t_id;

	if (target_requires_swap) {
		SWAP_16(fdata[0]);
		SWAP_16(fdata[1]);
	}

	ctf_buf_write(b, fdata, sizeof (fdata));

	for (i = 0; i < idp->ii_nargs; i++) {
		id = idp->ii_args[i]->t_id;

		if (target_requires_swap) {
			SWAP_16(id);
		}

		ctf_buf_write(b, &id, sizeof (id));
	}

	if (idp->ii_vargs) {
		id = 0;
		ctf_buf_write(b, &id, sizeof (id));
	}

	debug(3, "Wrote function %s (%d args)\n", idp->ii_name, nargs);
}
Example #6
0
/* now for something ugly */
static void testSwap_16_ptr(void)
{
#if defined (SDCC)
#include <sdcc-lib.h> /* just to get _AUTOMEM or _STATMEM */
#if defined (SDCC_STACK_AUTO)
#define MY_STATIC static
#else
#define MY_STATIC
#endif
    MY_STATIC unsigned long _STATMEM tt=TEST_VECT_32;

    /* swapping with little register pressure */
    {
        unsigned char c;

        /* uglyness += 1 */
        c = *(0+(unsigned char _STATMEM *)&tt);
        *(0+(unsigned char _STATMEM *)&tt) = *(2+(unsigned char _STATMEM *)&tt);
        *(2+(unsigned char _STATMEM *)&tt) = c;
        c = *(1+(unsigned char _STATMEM *)&tt);
        *(1+(unsigned char _STATMEM *)&tt) = *(3+(unsigned char _STATMEM *)&tt);
        *(3+(unsigned char _STATMEM *)&tt) = c;
        /* uglyness -= 1 */
    }
    ASSERT( tt == SWAP_16(TEST_VECT_32));
#endif
}
Example #7
0
extern unsigned_16 DWRVMReadWord( drmem_hdl hdl )
/***********************************************/
{
    page_entry  *node;
    unsigned_16 off;
    virt_struct vm;

    vm.l = hdl;
    ACCESSPAGE( node, vm );
    off = NODE_OFF(vm);
    if( off <= MAX_NODE_SIZE - 2 ) {
        // we can read both bytes now.
        // must not swap bytes in source buffer!
        off = *((unsigned_16 *)( node->mem + off ));
    } else {
        off = *(unsigned_8 *)( node->mem + off );
        vm.l++;
        ACCESSPAGE( node, vm );
        off |= ((unsigned_16)*node->mem) << 8;
    }
    if( DWRCurrNode->byte_swap ) {
        SWAP_16( off );
    }
    return( off );
}
Example #8
0
ScmObj Scm_ReadBinaryF16(ScmPort *iport, ScmSymbol *endian)
{
    swap_f16_t v;
    CHECK_ENDIAN(endian);
    if (getbytes(v.buf, 2, iport) == EOF) return SCM_EOF;
    SWAP_16(endian, v);
    return Scm_MakeFlonum(Scm_HalfToDouble(v.val));
}
Example #9
0
ScmObj Scm_GetBinaryS16(ScmUVector *uv, int off, ScmSymbol *endian)
{
    swap_s16_t v;
    CHECK_ENDIAN(endian);
    extract(uv, v.buf, off, 2);
    SWAP_16(endian, v);
    return SCM_MAKE_INT(v.val);
}
Example #10
0
ScmObj Scm_GetBinaryF16(ScmUVector *uv, int off, ScmSymbol *endian)
{
    swap_f16_t v;
    CHECK_ENDIAN(endian);
    extract(uv, v.buf, off, 2);
    SWAP_16(endian, v);
    return Scm_MakeFlonum(Scm_HalfToDouble(v.val));
}
Example #11
0
void Scm_PutBinaryS16(ScmUVector *uv, int off, ScmObj val, ScmSymbol *e)
{
    swap_s16_t v;
    CHECK_ENDIAN(e);
    v.val = Scm_GetInteger16Clamp(val, SCM_CLAMP_NONE, NULL);
    SWAP_16(e, v);
    inject(uv, v.buf, off, 2);
}
Example #12
0
void Scm_PutBinaryF16(ScmUVector *uv, int off, ScmObj val, ScmSymbol *e)
{
    swap_f16_t v;
    CHECK_ENDIAN(e);
    v.val = Scm_DoubleToHalf(Scm_GetDouble(val));
    SWAP_16(e, v);
    inject(uv, v.buf, off, 2);
}
Example #13
0
ScmObj Scm_ReadBinaryS16(ScmPort *iport, ScmSymbol *endian)
{
    swap_s16_t v;
    CHECK_ENDIAN(endian);
    if (getbytes(v.buf, 2, iport) == EOF) return SCM_EOF;
    SWAP_16(endian, v);
    return SCM_MAKE_INT(v.val);
}
Example #14
0
void Scm_WriteBinaryS16(ScmObj sval, ScmPort *oport, ScmSymbol *endian)
{
    swap_s16_t v;
    ENSURE_OPORT(oport);
    CHECK_ENDIAN(endian);
    v.val = Scm_GetInteger16Clamp(sval, SCM_CLAMP_NONE, NULL);
    SWAP_16(endian, v);
    Scm_Putz(v.buf, 2, oport);
}
Example #15
0
void Scm_WriteBinaryF16(ScmObj sval, ScmPort *oport, ScmSymbol *endian)
{
    swap_f16_t v;
    ENSURE_OPORT(oport);
    CHECK_ENDIAN(endian);
    v.val = Scm_DoubleToHalf(Scm_GetDouble(sval));
    SWAP_16(endian, v);
    Scm_Putz(v.buf, 2, oport);
}
Example #16
0
extern unsigned_16 DWRVMReadWord( dr_handle hdl )
/***********************************************/
{
    unsigned_16     word = *((unsigned_16 _WCUNALIGNED *)(hdl));

    if( DWRCurrNode->byte_swap ) {
        SWAP_16( word );
    }
    return( word );
}
Example #17
0
unsigned short letoh16(unsigned short x)
{
    unsigned short n = 0x1234;
    unsigned char* ch = (unsigned char*)&n;

    if (*ch == 0x34)
    {
        /* Little-endian */
        return x;
    } else {
        return SWAP_16(x);
    }
}
Example #18
0
File: ctf.c Project: DataIX/src
static void
write_objects(iidesc_t *idp, ctf_buf_t *b)
{
	ushort_t id = (idp ? idp->ii_dtype->t_id : 0);

	ctf_buf_write(b, &id, sizeof (id));

	if (target_requires_swap) {
		SWAP_16(id);
	}

	debug(3, "Wrote object %s (%d)\n", (idp ? idp->ii_name : "(null)"), id);
}
Example #19
0
/*
 * Dump the ELF header, if any.
 */
bool Dmp_elf_header( unsigned long start )
/****************************************/
{
    Wread( &Elf_head, sizeof( Elf32_Ehdr ) );
    if( memcmp( Elf_head.e_ident, ELF_SIGNATURE, ELF_SIGNATURE_LEN ) ) {
        return( 0 );
    }
    Banner( "ELF Header" );
    if( start != 0 ) {
        Wdputs( "File Offset:" );
        Puthex( start, 8 );
        Wdputslc( "\n" );
    }
    Wdputs( "class (1==32-bit objects, 2==64-bit objs)   =       " );
    Puthex( Elf_head.e_ident[EI_CLASS], 2 );
    Wdputslc( "H\ndata  (1==little-endian, 2==big-endian)     =       " );
    Puthex( Elf_head.e_ident[EI_DATA], 2 );
    Wdputslc( "H\nversion                                     =       " );
    Puthex( Elf_head.e_ident[EI_VERSION], 2 );
    Wdputslc( "H\nOS/ABI type (0==unspecified)                =       " );
    Puthex( Elf_head.e_ident[EI_OSABI], 2 );
    Wdputslc( "H\nABI version (0==unspecified)                =       " );
    Puthex( Elf_head.e_ident[EI_ABIVERSION], 2 );
    Wdputslc( "H\n" );
    if( Elf_head.e_ident[EI_DATA] != NATIVE_ENDIAN ) {
        Byte_swap = TRUE;

        /* Byte swap ELF header */
        SWAP_16( Elf_head.e_type );
        SWAP_16( Elf_head.e_machine );
        SWAP_32( Elf_head.e_version );
        SWAP_32( Elf_head.e_entry );
        SWAP_32( Elf_head.e_phoff );
        SWAP_32( Elf_head.e_shoff );
        SWAP_32( Elf_head.e_flags );
        SWAP_16( Elf_head.e_ehsize );
        SWAP_16( Elf_head.e_phentsize );
        SWAP_16( Elf_head.e_phnum );
        SWAP_16( Elf_head.e_shentsize );
        SWAP_16( Elf_head.e_shnum );
        SWAP_16( Elf_head.e_shstrndx );
    }
    dmp_hdr_type( Elf_head.e_type );
    Dump_header( &Elf_head.e_type, elf_exe_msg );
    Wdputslc( "\n" );
    dmp_prog_sec( start );
    return( 1 );
}
Example #20
0
static void
label(ud_handle_t udh, uint32_t set_flags)
{
	if (set_flags == 0) {
		if (udh->udfs.flags & VALID_MVDS) {
			print_info(&udh->udfs.mvds, "mvds", udh);
		}
		if (udh->udfs.flags & VALID_RVDS) {
			print_info(&udh->udfs.rvds, "rvds", udh);
		}
		return;
	} else {

		if (udh->udfs.flags & VALID_MVDS) {
			label_vds(&udh->udfs.mvds, set_flags, udh);
		}
		if (udh->udfs.flags & VALID_RVDS) {
			label_vds(&udh->udfs.rvds, set_flags, udh);
		}
		if (((set_flags & (SET_FSNAME | SET_VOLNAME)) ==
			(SET_FSNAME | SET_VOLNAME)) &&
			(udh->udfs.fsd_len != 0)) {
			struct file_set_desc *fsd;

			off = udh->udfs.fsd_loc * udh->udfs.lbsize;
			if (ud_read_dev(udh, off, buf,
				udh->udfs.fsd_len) != 0) {
				return;
			}

			/* LINTED */
			fsd = (struct file_set_desc *)buf;

			set_dstring(fsd->fsd_lvid,
				volname, sizeof (fsd->fsd_lvid));
			set_dstring(fsd->fsd_fsi,
				volname, sizeof (fsd->fsd_fsi));

			ud_make_tag(udh, &fsd->fsd_tag, UD_FILE_SET_DESC,
				SWAP_32(fsd->fsd_tag.tag_loc),
				SWAP_16(fsd->fsd_tag.tag_crc_len));

			(void) ud_write_dev(udh, off, buf, udh->udfs.fsd_len);
		}
	}
}
Example #21
0
/* Read ELF header and check if it's roughly what we're expecting */
int elf_read_hdr( int fd, Elf32_Ehdr *e_hdr )
{
//    Elf32_Phdr  phdr;
//    size_t      i;
    int     result = FALSE;

    lseek( fd, 0, SEEK_SET );
    if( read( fd, e_hdr, sizeof( *e_hdr ) ) >= sizeof( *e_hdr ) &&
        memcmp( e_hdr->e_ident, ELF_SIGNATURE, 4 ) == 0 &&
        e_hdr->e_ident[EI_CLASS] == ELFCLASS32) {
#ifdef __BIG_ENDIAN__
        if( e_hdr->e_ident[EI_DATA] == ELFDATA2LSB )
            core_info.swap_bytes = TRUE;
#else
        if( e_hdr->e_ident[EI_DATA] == ELFDATA2MSB )
            core_info.swap_bytes = TRUE;
#endif
        if( core_info.swap_bytes ) {
            SWAP_16( e_hdr->e_type );
            SWAP_16( e_hdr->e_machine );
            SWAP_32( e_hdr->e_version );
            SWAP_32( e_hdr->e_entry );
            SWAP_32( e_hdr->e_phoff );
            SWAP_32( e_hdr->e_shoff );
            SWAP_32( e_hdr->e_flags );
            SWAP_16( e_hdr->e_ehsize );
            SWAP_16( e_hdr->e_phentsize );
            SWAP_16( e_hdr->e_phnum );
            SWAP_16( e_hdr->e_shentsize );
            SWAP_16( e_hdr->e_shnum );
            SWAP_16( e_hdr->e_shstrndx );
        }
        if( e_hdr->e_phoff != 0 && e_hdr->e_phentsize >= sizeof( Elf32_Phdr ) ) {
            result = TRUE;
        }
    }
    return( result );
}
Example #22
0
UInt16 mlsConfigGetAckCheckTimeout()
{
	return SWAP_16(gConfigData.settlementAckCheckTimeout);
}
Example #23
0
UInt16 mlsConfigGetAckCheckingInterval()
{
	return SWAP_16(gConfigData.settlementAckCheckingInterval);
}
Example #24
0
UInt16 mlsConfigGetMdFileErrorAge()
{
	return SWAP_16(gConfigData.mdFileErrorAge);
}
Example #25
0
UInt16 mlsConfigGetMdFileWarningAge()
{
	return SWAP_16(gConfigData.mdFileWarningAge);
}
Example #26
0
UInt16 mlsConfigGetBatchClearanceDay()
{
	return SWAP_16(gConfigData.batchClearanceDay);
}
Example #27
0
UInt16 mlsConfigGetNETSMdLimit()
{
	return SWAP_16(gConfigData.netsMDLimit);
}
Example #28
0
UInt16 mlsConfigGetEZMdLimit()
{
	return SWAP_16(gConfigData.ezMDLimit);
}
Example #29
0
#define CONFIG_DEBUG_HEADER			"CFG_:"
#define CONFIG_DEBUG_PRINTF(...)	mlsDebugModPrintf(DEBUG_MODULE_ID_CONFIG, CONFIG_DEBUG_HEADER __VA_ARGS__)

//#ifdef CONFIG_DEBUG
//#define CONFIG_DEBUG_PRINTF	mlsDebugPrintf
//#else
//#define CONFIG_DEBUG_PRINTF(...)
//#endif

#define CONFIGURATION_DATA_FORMAT_VERSION		0x0100
//#define SING_DEFAULT_CONFIG_VALUE

ConfigFile	gConfigData;

const ConfigFile defaultConfig = {
		.formatVersion 					= SWAP_16(CONFIGURATION_DATA_FORMAT_VERSION),
		.effectiveDate 					= "20100101",
		.merchantChainID 				= "00000",
		.locationID 					= "00000",
		.deviceType						= "0080",
		.deviceID						= "CCTVending",
		.merchantID						= "000000000000000",
		.merchantPOSID					= "0000000000",
		.cardSerialNumber				= "00000000",
		.netsTerminalSerialNumber		= {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
		.netsMerchantIdentifier			= "Z1Z",
		.gprsEnable						= 1,
		.gprsRetryInterval				= SWAP_16(1),
#ifdef SING_DEFAULT_CONFIG_VALUE
		.gprsAPNserver					= "sunsurf",
		.gprsAPNUserName				= "",
Example #30
0
/*
 * Search for the prn in the array
 * of partitions and translate
 * to the disk block number
 */
daddr_t
ud_xlate_to_daddr(struct udf_vfs *udf_vfsp,
	uint16_t prn, uint32_t blkno, int32_t nblks, uint32_t *count)
{
	int32_t i;
	struct ud_map *map;
	struct ud_part *ud_parts;
	uint32_t lblkno, retblkno = 0, *addr;
	uint32_t begin_req, end_req;
	uint32_t begin_bad, end_bad;

	ud_printf("ud_xlate_to_daddr\n");

	/* Is prn valid */
	if (prn < udf_vfsp->udf_nmaps) {
		map = &(udf_vfsp->udf_maps[prn]);

		if (map->udm_flags == UDM_MAP_VPM) {
			/*
			 * Map is Virtual Parition Map
			 * first check for the appropriate
			 * table and then return the converted
			 * block number
			 */
			for (i = 0; i < map->udm_nent; i++) {
				if (blkno < map->udm_count[i]) {
					addr = map->udm_addr[i];
					lblkno = SWAP_32(addr[blkno]);
					*count = 1;
					break;
				} else {
					blkno -= map->udm_count[i];
				}
			}
		} else if (map->udm_flags == UDM_MAP_SPM) {
			struct stbl *stbl;
			struct stbl_entry *te;
			int32_t entry_count;

			/*
			 * Map type is Sparable Parition Map
			 * if the block is in the map
			 * return the translated block
			 * other wise use the regular
			 * partition stuff
			 */
			begin_req = blkno;
			end_req = begin_req + nblks;

			stbl = (struct stbl *)map->udm_spaddr[0];
			te = (struct stbl_entry *)&stbl->stbl_entry;
			entry_count = SWAP_16(stbl->stbl_len);

			for (i = 0; i < entry_count; i++, te++) {
				begin_bad = SWAP_32(te->sent_ol);
				end_bad = begin_bad + map->udm_plen;

				/*
				 * Either unmapped or reserved
				 * or defective. need not consider
				 */
				if (begin_bad >= (uint32_t)0xFFFFFFF0) {
					continue;
				}
				if ((end_req < begin_bad) ||
				    (begin_req >= end_bad)) {
					continue;
				}

				if (begin_req < begin_bad) {
					ASSERT(end_req >= begin_bad);
					end_req = begin_bad;
				} else {
					retblkno = SWAP_32(te->sent_ml) +
					    begin_req - begin_bad;
					if (end_req < end_bad) {
						*count = end_req - begin_req;
					} else {
						*count = end_bad - begin_req;
					}
					goto end;
				}
			}

			lblkno = blkno;
			*count = end_req - begin_req;
		} else {
			/*
			 * regular partition
			 */
			lblkno = blkno;
			*count = nblks;
		}
		ud_parts = udf_vfsp->udf_parts;
		for (i = 0; i < udf_vfsp->udf_npart; i++) {
			if (map->udm_pn == ud_parts->udp_number) {
				/*
				 * Check if the block is inside
				 * the partition or not
				 */
				if (lblkno >= ud_parts->udp_length) {
					retblkno = 0;
				} else {
					retblkno = ud_parts->udp_start + lblkno;
				}
				goto end;
			}
			ud_parts ++;
		}
	}

end:
	return (retblkno);
}