static void
fill_wave_header(struct wave_header *header, int channels, int bits,
int freq, int block_size)
{
int data_size = 0x0FFFFFFF;
/* constants */
header->id_riff = GUINT32_TO_LE(0x46464952);
header->id_wave = GUINT32_TO_LE(0x45564157);
header->id_fmt = GUINT32_TO_LE(0x20746d66);
header->id_data = GUINT32_TO_LE(0x61746164);
/* wave format */
header->format = GUINT16_TO_LE(1); // PCM_FORMAT
header->channels = GUINT16_TO_LE(channels);
header->bits = GUINT16_TO_LE(bits);
header->freq = GUINT32_TO_LE(freq);
header->blocksize = GUINT16_TO_LE(block_size);
header->byterate = GUINT32_TO_LE(freq * block_size);
/* chunk sizes (fake data length) */
header->fmt_size = GUINT32_TO_LE(16);
header->data_size = GUINT32_TO_LE(data_size);
header->riff_size = GUINT32_TO_LE(4 + (8 + 16) +
(8 + data_size));
}
static gint wav_open(void)
{
memcpy(&header.main_chunk, "RIFF", 4);
header.length = GUINT32_TO_LE(0);
memcpy(&header.chunk_type, "WAVE", 4);
memcpy(&header.sub_chunk, "fmt ", 4);
header.sc_len = GUINT32_TO_LE(16);
header.format = GUINT16_TO_LE(1);
header.modus = GUINT16_TO_LE(input.channels);
header.sample_fq = GUINT32_TO_LE(input.frequency);
if (input.format == FMT_U8 || input.format == FMT_S8)
header.bit_p_spl = GUINT16_TO_LE(8);
else
header.bit_p_spl = GUINT16_TO_LE(16);
header.byte_p_sec = GUINT32_TO_LE(input.frequency * header.modus * (GUINT16_FROM_LE(header.bit_p_spl) / 8));
header.byte_p_spl = GUINT16_TO_LE((GUINT16_FROM_LE(header.bit_p_spl) / (8 / input.channels)));
memcpy(&header.data_chunk, "data", 4);
header.data_length = GUINT32_TO_LE(0);
if (vfs_fwrite (& header, 1, sizeof header, output_file) != sizeof header)
return 0;
written = 0;
return 1;
}
void
msn_directconn_parse_nonce(MsnDirectConn *directconn, const char *nonce)
{
guint32 t1;
guint16 t2;
guint16 t3;
guint16 t4;
guint64 t5;
g_return_if_fail(directconn != NULL);
g_return_if_fail(nonce != NULL);
sscanf (nonce, "%08X-%04hX-%04hX-%04hX-%012llX", &t1, &t2, &t3, &t4, &t5);
t1 = GUINT32_TO_LE(t1);
t2 = GUINT16_TO_LE(t2);
t3 = GUINT16_TO_LE(t3);
t4 = GUINT16_TO_BE(t4);
t5 = GUINT64_TO_BE(t5);
directconn->slpheader = g_new0(MsnSlpHeader, 1);
directconn->slpheader->ack_id = t1;
directconn->slpheader->ack_sub_id = t2 | (t3 << 16);
directconn->slpheader->ack_size = t4 | t5;
}
/* Write a record for a packet to a dump file.
Returns TRUE on success, FALSE on failure. */
static gboolean _5views_dump(wtap_dumper *wdh,
const struct wtap_pkthdr *phdr,
const guint8 *pd, int *err)
{
_5views_dump_t *_5views = (_5views_dump_t *)wdh->priv;
t_5VW_TimeStamped_Header HeaderFrame;
/* Frame Header */
/* constant fields */
HeaderFrame.Key = GUINT32_TO_LE(CST_5VW_RECORDS_HEADER_KEY);
HeaderFrame.HeaderSize = GUINT16_TO_LE(sizeof(t_5VW_TimeStamped_Header));
HeaderFrame.HeaderType = GUINT16_TO_LE(CST_5VW_TIMESTAMPED_HEADER_TYPE);
HeaderFrame.RecType = GUINT32_TO_LE(CST_5VW_CAPTURES_RECORD | CST_5VW_SYSTEM_RECORD);
HeaderFrame.RecSubType = GUINT32_TO_LE(CST_5VW_FRAME_RECORD);
HeaderFrame.RecNb = GUINT32_TO_LE(1);
/* record-dependent fields */
HeaderFrame.Utc = GUINT32_TO_LE(phdr->ts.secs);
HeaderFrame.NanoSecondes = GUINT32_TO_LE(phdr->ts.nsecs);
HeaderFrame.RecSize = GUINT32_TO_LE(phdr->len);
HeaderFrame.RecInfo = GUINT32_TO_LE(0);
/* write the record header */
if (!wtap_dump_file_write(wdh, &HeaderFrame,
sizeof(t_5VW_TimeStamped_Header), err))
return FALSE;
/* write the data */
if (!wtap_dump_file_write(wdh, pd, phdr->caplen, err))
return FALSE;
_5views->nframes ++;
return TRUE;
}
/* Returns TRUE on success, FALSE on failure; sets "*err" to an error code on
failure */
gboolean network_instruments_dump_open(wtap_dumper *wdh, gboolean cant_seek, int *err)
{
capture_file_header file_header;
tlv_header comment_header;
char comment[64];
struct tm *current_time;
time_t system_time;
niobserver_dump_t *niobserver;
if (cant_seek) {
*err = WTAP_ERR_CANT_WRITE_TO_PIPE;
return FALSE;
}
wdh->subtype_write = observer_dump;
niobserver = (niobserver_dump_t *)g_malloc(sizeof(niobserver_dump_t));
wdh->priv = (void *)niobserver;
niobserver->packet_count = 0;
niobserver->network_type = from_wtap_encap[wdh->encap];
/* create the file comment */
time(&system_time);
current_time = localtime(&system_time);
memset(&comment, 0x00, sizeof(comment));
g_snprintf(comment, 64, "This capture was saved from Wireshark on %s", asctime(current_time));
/* create the file header */
if (fseek(wdh->fh, 0, SEEK_SET) == -1) {
*err = errno;
return FALSE;
}
memset(&file_header, 0x00, sizeof(capture_file_header));
g_strlcpy(file_header.observer_version, network_instruments_magic, 32);
file_header.offset_to_first_packet = (guint16) (sizeof(capture_file_header) + sizeof(tlv_header) + strlen(comment));
file_header.offset_to_first_packet = GUINT16_TO_LE(file_header.offset_to_first_packet);
file_header.number_of_information_elements = 1;
if(!fwrite(&file_header, sizeof(capture_file_header), 1, wdh->fh)) {
*err = errno;
return FALSE;
}
/* create the comment entry */
comment_header.type = GUINT16_TO_LE(INFORMATION_TYPE_COMMENT);
comment_header.length = (guint16) (sizeof(tlv_header) + strlen(comment));
comment_header.length = GUINT16_TO_LE(comment_header.length);
if(!fwrite(&comment_header, sizeof(tlv_header), 1, wdh->fh)) {
*err = errno;
return FALSE;
}
if(!fwrite(&comment, sizeof(char), strlen(comment), wdh->fh)) {
*err = errno;
return FALSE;
}
init_time_offset();
return TRUE;
}
/** Prepare the packet to be sent over the network
*
* It initialize the data values with the local private fields.
*
*/
void RainbruRPG::Network::npIdentification::netSerialize(){
if (clientType==NCT_UNKNOWN){
LOGW(_("The client type is not set"));
}
data->packetIdentifier=GUINT16_TO_LE(this->id);
data->clientType=GUINT16_TO_LE(this->clientType);
}
void gfire_add_header(guint8 *packet, int length, int type, int atts)
{
guint8 buffer[5] = { 0,0,0,0,(guint8) atts };
guint16 l = GUINT16_TO_LE((guint16) length);
guint16 t = GUINT16_TO_LE((guint16) type);
memcpy(buffer,&l,2);
memcpy(buffer+2,&t,2);
memcpy(packet,buffer,XFIRE_HEADER_LEN);
}
static gboolean
set_le_guid (guint8 *buf, const char *source)
{
efi_guid *guid = (efi_guid *) buf;
guint32 __attribute__((__unused__)) data1;
guint16 __attribute__((__unused__)) data2;
guint16 __attribute__((__unused__)) data3;
guint8 __attribute__((__unused__)) data4[8];
gboolean ret;
int n;
n = sscanf (source, "%x-%hx-%hx-%02hhx%02hhx-%02hhx%02hhx%02hhx%02hhx%02hhx%02hhx",
&guid->data1,
&guid->data2,
&guid->data3,
&(guid->data4[0]),
&(guid->data4[1]),
&(guid->data4[2]),
&(guid->data4[3]),
&(guid->data4[4]),
&(guid->data4[5]),
&(guid->data4[6]),
&(guid->data4[7]));
if (n != 11) {
HAL_INFO (("guid '%s' is not valid"));
goto out;
}
#if 0
HAL_INFO (("source = %s", source));
HAL_INFO (("data1 = %08x", guid->data1));
HAL_INFO (("data2 = %04x", guid->data2));
HAL_INFO (("data3 = %04x", guid->data3));
HAL_INFO (("data4[0] = %02x", guid->data4[0]));
HAL_INFO (("data4[1] = %02x", guid->data4[1]));
HAL_INFO (("data4[2] = %02x", guid->data4[2]));
HAL_INFO (("data4[3] = %02x", guid->data4[3]));
HAL_INFO (("data4[4] = %02x", guid->data4[4]));
HAL_INFO (("data4[5] = %02x", guid->data4[5]));
HAL_INFO (("data4[6] = %02x", guid->data4[6]));
HAL_INFO (("data4[7] = %02x", guid->data4[7]));
#endif
guid->data1 = GUINT32_TO_LE (guid->data1);
guid->data2 = GUINT16_TO_LE (guid->data2);
guid->data3 = GUINT16_TO_LE (guid->data3);
ret = TRUE;
out:
return ret;
}
static gboolean _5views_dump_close(wtap_dumper *wdh, int *err)
{
_5views_dump_t *_5views = (_5views_dump_t *)wdh->priv;
t_5VW_Capture_Header file_hdr;
if (wtap_dump_file_seek(wdh, 0, SEEK_SET, err) == -1)
return FALSE;
/* fill in the Info_Header */
file_hdr.Info_Header.Signature = GUINT32_TO_LE(CST_5VW_INFO_HEADER_KEY);
file_hdr.Info_Header.Size = GUINT32_TO_LE(sizeof(t_5VW_Info_Header)); /* Total size of Header in bytes (included Signature) */
file_hdr.Info_Header.Version = GUINT32_TO_LE(CST_5VW_INFO_RECORD_VERSION); /* Identify version and so the format of this record */
file_hdr.Info_Header.DataSize = GUINT32_TO_LE(sizeof(t_5VW_Attributes_Header)
+ sizeof(guint32)
+ sizeof(t_5VW_Attributes_Header)
+ sizeof(guint32));
/* Total size of data included in the Info Record (except the header size) */
file_hdr.Info_Header.FileType = GUINT32_TO_LE(wtap_encap[wdh->encap]); /* Type of the file */
file_hdr.Info_Header.Reserved[0] = 0; /* Reserved for future use */
file_hdr.Info_Header.Reserved[1] = 0; /* Reserved for future use */
file_hdr.Info_Header.Reserved[2] = 0; /* Reserved for future use */
/* fill in the HeaderDateCreation */
file_hdr.HeaderDateCreation.Type = GUINT32_TO_LE(CST_5VW_IA_DATE_CREATION); /* Id of the attribute */
file_hdr.HeaderDateCreation.Size = GUINT16_TO_LE(sizeof(guint32)); /* Size of the data part of the attribute (not including header size) */
file_hdr.HeaderDateCreation.Nb = GUINT16_TO_LE(1); /* Number of elements */
/* fill in the Time field */
#ifdef _WIN32
_tzset();
#endif
file_hdr.Time = GUINT32_TO_LE(time(NULL));
/* fill in the Time field */
file_hdr.HeaderNbFrames.Type = GUINT32_TO_LE(CST_5VW_IA_CAP_INF_NB_TRAMES_STOCKEES); /* Id of the attribute */
file_hdr.HeaderNbFrames.Size = GUINT16_TO_LE(sizeof(guint32)); /* Size of the data part of the attribute (not including header size) */
file_hdr.HeaderNbFrames.Nb = GUINT16_TO_LE(1); /* Number of elements */
/* fill in the number of frames saved */
file_hdr.TramesStockeesInFile = GUINT32_TO_LE(_5views->nframes);
/* Write the file header. */
if (!wtap_dump_file_write(wdh, &file_hdr, sizeof(t_5VW_Capture_Header),
err))
return FALSE;
return TRUE;
}
static gchar *
gen_context(const char *file_name,
const char *file_path)
{
struct stat st;
gsize size = 0;
MsnContextHeader header;
gchar *u8 = NULL;
guchar *base;
guchar *n;
gchar *ret;
gunichar2 *uni = NULL;
glong currentChar = 0;
glong uni_len = 0;
gsize len;
if (g_stat(file_path, &st) == 0)
size = st.st_size;
if(!file_name) {
u8 = purple_utf8_try_convert(g_basename(file_path));
file_name = u8;
}
uni = g_utf8_to_utf16(file_name, -1, NULL, &uni_len, NULL);
if(u8) {
g_free(u8);
file_name = NULL;
u8 = NULL;
}
len = sizeof(MsnContextHeader) + MAX_FILE_NAME_LEN + 4;
header.length = GUINT32_TO_LE(len);
header.unk1 = GUINT32_TO_LE(2);
header.file_size = GUINT32_TO_LE(size);
header.unk2 = GUINT32_TO_LE(0);
header.unk3 = GUINT32_TO_LE(0);
base = g_malloc(len + 1);
n = base;
memcpy(n, &header, sizeof(MsnContextHeader));
n += sizeof(MsnContextHeader);
memset(n, 0x00, MAX_FILE_NAME_LEN);
for(currentChar = 0; currentChar < uni_len; currentChar++) {
*((gunichar2 *)n + currentChar) = GUINT16_TO_LE(uni[currentChar]);
}
n += MAX_FILE_NAME_LEN;
memset(n, 0xFF, 4);
n += 4;
g_free(uni);
ret = purple_base64_encode(base, len);
g_free(base);
return ret;
}
int gfire_add_buddy_create(PurpleConnection *gc, char *name)
{
gfire_data *gfire = NULL;
int index = XFIRE_HEADER_LEN;
guint16 slen = 0;
if (!gc || !(gfire = (gfire_data *)gc->proto_data) || !name) return 0;
slen = strlen(name);
slen = GUINT16_TO_LE(slen);
gfire->buff_out[index++] = strlen("name");
memcpy(gfire->buff_out + index, "name", strlen("name"));
index += strlen("name");
gfire->buff_out[index++] = 0x01;
memcpy(gfire->buff_out + index, &slen, sizeof(slen));
index += sizeof(slen);
memcpy(gfire->buff_out + index, name, strlen(name));
index += strlen(name);
gfire->buff_out[index++] = strlen("msg");
memcpy(gfire->buff_out + index, "msg", strlen("msg"));
index += strlen("msg");
gfire->buff_out[index++] = 0x01;
gfire->buff_out[index++] = 0x00;
gfire->buff_out[index++] = 0x00;
gfire_add_header(gfire->buff_out, index, 6, 2);
return index;
}
int gfire_create_im(PurpleConnection *gc, gfire_buddy *buddy, const char *msg)
{
int length = 68+strlen(msg);
int index = 0;
gfire_data *gfire = NULL;
guint32 msgtype = 0;
guint32 imindex = 0;
guint16 slen = strlen(msg);
buddy->im++;
imindex = GUINT32_TO_LE(buddy->im);
msgtype = GUINT32_TO_LE(msgtype);
slen = GUINT16_TO_LE(slen);
gfire = (gfire_data *)gc->proto_data;
gfire_add_header(gfire->buff_out, length, 2, 2);/*add header*/
index += 5;
gfire->buff_out[index] = strlen("sid"); index++;
memcpy(gfire->buff_out + index, "sid", strlen("sid"));
index+= strlen("sid");
gfire->buff_out[index++] = 0x03;
memcpy(gfire->buff_out+index,buddy->sid, XFIRE_SID_LEN);
index += XFIRE_SID_LEN;
gfire->buff_out[index] = strlen("peermsg"); index++;
memcpy(gfire->buff_out + index, "peermsg", strlen("peermsg"));
index+= strlen("peermsg");
gfire->buff_out[index++] = 0x05;
gfire->buff_out[index++] = 0x03;
gfire->buff_out[index] = strlen("msgtype"); index++;
memcpy(gfire->buff_out + index, "msgtype", strlen("msgtype"));
index+= strlen("msgtype");
gfire->buff_out[index++] = 0x02;
memcpy(gfire->buff_out + index, &msgtype, sizeof(msgtype));
index+= sizeof(msgtype);
gfire->buff_out[index] = strlen("imindex"); index++;
memcpy(gfire->buff_out + index, "imindex", strlen("imindex"));
index+= strlen("imindex");
gfire->buff_out[index++] = 0x02;
memcpy(gfire->buff_out + index, &imindex, sizeof(imindex));
index+= sizeof(imindex);
gfire->buff_out[index] = strlen("im"); index++;
memcpy(gfire->buff_out + index, "im", strlen("im"));
index+= strlen("im");
gfire->buff_out[index++] = 0x01;
memcpy(gfire->buff_out + index, &slen, sizeof(slen));
index+= sizeof(slen);
memcpy(gfire->buff_out+index, msg, strlen(msg));
index += strlen(msg);
return index;
}
ArvUvcpPacket *
arv_uvcp_packet_new_write_memory_cmd (guint32 address, guint32 size, guint16 packet_id, size_t *packet_size)
{
ArvUvcpWriteMemoryCmd *packet;
g_return_val_if_fail (packet_size != NULL, NULL);
*packet_size = sizeof (ArvUvcpWriteMemoryCmd) + size;
packet = g_malloc (*packet_size);
packet->header.magic = GUINT32_TO_LE (ARV_UVCP_MAGIC);
packet->header.packet_type = GUINT16_TO_LE (ARV_UVCP_PACKET_TYPE_CMD);
packet->header.command = GUINT16_TO_LE (ARV_UVCP_COMMAND_WRITE_MEMORY_CMD);
packet->header.size = GUINT16_TO_LE (sizeof (ArvUvcpWriteMemoryCmdInfos) + size);
packet->header.id = GUINT16_TO_LE (packet_id);
packet->infos.address = GUINT64_TO_LE (address);
return (ArvUvcpPacket *) packet;
}
bool
SidTuneMD5::GetMD5(char *buf)
{
guint16 t;
int i;
MD5 md5;
if (!status)
return false;
md5.append(cache.get()+fileOffset, info.c64dataLen);
t = GUINT16_TO_LE (info.initAddr);
md5.append(&t, sizeof (t));
t = GUINT16_TO_LE (info.playAddr);
md5.append(&t, sizeof (t));
t = GUINT16_TO_LE (info.songs);
md5.append(&t, sizeof (t));
for (i = 1; i <= info.songs; i++) {
selectSong (i);
md5.append(&info.songSpeed, sizeof (info.songSpeed));
}
selectSong (1);
if (info.clockSpeed == SIDTUNE_CLOCK_NTSC)
md5.append(&info.clockSpeed, sizeof (info.clockSpeed));
md5.finish();
const char *d = (const char *)md5.getDigest ();
for (int i = 0; i < 16; i++) {
static const char hexchars[] = "0123456789abcdef";
buf[2*i] = hexchars[(d[i]&0xf0)>>4];
buf[2*i+1] = hexchars[d[i]&0xf];
}
buf[33] = 0;
return true;
}
void
msn_directconn_send_handshake(MsnDirectConn *directconn)
{
MsnSlpLink *slplink;
MsnSlpMessage *slpmsg;
g_return_if_fail(directconn != NULL);
slplink = directconn->slplink;
slpmsg = msn_slpmsg_new(slplink);
slpmsg->flags = 0x100;
if (directconn->nonce != NULL)
{
guint32 t1;
guint16 t2;
guint16 t3;
guint16 t4;
guint64 t5;
sscanf (directconn->nonce, "%08X-%04hX-%04hX-%04hX-%012" G_GINT64_MODIFIER "X", &t1, &t2, &t3, &t4, &t5);
t1 = GUINT32_TO_LE(t1);
t2 = GUINT16_TO_LE(t2);
t3 = GUINT16_TO_LE(t3);
t4 = GUINT16_TO_BE(t4);
t5 = GUINT64_TO_BE(t5);
slpmsg->ack_id = t1;
slpmsg->ack_sub_id = t2 | (t3 << 16);
slpmsg->ack_size = t4 | t5;
}
g_free(directconn->nonce);
msn_slplink_send_slpmsg(slplink, slpmsg);
directconn->acked =TRUE;
}
/** \ingroup print_data
* Convert a stored print into a unified representation inside a data buffer.
* You can then store this data buffer in any way that suits you, and load
* it back at some later time using fp_print_data_from_data().
* \param data the stored print
* \param ret output location for the data buffer. Must be freed with free()
* after use.
* \returns the size of the freshly allocated buffer, or 0 on error.
*/
API_EXPORTED size_t fp_print_data_get_data(struct fp_print_data *data,
unsigned char **ret)
{
struct fpi_print_data_fp2 *out_data;
struct fpi_print_data_item_fp2 *out_item;
struct fp_print_data_item *item;
size_t buflen = 0;
GSList *list_item;
unsigned char *buf;
fp_dbg("");
list_item = data->prints;
while (list_item) {
item = list_item->data;
buflen += sizeof(*out_item);
buflen += item->length;
list_item = g_slist_next(list_item);
}
buflen += sizeof(*out_data);
out_data = g_malloc(buflen);
*ret = (unsigned char *) out_data;
buf = out_data->data;
out_data->prefix[0] = 'F';
out_data->prefix[1] = 'P';
out_data->prefix[2] = '2';
out_data->driver_id = GUINT16_TO_LE(data->driver_id);
out_data->devtype = GUINT32_TO_LE(data->devtype);
out_data->data_type = data->type;
list_item = data->prints;
while (list_item) {
item = list_item->data;
out_item = (struct fpi_print_data_item_fp2 *)buf;
out_item->length = GUINT32_TO_LE(item->length);
/* FIXME: fp_print_data_item->data content is not endianess agnostic */
memcpy(out_item->data, item->data, item->length);
buf += sizeof(*out_item);
buf += item->length;
list_item = g_slist_next(list_item);
}
return buflen;
}
static int convert_stereo_to_mono_u16le(struct xmms_convert_buffers* buf, void **data, int length)
{
guint16 *output = *data, *input = *data;
int i;
for (i = 0; i < length / 4; i++)
{
guint32 tmp;
guint16 stmp;
tmp = GUINT16_FROM_LE(*input);
input++;
tmp += GUINT16_FROM_LE(*input);
input++;
stmp = tmp / 2;
*output++ = GUINT16_TO_LE(stmp);
}
return length / 2;
}
/* Demangle and decompress incoming sample data from the transfer buffer.
*/
static void read_response_rle(struct acquisition_state *acq)
{
uint32_t *in_p;
uint16_t *out_p;
unsigned int words_left, max_samples, run_samples, wi, ri;
uint32_t word;
uint16_t sample;
words_left = MIN(acq->mem_addr_next, acq->mem_addr_stop)
- acq->mem_addr_done;
in_p = &acq->xfer_buf_in[acq->in_index];
for (wi = 0;; wi++) {
/* Calculate number of samples to write into packet. */
max_samples = MIN(acq->samples_max - acq->samples_done,
PACKET_SIZE / UNIT_SIZE - acq->out_index);
run_samples = MIN(max_samples, acq->run_len);
/* Expand run-length samples into session packet. */
sample = GUINT16_TO_LE(acq->sample);
out_p = &((uint16_t *)acq->out_packet)[acq->out_index];
for (ri = 0; ri < run_samples; ri++)
out_p[ri] = sample;
acq->run_len -= run_samples;
acq->out_index += run_samples;
acq->samples_done += run_samples;
if (run_samples == max_samples)
break; /* Packet full or sample limit reached. */
if (wi >= words_left)
break; /* Done with current transfer. */
word = GUINT32_FROM_LE(in_p[wi]);
acq->sample = word >> 16;
acq->run_len = (word & 0xFFFF) + 1;
}
acq->in_index += wi;
acq->mem_addr_done += wi;
}
/**
* qmi_utils_write_guint16_to_buffer:
* @buffer: a buffer.
* @buffer_size: size of @buffer.
* @endian: endianness of firmware value; swapped from host byte order if necessary
* @in: location of the variable to be written.
*
* Writes an unsigned 16-bit integer into the buffer. The number to be written
* is expected to be given in host endianness, and this method takes care of
* converting the value written to the byte order specified by @endian.
*
* The user needs to make sure that the buffer is at least 2 bytes long.
*
* Also note that both @buffer and @buffer_size get updated after the 2 bytes
* write.
*/
void
qmi_utils_write_guint16_to_buffer (guint8 **buffer,
guint16 *buffer_size,
QmiEndian endian,
guint16 *in)
{
guint16 tmp;
g_assert (in != NULL);
g_assert (buffer != NULL);
g_assert (buffer_size != NULL);
g_assert (*buffer_size >= 2);
if (endian == QMI_ENDIAN_BIG)
tmp = GUINT16_TO_BE (*in);
else
tmp = GUINT16_TO_LE (*in);
memcpy (&(*buffer)[0], &tmp, sizeof (tmp));
*buffer = &((*buffer)[2]);
*buffer_size = (*buffer_size) - 2;
}
/*
*Sends a nickname change to the server
*/
int gfire_create_change_alias(PurpleConnection *gc, char *name)
{
gfire_data *gfire = NULL;
int index = XFIRE_HEADER_LEN;
guint16 slen = 0;
if (!gc || !(gfire = (gfire_data *)gc->proto_data)) return 0;
if (! name ) name = "";
slen = strlen(name);
slen = GUINT16_TO_LE(slen);
gfire->buff_out[index++] = strlen("nick");
memcpy(gfire->buff_out + index, "nick", strlen("nick"));
index += strlen("nick");
gfire->buff_out[index++] = 0x01;
memcpy(gfire->buff_out + index, &slen, sizeof(slen));
index += sizeof(slen);
memcpy(gfire->buff_out + index, name, strlen(name));
index += strlen(name);
gfire_add_header(gfire->buff_out, index, 14, 1);
return index;
}
static gchar *
gen_context(PurpleXfer *xfer, const char *file_name, const char *file_path)
{
goffset size = 0;
MsnFileContext context;
gchar *u8 = NULL;
gchar *ret;
gunichar2 *uni = NULL;
glong currentChar = 0;
glong len = 0;
const char *preview;
gsize preview_len;
size = purple_xfer_get_size(xfer);
purple_xfer_prepare_thumbnail(xfer, "png");
if (!file_name) {
gchar *basename = g_path_get_basename(file_path);
u8 = purple_utf8_try_convert(basename);
g_free(basename);
file_name = u8;
}
uni = g_utf8_to_utf16(file_name, -1, NULL, &len, NULL);
if (u8) {
g_free(u8);
file_name = NULL;
u8 = NULL;
}
preview = purple_xfer_get_thumbnail(xfer, &preview_len);
context.length = MSN_FILE_CONTEXT_SIZE_V2;
context.version = 2; /* V.3 contains additional unnecessary data */
context.file_size = size;
if (preview)
context.type = 0;
else
context.type = 1;
len = MIN(len, MAX_FILE_NAME_LEN);
for (currentChar = 0; currentChar < len; currentChar++) {
context.file_name[currentChar] = GUINT16_TO_LE(uni[currentChar]);
}
memset(&context.file_name[currentChar], 0x00, (MAX_FILE_NAME_LEN - currentChar) * 2);
#if 0
memset(&context.unknown1, 0, sizeof(context.unknown1));
context.unknown2 = 0xffffffff;
#endif
/* Mind the cast, as in, don't free it after! */
context.preview = (char *)preview;
context.preview_len = preview_len;
u8 = msn_file_context_to_wire(&context);
ret = purple_base64_encode((const guchar *)u8, MSN_FILE_CONTEXT_SIZE_V2 + preview_len);
g_free(uni);
g_free(u8);
return ret;
}
/**
* e2k_security_descriptor_set_permissions:
* @sd: a security descriptor
* @sid: a SID
* @perms: the MAPI permissions
*
* Updates or sets @sid's permissions on @sd.
**/
void
e2k_security_descriptor_set_permissions (E2kSecurityDescriptor *sd,
E2kSid *sid, guint32 perms)
{
E2k_ACE ace;
guint32 object_allowed, object_denied;
guint32 container_allowed, container_denied;
const guint8 *bsid;
E2kSid *sid2;
int map;
g_return_if_fail (E2K_IS_SECURITY_DESCRIPTOR (sd));
g_return_if_fail (E2K_IS_SID (sid));
bsid = e2k_sid_get_binary_sid (sid);
sid2 = g_hash_table_lookup (sd->priv->sids, bsid);
if (!sid2) {
int size = g_hash_table_size (sd->priv->sid_order);
g_hash_table_insert (sd->priv->sids, (char *)bsid, sid);
g_object_ref (sid);
g_hash_table_insert (sd->priv->sid_order, sid,
GUINT_TO_POINTER (size + 1));
} else
sid = sid2;
object_allowed = 0;
object_denied = object_permissions_all;
container_allowed = 0;
container_denied = container_permissions_all;
for (map = 0; map < permissions_map_size; map++) {
if (!(permissions_map[map].mapi_permission & perms))
continue;
object_allowed |= permissions_map[map].object_allowed;
object_denied &= ~permissions_map[map].object_not_denied;
container_allowed |= permissions_map[map].container_allowed;
container_denied &= ~permissions_map[map].container_not_denied;
}
ace.Sid = sid;
ace.Header.AceSize = GUINT16_TO_LE (sizeof (ace.Header) +
sizeof (ace.Mask) +
E2K_SID_BINARY_SID_LEN (bsid));
ace.Header.AceType = E2K_ACCESS_ALLOWED_ACE_TYPE;
ace.Header.AceFlags = E2K_OBJECT_INHERIT_ACE | E2K_INHERIT_ONLY_ACE;
ace.Mask = object_allowed;
set_ace (sd, &ace);
if (sid != sd->priv->default_sid) {
ace.Header.AceType = E2K_ACCESS_DENIED_ACE_TYPE;
ace.Header.AceFlags = E2K_OBJECT_INHERIT_ACE | E2K_INHERIT_ONLY_ACE;
ace.Mask = object_denied;
set_ace (sd, &ace);
}
ace.Header.AceType = E2K_ACCESS_ALLOWED_ACE_TYPE;
ace.Header.AceFlags = E2K_CONTAINER_INHERIT_ACE;
ace.Mask = container_allowed;
set_ace (sd, &ace);
if (sid != sd->priv->default_sid) {
ace.Header.AceType = E2K_ACCESS_DENIED_ACE_TYPE;
ace.Header.AceFlags = E2K_CONTAINER_INHERIT_ACE;
ace.Mask = container_denied;
set_ace (sd, &ace);
}
}
/**
* e2k_security_descriptor_to_binary:
* @sd: an #E2kSecurityDescriptor
*
* Converts @sd back to binary (#E2K_PR_EXCHANGE_SD_BINARY) form
* so it can be PROPPATCHed back to the server.
*
* Return value: the binary form of @sd.
**/
GByteArray *
e2k_security_descriptor_to_binary (E2kSecurityDescriptor *sd)
{
GByteArray *binsd;
E2k_SECURITY_DESCRIPTOR_RELATIVE sdbuf;
E2k_ACL aclbuf;
E2k_ACE *aces;
int off, ace, last_ace = -1, acl_size, ace_count;
const guint8 *bsid;
g_return_val_if_fail (E2K_IS_SECURITY_DESCRIPTOR (sd), NULL);
aces = (E2k_ACE *)sd->priv->aces->data;
/* Compute the length of the ACL first */
acl_size = sizeof (E2k_ACL);
for (ace = ace_count = 0; ace < sd->priv->aces->len; ace++) {
if (aces[ace].Mask) {
ace_count++;
acl_size += GUINT16_FROM_LE (aces[ace].Header.AceSize);
}
}
binsd = g_byte_array_new ();
/* Exchange-specific header */
g_byte_array_append (binsd, sd->priv->header->data,
sd->priv->header->len);
/* SECURITY_DESCRIPTOR header */
memset (&sdbuf, 0, sizeof (sdbuf));
sdbuf.Revision = E2K_SECURITY_DESCRIPTOR_REVISION;
sdbuf.Control = sd->priv->control_flags;
off = sizeof (sdbuf);
sdbuf.Dacl = GUINT32_TO_LE (off);
off += acl_size;
sdbuf.Owner = GUINT32_TO_LE (off);
bsid = e2k_sid_get_binary_sid (sd->priv->owner);
off += E2K_SID_BINARY_SID_LEN (bsid);
sdbuf.Group = GUINT32_TO_LE (off);
g_byte_array_append (binsd, (gpointer)&sdbuf, sizeof (sdbuf));
/* ACL header */
aclbuf.AclRevision = E2K_ACL_REVISION;
aclbuf.Sbz1 = 0;
aclbuf.AclSize = GUINT16_TO_LE (acl_size);
aclbuf.AceCount = GUINT16_TO_LE (ace_count);
aclbuf.Sbz2 = 0;
g_byte_array_append (binsd, (gpointer)&aclbuf, sizeof (aclbuf));
/* ACEs */
for (ace = 0; ace < sd->priv->aces->len; ace++) {
if (!aces[ace].Mask)
continue;
if (last_ace != -1) {
if (ace_compar (&aces[last_ace], &aces[ace], sd) != -1) {
g_warning ("ACE order mismatch at %d\n", ace);
g_byte_array_free (binsd, TRUE);
return NULL;
}
}
g_byte_array_append (binsd, (gpointer)&aces[ace],
sizeof (aces[ace].Header) +
sizeof (aces[ace].Mask));
bsid = e2k_sid_get_binary_sid (aces[ace].Sid);
g_byte_array_append (binsd, bsid,
E2K_SID_BINARY_SID_LEN (bsid));
last_ace = ace;
}
/* Owner and Group */
bsid = e2k_sid_get_binary_sid (sd->priv->owner);
g_byte_array_append (binsd, bsid, E2K_SID_BINARY_SID_LEN (bsid));
bsid = e2k_sid_get_binary_sid (sd->priv->group);
g_byte_array_append (binsd, bsid, E2K_SID_BINARY_SID_LEN (bsid));
return binsd;
}
int fwrite_word(FILE * f, uint16_t data)
{
data = GUINT16_TO_LE(data);
return (fwrite(&data, sizeof(uint16_t), 1, f) < 1) ? -1 : 0;
}
void
msn_write16le(char *buf, guint16 data)
{
data = GUINT16_TO_LE(data);
memcpy(buf, &data, sizeof(data));
}
static void koneplus_profile_settings_set_checksum(KoneplusProfileSettings *profile_settings) {
guint16 checksum = koneplus_profile_settings_calc_checksum(profile_settings);
profile_settings->checksum = GUINT16_TO_LE(checksum);
}
/*---------------------------------------------------
* Returns TRUE on success, FALSE on error
* Write a 16-bit value as little-endian
*---------------------------------------------------*/
static gboolean s16write(wtap_dumper *wdh, const guint16 s16, int *err)
{
guint16 s16_le = GUINT16_TO_LE(s16);
return wtap_dump_file_write(wdh, &s16_le, 2, err);
}
static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data)
{
struct drv_context *drvc;
struct dev_context *devc;
uint16_t trigger_bytes, tmp;
unsigned int i, j;
int ret;
if (sdi->status != SR_ST_ACTIVE)
return SR_ERR_DEV_CLOSED;
devc = sdi->priv;
drvc = di->priv;
devc->cb_data = cb_data;
devc->wait_data_ready_locked = TRUE;
devc->stopping_in_progress = FALSE;
devc->transfer_error = FALSE;
devc->samples_processed = 0;
devc->channel = 0;
devc->sample_packet = 0;
/*
* The trigger must be configured first because the calculation of the
* pre and post trigger samples depends on a configured trigger.
*/
sl2_configure_trigger(sdi);
sl2_calculate_trigger_samples(sdi);
trigger_bytes = devc->pre_trigger_bytes + devc->post_trigger_bytes;
/* Calculate the number of expected sample packets. */
devc->num_sample_packets = trigger_bytes / PACKET_NUM_SAMPLE_BYTES;
/* Round up the number of expected sample packets. */
if (trigger_bytes % PACKET_NUM_SAMPLE_BYTES != 0)
devc->num_sample_packets++;
devc->num_enabled_probes = 0;
/*
* Count the number of enabled probes and number them for a sequential
* access.
*/
for (i = 0, j = 0; i < NUM_PROBES; i++) {
if (devc->probes[i]->enabled) {
devc->num_enabled_probes++;
devc->probe_map[j] = i;
j++;
}
}
sr_dbg("Number of enabled probes: %i.", devc->num_enabled_probes);
/* Set up the transfer buffer for the acquisition. */
devc->xfer_data_out[0] = CMD_SAMPLE;
devc->xfer_data_out[1] = 0x00;
tmp = GUINT16_TO_LE(devc->pre_trigger_bytes);
memcpy(devc->xfer_data_out + 2, &tmp, sizeof(tmp));
tmp = GUINT16_TO_LE(devc->post_trigger_bytes);
memcpy(devc->xfer_data_out + 4, &tmp, sizeof(tmp));
devc->xfer_data_out[6] = devc->samplerate_id;
devc->xfer_data_out[7] = devc->trigger_type;
devc->xfer_data_out[8] = devc->trigger_channel;
devc->xfer_data_out[9] = 0x00;
tmp = GUINT16_TO_LE(devc->after_trigger_delay);
memcpy(devc->xfer_data_out + 10, &tmp, sizeof(tmp));
if ((ret = libusb_submit_transfer(devc->xfer_out)) != 0) {
sr_err("Submit transfer failed: %s.", libusb_error_name(ret));
return SR_ERR;
}
usb_source_add(drvc->sr_ctx, 100, ikalogic_scanalogic2_receive_data, (void *)sdi);
sr_dbg("Acquisition started successfully.");
/* Send header packet to the session bus. */
std_session_send_df_header(cb_data, LOG_PREFIX);
devc->next_state = STATE_SAMPLE;
return SR_OK;
}
static gchar *
gen_context(PurpleXfer *xfer, const char *file_name, const char *file_path)
{
gsize size = 0;
MsnFileContext *header;
gchar *u8 = NULL;
gchar *ret;
gunichar2 *uni = NULL;
glong currentChar = 0;
glong len = 0;
const char *preview;
gsize preview_len;
size = purple_xfer_get_size(xfer);
purple_xfer_prepare_thumbnail(xfer, "png");
if (!file_name) {
gchar *basename = g_path_get_basename(file_path);
u8 = purple_utf8_try_convert(basename);
g_free(basename);
file_name = u8;
}
uni = g_utf8_to_utf16(file_name, -1, NULL, &len, NULL);
if (u8) {
g_free(u8);
file_name = NULL;
u8 = NULL;
}
preview = purple_xfer_get_thumbnail(xfer, &preview_len);
header = g_malloc(sizeof(MsnFileContext) + preview_len);
header->length = GUINT32_TO_LE(sizeof(MsnFileContext) - 1);
header->version = GUINT32_TO_LE(2); /* V.3 contains additional unnecessary data */
header->file_size = GUINT64_TO_LE(size);
if (preview)
header->type = GUINT32_TO_LE(0);
else
header->type = GUINT32_TO_LE(1);
len = MIN(len, MAX_FILE_NAME_LEN);
for (currentChar = 0; currentChar < len; currentChar++) {
header->file_name[currentChar] = GUINT16_TO_LE(uni[currentChar]);
}
memset(&header->file_name[currentChar], 0x00, (MAX_FILE_NAME_LEN - currentChar) * 2);
memset(&header->unknown1, 0, sizeof(header->unknown1));
header->unknown2 = GUINT32_TO_LE(0xffffffff);
if (preview) {
memcpy(&header->preview, preview, preview_len);
}
header->preview[preview_len] = '\0';
g_free(uni);
ret = purple_base64_encode((const guchar *)header, sizeof(MsnFileContext) + preview_len);
g_free(header);
return ret;
}
static void isku_key_mask_set_checksum(IskuKeyMask *key_mask) {
guint16 checksum = isku_key_mask_calc_checksum(key_mask);
key_mask->checksum = GUINT16_TO_LE(checksum);
}
