static int get_memfree (CalcHandle* handle, uint32_t* ram, uint32_t* flash)
{
uint16_t pids[] = { PID_FREE_RAM, PID_FREE_FLASH };
const int size = sizeof(pids) / sizeof(uint16_t);
CalcParam **params;
params = cp_new_array(size);
TRYF(cmd_s_param_request(handle, size, pids));
TRYF(cmd_r_param_data(handle, size, params));
*ram = (uint32_t)GINT64_FROM_BE(*((uint64_t *)(params[0]->data)));
*flash = (uint32_t)GINT64_FROM_BE(*((uint64_t *)(params[1]->data)));
cp_del_array(size, params);
return 0;
}
static gint
file_index_compare (gconstpointer sample, gconstpointer row, gpointer user_data)
{
//GstFileIndexId *id_index = user_data;
const GstIndexAssociation *ca = sample;
gint64 val1 = ca->value;
gint64 val2_be = ARRAY_ROW_VALUE (row, ca->format);
gint64 val2 = GINT64_FROM_BE (val2_be);
gint64 diff = val2 - val1;
return (diff == 0 ? 0 : (diff < 0 ? 1 : -1));
}
gboolean
g_vfs_afp_reply_read_int64 (GVfsAfpReply *reply, gint64 *val)
{
if ((reply->len - reply->pos) < 8)
return FALSE;
if (val)
*val = GINT64_FROM_BE (*((gint64 *)(reply->data + reply->pos)));
reply->pos += 8;
return TRUE;
}
void
io_recode_data_copy (const gchar *src, gchar *dest, DSType type, gsize nvals)
{
gsize i;
IOConstBufptr bsrc;
IOBufptr bdest;
bsrc.any = src;
bdest.any = dest;
switch (type) {
case DST_BIN:
case DST_I8:
case DST_TEXT:
memcpy (dest, src, nvals);
break;
case DST_I16:
for (i = 0; i < nvals; i++) {
*(bdest.i16) = GINT16_FROM_BE(*(bsrc.i16));
bdest.i16++;
bsrc.i16++;
}
break;
case DST_C64:
nvals *= 2;
/* fall through */
case DST_I32:
case DST_F32:
for (i = 0; i < nvals; i++) {
*(bdest.i32) = GINT32_FROM_BE(*(bsrc.i32));
bdest.i32++;
bsrc.i32++;
}
break;
case DST_I64:
case DST_F64:
for (i = 0; i < nvals; i++) {
*(bdest.i64) = GINT64_FROM_BE(*(bsrc.i64));
bdest.i64++;
bsrc.i64++;
}
break;
default:
g_error ("Unhandled data typecode %d!", type);
break;
}
}
void
io_recode_data_inplace (gchar *data, DSType type, gsize nvals)
{
gsize i;
IOBufptr bdata;
bdata.any = data;
switch (type) {
case DST_BIN:
case DST_I8:
case DST_TEXT:
break;
case DST_I16:
for (i = 0; i < nvals; i++) {
*(bdata.i16) = GINT16_FROM_BE(*(bdata.i16));
bdata.i16++;
}
break;
case DST_C64:
nvals *= 2;
/* fall through */
case DST_I32:
case DST_F32:
for (i = 0; i < nvals; i++) {
*(bdata.i32) = GINT32_FROM_BE(*(bdata.i32));
bdata.i32++;
}
break;
case DST_I64:
case DST_F64:
for (i = 0; i < nvals; i++) {
*(bdata.i64) = GINT64_FROM_BE(*(bdata.i64));
bdata.i64++;
}
break;
default:
g_error ("Unhandled data typecode %d!", type);
break;
}
}
/**
* qmi_utils_read_gint64_from_buffer:
* @buffer: a buffer with raw binary data.
* @buffer_size: size of @buffer.
* @endian: endianness of firmware value; swapped to host byte order if necessary
* @out: return location for the read variable.
*
* Reads a signed 64-bit integer from the buffer. The number in the buffer is
* expected to be given in the byte order specified by @endian, and this method
* takes care of converting the read value to the proper host endianness.
*
* The user needs to make sure that at least 8 bytes are available
* in the buffer.
*
* Also note that both @buffer and @buffer_size get updated after the 8 bytes
* read.
*/
void
qmi_utils_read_gint64_from_buffer (const guint8 **buffer,
guint16 *buffer_size,
QmiEndian endian,
gint64 *out)
{
g_assert (out != NULL);
g_assert (buffer != NULL);
g_assert (buffer_size != NULL);
g_assert (*buffer_size >= 8);
memcpy (out, &((*buffer)[0]), 8);
if (endian == QMI_ENDIAN_BIG)
*out = GINT64_FROM_BE (*out);
else
*out = GINT64_FROM_LE (*out);
print_read_bytes_trace ("gint64", &(*buffer)[0], out, 8);
*buffer = &((*buffer)[8]);
*buffer_size = (*buffer_size) - 8;
}
static gboolean btsnoop_read(wtap *wth, int *err, gchar **err_info,
gint64 *data_offset)
{
guint32 packet_size;
guint32 flags;
guint32 orig_size;
int bytes_read;
struct btsnooprec_hdr hdr;
gint64 ts;
/* As the send/receive flag is stored in the middle of the capture header
but needs to go in the pseudo header for wiretap, the header needs to be reread
in the seek_read function*/
*data_offset = wth->data_offset;
/* Read record header. */
errno = WTAP_ERR_CANT_READ;
bytes_read = file_read(&hdr, sizeof hdr, wth->fh);
if (bytes_read != sizeof hdr) {
*err = file_error(wth->fh, err_info);
if (*err == 0 && bytes_read != 0)
*err = WTAP_ERR_SHORT_READ;
return FALSE;
}
wth->data_offset += sizeof hdr;
packet_size = g_ntohl(hdr.incl_len);
orig_size = g_ntohl(hdr.orig_len);
flags = g_ntohl(hdr.flags);
if (packet_size > WTAP_MAX_PACKET_SIZE) {
/*
* Probably a corrupt capture file; don't blow up trying
* to allocate space for an immensely-large packet.
*/
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup_printf("btsnoop: File has %u-byte packet, bigger than maximum of %u",
packet_size, WTAP_MAX_PACKET_SIZE);
return FALSE;
}
buffer_assure_space(wth->frame_buffer, packet_size);
if (!snoop_read_rec_data(wth->fh, buffer_start_ptr(wth->frame_buffer),
packet_size, err, err_info)) {
return FALSE; /* Read error */
}
wth->data_offset += packet_size;
ts = GINT64_FROM_BE(hdr.ts_usec);
ts -= KUnixTimeBase;
wth->phdr.presence_flags = WTAP_HAS_TS|WTAP_HAS_CAP_LEN;
wth->phdr.ts.secs = (guint)(ts / 1000000);
wth->phdr.ts.nsecs = (guint)((ts % 1000000) * 1000);
wth->phdr.caplen = packet_size;
wth->phdr.len = orig_size;
if(wth->file_encap == WTAP_ENCAP_BLUETOOTH_H4_WITH_PHDR)
{
wth->pseudo_header.p2p.sent = (flags & KHciLoggerControllerToHost) ? FALSE : TRUE;
}
else if(wth->file_encap == WTAP_ENCAP_BLUETOOTH_HCI)
{
wth->pseudo_header.bthci.sent = (flags & KHciLoggerControllerToHost) ? FALSE : TRUE;
if(flags & KHciLoggerCommandOrEvent)
{
if(wth->pseudo_header.bthci.sent)
{
wth->pseudo_header.bthci.channel = BTHCI_CHANNEL_COMMAND;
}
else
{
wth->pseudo_header.bthci.channel = BTHCI_CHANNEL_EVENT;
}
}
else
{
wth->pseudo_header.bthci.channel = BTHCI_CHANNEL_ACL;
}
}
return TRUE;
}
static GstIndexEntry *
gst_file_index_get_assoc_entry (GstIndex * index,
gint id,
GstIndexLookupMethod method,
GstAssocFlags flags,
GstFormat format,
gint64 value, GCompareDataFunc _ignore_func, gpointer _ignore_user_data)
{
GstFileIndex *fileindex = GST_FILE_INDEX (index);
GstFileIndexId *id_index;
gint formatx = -1;
gint fx;
GstIndexAssociation sample;
gint mx;
gboolean exact;
gpointer row_data;
GstIndexEntry *entry;
gint xx;
g_return_val_if_fail (id > 0, NULL);
id_index = g_hash_table_lookup (fileindex->id_index, &id);
if (!id_index) {
GST_WARNING_OBJECT (fileindex, "writer %d unavailable", id);
return NULL;
}
for (fx = 0; fx < id_index->nformats; fx++)
if (id_index->format[fx] == format) {
formatx = fx;
break;
}
if (formatx == -1) {
GST_WARNING_OBJECT (fileindex, "format %d not available", format);
return NULL;
}
/* this is a hack, we should use a private structure instead */
sample.format = formatx;
sample.value = value;
exact = _fc_bsearch (id_index->array, ARRAY_ROW_SIZE (id_index),
&mx, file_index_compare, &sample, id_index);
if (!exact) {
if (method == GST_INDEX_LOOKUP_EXACT)
return NULL;
else if (method == GST_INDEX_LOOKUP_BEFORE) {
if (mx == 0)
return NULL;
mx -= 1;
} else if (method == GST_INDEX_LOOKUP_AFTER) {
if (mx == id_index->array->len)
return NULL;
}
}
row_data = id_index->array->data + mx * ARRAY_ROW_SIZE (id_index);
/* if exact then ignore flags (?) */
if (method != GST_INDEX_LOOKUP_EXACT)
while ((GINT32_FROM_BE (ARRAY_ROW_FLAGS (row_data)) & flags) != flags) {
if (method == GST_INDEX_LOOKUP_BEFORE)
mx -= 1;
else if (method == GST_INDEX_LOOKUP_AFTER)
mx += 1;
if (mx < 0 || mx >= id_index->array->len)
return NULL;
row_data = id_index->array->data + mx * ARRAY_ROW_SIZE (id_index);
}
/* entry memory management needs improvement FIXME */
if (!fileindex->ret_entry)
fileindex->ret_entry = g_slice_new0 (GstIndexEntry);
entry = fileindex->ret_entry;
if (entry->data.assoc.assocs) {
g_free (entry->data.assoc.assocs);
entry->data.assoc.assocs = NULL;
}
entry->type = GST_INDEX_ENTRY_ASSOCIATION;
GST_INDEX_NASSOCS (entry) = id_index->nformats;
entry->data.assoc.assocs = g_new (GstIndexAssociation, id_index->nformats);
{
gint32 flags_be = ARRAY_ROW_FLAGS (row_data);
GST_INDEX_ASSOC_FLAGS (entry) = GINT32_FROM_BE (flags_be);
for (xx = 0; xx < id_index->nformats; xx++) {
gint64 val_be = ARRAY_ROW_VALUE (row_data, xx);
GST_INDEX_ASSOC_FORMAT (entry, xx) = id_index->format[xx];
GST_INDEX_ASSOC_VALUE (entry, xx) = GINT64_FROM_BE (val_be);
}
}
return entry;
}
static inline gint64 gint64_from_be (const gint64_be be) {
gint64 tmp; memcpy (&tmp, &be, sizeof tmp); return GINT64_FROM_BE (tmp);
}
static gboolean btsnoop_read_record(wtap *wth, FILE_T fh,
struct wtap_pkthdr *phdr, Buffer *buf, int *err, gchar **err_info)
{
int bytes_read;
struct btsnooprec_hdr hdr;
guint32 packet_size;
guint32 flags;
guint32 orig_size;
gint64 ts;
/* Read record header. */
errno = WTAP_ERR_CANT_READ;
bytes_read = file_read(&hdr, sizeof hdr, fh);
if (bytes_read != sizeof hdr) {
*err = file_error(fh, err_info);
if (*err == 0 && bytes_read != 0)
*err = WTAP_ERR_SHORT_READ;
return FALSE;
}
packet_size = g_ntohl(hdr.incl_len);
orig_size = g_ntohl(hdr.orig_len);
flags = g_ntohl(hdr.flags);
if (packet_size > WTAP_MAX_PACKET_SIZE) {
/*
* Probably a corrupt capture file; don't blow up trying
* to allocate space for an immensely-large packet.
*/
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup_printf("btsnoop: File has %u-byte packet, bigger than maximum of %u",
packet_size, WTAP_MAX_PACKET_SIZE);
return FALSE;
}
ts = GINT64_FROM_BE(hdr.ts_usec);
ts -= KUnixTimeBase;
phdr->rec_type = REC_TYPE_PACKET;
phdr->presence_flags = WTAP_HAS_TS|WTAP_HAS_CAP_LEN;
phdr->ts.secs = (guint)(ts / 1000000);
phdr->ts.nsecs = (guint)((ts % 1000000) * 1000);
phdr->caplen = packet_size;
phdr->len = orig_size;
if(wth->file_encap == WTAP_ENCAP_BLUETOOTH_H4_WITH_PHDR)
{
phdr->pseudo_header.p2p.sent = (flags & KHciLoggerControllerToHost) ? FALSE : TRUE;
} else if(wth->file_encap == WTAP_ENCAP_BLUETOOTH_HCI) {
phdr->pseudo_header.bthci.sent = (flags & KHciLoggerControllerToHost) ? FALSE : TRUE;
if(flags & KHciLoggerCommandOrEvent)
{
if(phdr->pseudo_header.bthci.sent)
{
phdr->pseudo_header.bthci.channel = BTHCI_CHANNEL_COMMAND;
}
else
{
phdr->pseudo_header.bthci.channel = BTHCI_CHANNEL_EVENT;
}
}
else
{
phdr->pseudo_header.bthci.channel = BTHCI_CHANNEL_ACL;
}
} else if (wth->file_encap == WTAP_ENCAP_BLUETOOTH_LINUX_MONITOR) {
phdr->pseudo_header.btmon.opcode = flags & 0xFFFF;
phdr->pseudo_header.btmon.adapter_id = flags >> 16;
}
static int get_version (CalcHandle* handle, CalcInfos* infos)
{
uint16_t pids[] = {
PID_PRODUCT_NAME, PID_MAIN_PART_ID,
PID_HW_VERSION, PID_LANGUAGE_ID, PID_SUBLANG_ID, PID_DEVICE_TYPE,
PID_BOOT_VERSION, PID_OS_VERSION,
PID_PHYS_RAM, PID_USER_RAM, PID_FREE_RAM,
PID_PHYS_FLASH, PID_USER_FLASH, PID_FREE_FLASH,
PID_LCD_WIDTH, PID_LCD_HEIGHT, PID_BATTERY, PID_OS_MODE,
};
const int size = sizeof(pids) / sizeof(uint16_t);
CalcParam **params;
int i = 0;
g_snprintf(update_->text, sizeof(update_->text), _("Getting version..."));
update_label();
memset(infos, 0, sizeof(CalcInfos));
params = cp_new_array(size);
TRYF(cmd_s_param_request(handle, size, pids));
TRYF(cmd_r_param_data(handle, size, params));
strncpy(infos->product_name, (char*)params[i]->data, params[i]->size);
infos->mask |= INFOS_PRODUCT_NAME;
i++;
g_snprintf(infos->main_calc_id, 10, "%02X%02X%02X%02X%02X",
params[i]->data[0], params[i]->data[1], params[i]->data[2], params[i]->data[3], params[i]->data[4]);
infos->mask |= INFOS_MAIN_CALC_ID;
strcpy(infos->product_id, infos->main_calc_id);
infos->mask |= INFOS_PRODUCT_ID;
i++;
infos->hw_version = (params[i]->data[0] << 8) | params[i]->data[1];
infos->mask |= INFOS_HW_VERSION; // hw version or model ?
i++;
infos->language_id = params[i]->data[0];
infos->mask |= INFOS_LANG_ID;
i++;
infos->sub_lang_id = params[i]->data[0];
infos->mask |= INFOS_SUB_LANG_ID;
i++;
infos->device_type = params[i]->data[1];
infos->mask |= INFOS_DEVICE_TYPE;
i++;
g_snprintf(infos->boot_version, 5, "%1i.%02i", params[i]->data[1], params[i]->data[2]);
infos->mask |= INFOS_BOOT_VERSION;
i++;
g_snprintf(infos->os_version, 5, "%1i.%02i", params[i]->data[1], params[i]->data[2]);
infos->mask |= INFOS_OS_VERSION;
i++;
infos->ram_phys = GINT64_FROM_BE(*((uint64_t *)(params[i]->data)));
infos->mask |= INFOS_RAM_PHYS;
i++;
infos->ram_user = GINT64_FROM_BE(*((uint64_t *)(params[i]->data)));
infos->mask |= INFOS_RAM_USER;
i++;
infos->ram_free = GINT64_FROM_BE(*((uint64_t *)(params[i]->data)));
infos->mask |= INFOS_RAM_FREE;
i++;
infos->flash_phys = GINT64_FROM_BE(*((uint64_t *)(params[i]->data)));
infos->mask |= INFOS_FLASH_PHYS;
i++;
infos->flash_user = GINT64_FROM_BE(*((uint64_t *)(params[i]->data)));
infos->mask |= INFOS_FLASH_USER;
i++;
infos->flash_free = GINT64_FROM_BE(*((uint64_t *)(params[i]->data)));
infos->mask |= INFOS_FLASH_FREE;
i++;
infos->lcd_width = GINT16_FROM_BE(*((uint16_t *)(params[i]->data)));
infos->mask |= INFOS_LCD_WIDTH;
i++;
infos->lcd_height = GINT16_FROM_BE(*((uint16_t *)(params[i]->data)));
infos->mask |= INFOS_LCD_HEIGHT;
i++;
infos->bits_per_pixel = 1;
infos->mask |= INFOS_BPP;
infos->battery = params[i]->data[0];
infos->mask |= INFOS_BATTERY;
i++;
infos->run_level = params[i]->data[0];
infos->mask |= INFOS_RUN_LEVEL;
i++;
switch(infos->hw_version)
{
case 0: infos->model = CALC_TI83P; break;
case 1: infos->model = CALC_TI83P; break;
case 2: infos->model = CALC_TI84P; break;
case 3: infos->model = CALC_TI84P; break;
}
infos->mask |= INFOS_CALC_MODEL;
cp_del_array(size, params);
return 0;
}