void type_write(type_t t, type_wr_ctx_t ctx)
{
fbuf_t *f = tree_write_file(ctx->tree_ctx);
if (t == NULL) {
write_u16(UINT16_C(0xffff), f); // Null marker
return;
}
if (t->generation == ctx->generation) {
// Already visited this type
write_u16(UINT16_C(0xfffe), f); // Back reference marker
write_u32(t->index, f);
return;
}
t->generation = ctx->generation;
t->index = (ctx->n_types)++;
write_u16(t->kind, f);
// Call type_ident here to generate an arbitrary name if needed
ident_write(type_ident(t), ctx->ident_ctx);
const uint32_t has = has_map[t->kind];
const int nitems = __builtin_popcount(has);
uint32_t mask = 1;
for (int n = 0; n < nitems; mask <<= 1) {
if (has & mask) {
if (ITEM_TYPE_ARRAY & mask) {
type_array_t *a = &(t->items[n].type_array);
write_u16(a->count, f);
for (unsigned i = 0; i < a->count; i++)
type_write(a->items[i], ctx);
}
else if (ITEM_TYPE & mask)
type_write(t->items[n].type, ctx);
else if (ITEM_TREE & mask)
tree_write(t->items[n].tree, ctx->tree_ctx);
else if (ITEM_TREE_ARRAY & mask) {
tree_array_t *a = &(t->items[n].tree_array);
write_u16(a->count, f);
for (unsigned i = 0; i < a->count; i++)
tree_write(a->items[i], ctx->tree_ctx);
}
else if (ITEM_RANGE_ARRAY & mask) {
range_array_t *a = &(t->items[n].range_array);
write_u16(a->count, f);
for (unsigned i = 0; i < a->count; i++) {
write_u8(a->items[i].kind, f);
tree_write(a->items[i].left, ctx->tree_ctx);
tree_write(a->items[i].right, ctx->tree_ctx);
}
}
else
item_without_type(mask);
n++;
}
}
}
static void do_test_libeprom24x(void)
{
int value;
do {
print_menu();
printf("Enter choice : ");
scanf("%d",&value);
switch(value) {
case 1:
get_prod_info();
break;
case 2:
get_last_error();
break;
case 3:
initialize();
break;
case 4:
finalize();
break;
case 5:
read_u8();
break;
case 6:
read_u16();
break;
case 7:
read_u32();
break;
case 8:
read_to_buffer();
break;
case 9:
write_u8();
break;
case 10:
write_u16();
break;
case 11:
write_u32();
break;
case 12:
write_from_buffer();
break;
case 13:
erase_chip();
break;
case 100: /* Exit */
break;
default:
printf("Illegal choice!\n");
}
} while (value != 100);
return;
}
u32 xbinary_writer::write(s8 b)
{
if (_can_write(len_, cursor_, sizeof(b)))
{
write_u8(buffer_ + cursor_, b);
cursor_ += sizeof(b);
return sizeof(b);
}
return 0;
}
u32 xbinary_writer::write(bool b)
{
if (_can_write(len_, cursor_, 1))
{
write_u8(buffer_ + cursor_, b ? 1 : 0);
cursor_ += 1;
return 1;
}
return 0;
}
static void write_u8_func(void** state) {
char buf[27];
char comp_buf[27];
uint8_t value = 0;
uint32_t idx = 0;
for(uint32_t i = 0; i < CHAR_SIZE; i++) {
value = 'a' + i;
sprintf(comp_buf + i, "%c%c", 'a' + i, '\0');
write_u8(buf, value, &idx);
buf[idx] = '\0';
assert_string_equal(buf, comp_buf);
}
}
/* flush out any data in a stream buffer. Return -1 on failure */
static int flush_buffer(struct stream_info *sinfo, int stream)
{
int c_type = CTYPE_NONE;
i64 c_len = sinfo->s[stream].buflen;
if (seekto(sinfo, sinfo->s[stream].last_head) != 0)
return -1;
if (write_i64(sinfo->fd, sinfo->cur_pos) != 0)
return -1;
sinfo->s[stream].last_head = sinfo->cur_pos + 17;
if (seekto(sinfo, sinfo->cur_pos) != 0)
return -1;
if (!(control.flags & FLAG_NO_COMPRESS)) {
if (LZMA_COMPRESS(control.flags))
lzma_compress_buf(&sinfo->s[stream], &c_type, &c_len);
else if (control.flags & FLAG_LZO_COMPRESS)
lzo_compress_buf(&sinfo->s[stream], &c_type, &c_len);
else if (control.flags & FLAG_BZIP2_COMPRESS)
bzip2_compress_buf(&sinfo->s[stream], &c_type, &c_len);
else if (control.flags & FLAG_ZLIB_COMPRESS)
gzip_compress_buf(&sinfo->s[stream], &c_type, &c_len);
else if (control.flags & FLAG_ZPAQ_COMPRESS)
zpaq_compress_buf(&sinfo->s[stream], &c_type, &c_len);
else fatal("Dunno wtf compression to use!\n");
}
if (write_u8(sinfo->fd, c_type) != 0 ||
write_i64(sinfo->fd, c_len) != 0 ||
write_i64(sinfo->fd, sinfo->s[stream].buflen) != 0 ||
write_i64(sinfo->fd, 0) != 0) {
return -1;
}
sinfo->cur_pos += 25;
if (write_buf(sinfo->fd, sinfo->s[stream].buf, c_len) != 0)
return -1;
sinfo->cur_pos += c_len;
sinfo->s[stream].buflen = 0;
free(sinfo->s[stream].buf);
sinfo->s[stream].buf = malloc(sinfo->bufsize);
if (!sinfo->s[stream].buf)
return -1;
return 0;
}
void ADXL345_init(int fd)
{
write_u8(fd, ADXL345_DATA_FORMAT, 0x0B); // +-16g, 13-bit
write_u8(fd, ADXL345_POWER_CTL, 0x08); // start measurement
//write_u8(fd, ADXL345_INT_ENABLE, 0x80); // enable DATA_READY interrupt
}
void process(NIC* ni) {
static uint32_t myip = 0xc0a86402; // 192.168.100.2
Packet* packet = nic_input(ni);
if(!packet)
return;
Ether* ether = (Ether*)(packet->buffer + packet->start);
if(endian16(ether->type) == ETHER_TYPE_ARP) {
// ARP response
ARP* arp = (ARP*)ether->payload;
if(endian16(arp->operation) == 1 && endian32(arp->tpa) == myip) {
ether->dmac = ether->smac;
ether->smac = endian48(ni->mac);
arp->operation = endian16(2);
arp->tha = arp->sha;
arp->tpa = arp->spa;
arp->sha = ether->smac;
arp->spa = endian32(myip);
nic_output(ni, packet);
packet = NULL;
}
} else if(endian16(ether->type) == ETHER_TYPE_IPv4) {
IP* ip = (IP*)ether->payload;
if(ip->protocol == IP_PROTOCOL_ICMP && endian32(ip->destination) == myip) {
// Echo reply
ICMP* icmp = (ICMP*)ip->body;
icmp->type = 0;
icmp->checksum = 0;
icmp->checksum = endian16(checksum(icmp, packet->end - packet->start - ETHER_LEN - IP_LEN));
ip->destination = ip->source;
ip->source = endian32(myip);
ip->ttl = endian8(64);
ip->checksum = 0;
ip->checksum = endian16(checksum(ip, ip->ihl * 4));
ether->dmac = ether->smac;
ether->smac = endian48(ni->mac);
nic_output(ni, packet);
packet = NULL;
} else if(ip->protocol == IP_PROTOCOL_UDP) {
UDP* udp = (UDP*)ip->body;
if(endian16(udp->destination) == 9000) {
reply_count = 2;
// Control packet
uint32_t idx = 0;
seq = read_u16(udp->body, &idx);
user_mac = endian48(ether->smac);
user_ip = endian32(ip->source);
user_port = endian16(udp->source);
uint8_t msg = read_u8(udp->body, &idx);
switch(msg) {
case 1: // MSG_CREATE
{
idx++; // read ctype
uint32_t clen = read_u32(udp->body, &idx);
char collection[clen + 1];
collection[clen] = '\0';
memcpy(collection, udp->body + idx, clen);
idx += clen;
uint64_t id = newID(collection);
memmove(udp->body + idx + 9, udp->body + idx, endian16(udp->length) - 8 - idx);
packet->end += 9;
udp->length = endian16(endian16(udp->length) + 9);
ip->length = endian16(endian16(ip->length) + 9);
write_u8(udp->body, 4, &idx);
write_u64(udp->body, id, &idx);
}
break;
case 2: // MSG_READ
reply_count = 1;
break;
case 3: // MSG_RETRIEVE
break;
case 4: // MSG_UPDATE
break;
case 5: // MSG_DELETE
break;
case 6: // MSG_HELLO
reply_count = 1;
break;
}
udp->source = endian16(9999);
udp->destination = endian16(9001);
udp->checksum = 0;
ip->destination = ip->source;
ip->source = endian32(myip);
ip->ttl = endian8(ip->ttl) - 1;
ip->checksum = 0;
ip->checksum = endian16(checksum(ip, ip->ihl * 4));
ether->dmac = ether->smac;
ether->smac = endian48(ni->mac);
nic_output_dup(ni, packet);
udp->destination = endian16(9002);
ip->checksum = 0;
ip->checksum = endian16(checksum(ip, ip->ihl * 4));
nic_output_dup(ni, packet);
udp->destination = endian16(9003);
ip->checksum = 0;
ip->checksum = endian16(checksum(ip, ip->ihl * 4));
nic_output(ni, packet);
packet = NULL;
} else if(endian16(udp->destination) == 9999) {
uint32_t idx = 0;
uint16_t seq2 = read_u16(udp->body, &idx);
if(seq == seq2 && --reply_count == 0) {
udp->checksum = 0;
udp->destination = endian16(user_port);
udp->source = endian16(9000);
ip->destination = endian32(user_ip);
ip->source = endian32(myip);
ip->ttl = endian8(64);
ip->checksum = 0;
ip->checksum = endian16(checksum(ip, ip->ihl * 4));
ether->dmac = endian48(user_mac);
ether->smac = endian48(ni->mac);
nic_output(ni, packet);
packet = NULL;
}
}
}
}
if(packet)
nic_free(packet);
}
/* open a set of output streams, compressing with the given
compression level and algorithm */
void *open_stream_out(int f, int n, i64 limit)
{
unsigned cwindow = control.window;
int i;
struct stream_info *sinfo;
sinfo = malloc(sizeof(*sinfo));
if (!sinfo)
return NULL;
sinfo->num_streams = n;
sinfo->cur_pos = 0;
sinfo->fd = f;
/* 10MB streams for non lzma compress. There is virtually no gain
in lzo, gzip and bzip2 with larger streams. With lzma and zpaq,
however, the larger the buffer, the better the compression so we
make it as large as the window up to the limit the compressor
will take */
if (LZMA_COMPRESS(control.flags)) {
if (sizeof(long) == 4) {
/* Largest window supported on lzma 32bit is 600MB */
if (cwindow > 6)
cwindow = 6;
}
/* Largest window supported on lzma 64bit is 4GB */
if (cwindow > 40)
cwindow = 40;
}
if (LZMA_COMPRESS(control.flags) || (control.flags & FLAG_ZPAQ_COMPRESS))
sinfo->bufsize = STREAM_BUFSIZE * 10 * cwindow;
else
sinfo->bufsize = STREAM_BUFSIZE;
/* No point making the stream larger than the amount of data */
if (limit && limit < sinfo->bufsize)
sinfo->bufsize = limit;
sinfo->initial_pos = lseek(f, 0, SEEK_CUR);
sinfo->s = (struct stream *)calloc(sizeof(sinfo->s[0]), n);
if (!sinfo->s) {
free(sinfo);
return NULL;
}
for (i = 0; i < n; i++) {
sinfo->s[i].buf = malloc(sinfo->bufsize);
if (!sinfo->s[i].buf)
goto failed;
}
/* write the initial headers */
for (i = 0; i < n; i++) {
sinfo->s[i].last_head = sinfo->cur_pos + 17;
write_u8(sinfo->fd, CTYPE_NONE);
write_i64(sinfo->fd, 0);
write_i64(sinfo->fd, 0);
write_i64(sinfo->fd, 0);
sinfo->cur_pos += 25;
}
return (void *)sinfo;
failed:
for (i = 0; i < n; i++) {
if (sinfo->s[i].buf)
free(sinfo->s[i].buf);
}
free(sinfo);
return NULL;
}
