guint64
prop_copy_uint64 (guint64 prop, guint8 ** buffer, guint64 * size,
guint64 * offset)
{
prop = GUINT64_TO_BE (prop);
return copy_func (&prop, sizeof (guint64), buffer, size, offset);
}
void falcon_object_save(trie_node_t *node, void *userdata)
{
const falcon_object_t *object = (const falcon_object_t *)trie_data(node);
int fd = GPOINTER_TO_INT(userdata);
guint16 len = strlen(object->name);
guint16 len_be = GUINT16_TO_BE(len);
guint64 size = GUINT64_TO_BE(object->size);
guint64 time = GUINT64_TO_BE(object->time);
guint32 mode = GUINT32_TO_BE(object->mode);
if (write(fd, &len_be, 2) == -1 || write(fd, object->name, len) == -1
|| write(fd, &size, 8) == -1 || write(fd, &time, 8) == -1
|| write(fd, &mode, 4) == -1 || write(fd, &(object->watch), 1) == -1)
g_critical(_("Failed to save object \"%s\": %s"), object->name,
g_strerror(errno));
}
void SHA256_Final(unsigned char out[SHA256_DIGEST_LENGTH], GChecksum *ctx)
{
// Add padding as described in RFC 3174 (it describes SHA-1 but
// the same padding style is used for SHA-256 too).
size_t pos = ctx->sha256.size & 0x3F;
ctx->buffer.u8[pos++] = 0x80;
while (pos != 64 - 8) {
if (pos == 64) {
process(ctx);
pos = 0;
}
ctx->buffer.u8[pos++] = 0x00;
}
// Convert the message size from bytes to bits.
ctx->sha256.size *= 8;
ctx->buffer.u64[(64 - 8) / 8] = GUINT64_TO_BE(ctx->sha256.size);
process(ctx);
for (size_t i = 0; i < 8; ++i)
ctx->buffer.u32[i] = GUINT_TO_BE(ctx->sha256.state[i]);
memcpy(out, ctx->buffer.u8, SHA256_DIGEST_LENGTH);
}
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;
}
GVariant *
ostree_zlib_file_header_new (GFileInfo *file_info,
GVariant *xattrs)
{
guint64 size;
guint32 uid;
guint32 gid;
guint32 mode;
guint32 rdev;
const char *symlink_target;
GVariant *ret;
ot_lvariant GVariant *tmp_xattrs = NULL;
size = g_file_info_get_size (file_info);
uid = g_file_info_get_attribute_uint32 (file_info, "unix::uid");
gid = g_file_info_get_attribute_uint32 (file_info, "unix::gid");
mode = g_file_info_get_attribute_uint32 (file_info, "unix::mode");
rdev = g_file_info_get_attribute_uint32 (file_info, "unix::rdev");
if (g_file_info_get_file_type (file_info) == G_FILE_TYPE_SYMBOLIC_LINK)
symlink_target = g_file_info_get_symlink_target (file_info);
else
symlink_target = "";
if (xattrs == NULL)
tmp_xattrs = g_variant_ref_sink (g_variant_new_array (G_VARIANT_TYPE ("(ayay)"), NULL, 0));
ret = g_variant_new ("(tuuuus@a(ayay))",
GUINT64_TO_BE (size), GUINT32_TO_BE (uid),
GUINT32_TO_BE (gid), GUINT32_TO_BE (mode), GUINT32_TO_BE (rdev),
symlink_target, xattrs ? xattrs : tmp_xattrs);
g_variant_ref_sink (ret);
return ret;
}
gboolean falcon_cache_save(const falcon_cache_t *cache, const gchar *name)
{
int fd = 0;
guint64 count = 0;
g_return_val_if_fail(cache, FALSE);
if (!name)
return FALSE;
fd = g_open(name, O_WRONLY | O_TRUNC | O_CREAT,
S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
if (fd == -1) {
g_critical(_("Failed to open cache file %s: %s"), name,
g_strerror(errno));
return FALSE;
}
g_mutex_lock(cache->lock);
count = GUINT64_TO_BE(cache->count);
if (write(fd, &count, 8) == -1) {
g_critical(_("Failed to write to file %s: %s"), name, g_strerror(errno));
g_mutex_unlock(cache->lock);
close(fd);
return FALSE;
}
trie_foreach(cache->objects, falcon_object_save, GINT_TO_POINTER(fd));
g_mutex_unlock(cache->lock);
close(fd);
return TRUE;
}
void
lx_print_uint64(RxBuffer *buf, guint64 value, GError **error)
{
g_assert(buf != NULL); g_assert(buf->array != NULL);
g_assert(error != NULL);
guint64 network_value = GUINT64_TO_BE(value);
g_byte_array_append(buf->array, (guint8*)&network_value, sizeof(network_value));
}
static void
gstring_append_double (GString *gstring,
double vdouble)
{
union { double vdouble; guint64 vuint64; } u;
u.vdouble = vdouble;
u.vuint64 = GUINT64_TO_BE (u.vuint64);
g_string_append_len (gstring, (const gchar*) &u.vuint64, 8);
}
/**
* mega_aes_key_setup_ctr:
* @aes_key: a #MegaAesKey
* @nonce: (element-type guint8) (array fixed-size=8) (transfer none): 8-byte nonce buffer
* @position: Counter value (block index)
*
* Setup CTR mode encryption/decryption.
*/
void mega_aes_key_setup_ctr(MegaAesKey* aes_key, guchar* nonce, guint64 position)
{
g_return_if_fail(MEGA_IS_AES_KEY(aes_key));
g_return_if_fail(nonce != NULL);
memcpy(aes_key->priv->ctr_nonce, nonce, 8);
aes_key->priv->ctr_position = GUINT64_TO_BE(position);
memset(aes_key->priv->ctr_ecount, 0, 16);
aes_key->priv->ctr_num = 0;
}
static gboolean k12_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
const guint8 *pd, int *err) {
const union wtap_pseudo_header *pseudo_header = &phdr->pseudo_header;
k12_dump_t *k12 = (k12_dump_t *)wdh->priv;
guint32 len;
union {
guint8 buffer[8192];
struct {
guint32 len;
guint32 type;
guint32 frame_len;
guint32 input;
guint32 datum_1;
guint32 datum_2;
guint64 ts;
guint8 frame[0x1fc0];
} record;
} obj;
/* We can only write packet records. */
if (phdr->rec_type != REC_TYPE_PACKET) {
*err = WTAP_ERR_REC_TYPE_UNSUPPORTED;
return FALSE;
}
if (k12->num_of_records == 0) {
k12_t* file_data = (k12_t*)pseudo_header->k12.stuff;
/* XXX: We'll assume that any fwrite errors in k12_dump_src_setting will */
/* repeat during the final k12_dump_record at the end of k12_dump */
/* (and thus cause an error return from k12_dump). */
/* (I don't see a reasonably clean way to handle any fwrite errors */
/* encountered in k12_dump_src_setting). */
g_hash_table_foreach(file_data->src_by_id,k12_dump_src_setting,wdh);
}
obj.record.len = 0x20 + phdr->caplen;
obj.record.len += (obj.record.len % 4) ? 4 - obj.record.len % 4 : 0;
len = obj.record.len;
obj.record.len = g_htonl(obj.record.len);
obj.record.type = g_htonl(K12_REC_PACKET);
obj.record.frame_len = g_htonl(phdr->caplen);
obj.record.input = g_htonl(pseudo_header->k12.input);
obj.record.ts = GUINT64_TO_BE((((guint64)phdr->ts.secs - 631152000) * 2000000) + (phdr->ts.nsecs / 1000 * 2));
memcpy(obj.record.frame,pd,phdr->caplen);
return k12_dump_record(wdh,len,obj.buffer, err);
}
static DBusMessage *pull_phonebook(struct pbap_data *pbap,
DBusMessage *message, guint8 type,
const char *name, uint64_t filter,
guint8 format, guint16 maxlistcount,
guint16 liststartoffset)
{
struct pullphonebook_apparam apparam;
session_callback_t func;
if (pbap->msg)
return g_dbus_create_error(message,
"org.openobex.Error.InProgress",
"Transfer in progress");
apparam.filter_tag = FILTER_TAG;
apparam.filter_len = FILTER_LEN;
apparam.filter = GUINT64_TO_BE(filter);
apparam.format_tag = FORMAT_TAG;
apparam.format_len = FORMAT_LEN;
apparam.format = format;
apparam.maxlistcount_tag = MAXLISTCOUNT_TAG;
apparam.maxlistcount_len = MAXLISTCOUNT_LEN;
apparam.maxlistcount = GUINT16_TO_BE(maxlistcount);
apparam.liststartoffset_tag = LISTSTARTOFFSET_TAG;
apparam.liststartoffset_len = LISTSTARTOFFSET_LEN;
apparam.liststartoffset = GUINT16_TO_BE(liststartoffset);
switch (type) {
case PULLPHONEBOOK:
func = pull_phonebook_callback;
break;
case GETPHONEBOOKSIZE:
func = phonebook_size_callback;
break;
default:
error("Unexpected type : 0x%2x", type);
return NULL;
}
if (obc_session_get(pbap->session, "x-bt/phonebook", name, NULL,
(guint8 *) &apparam, sizeof(apparam),
func, pbap) < 0)
return g_dbus_create_error(message,
"org.openobex.Error.Failed",
"Failed");
pbap->msg = dbus_message_ref(message);
return NULL;
}
static gboolean output_stream_write_uint64_all(GOutputStream *stream,
guint64 data,
GCancellable *cancellable,
GError **error)
{
gsize bytes_written;
gboolean res;
data = GUINT64_TO_BE(data);
res = g_output_stream_write_all(stream, &data, sizeof(data), &bytes_written,
cancellable, error);
g_assert(bytes_written == sizeof(data));
return res;
}
gint32
thrift_binary_protocol_write_i64 (ThriftProtocol *protocol, const gint64 value,
GError **error)
{
g_return_val_if_fail (THRIFT_IS_BINARY_PROTOCOL (protocol), -1);
gint64 net = GUINT64_TO_BE (value);
if (thrift_transport_write (protocol->transport,
(const gpointer) &net, 8, error))
{
return 8;
} else {
return -1;
}
}
static DBusMessage *pbap_pull_vcard(DBusConnection *connection,
DBusMessage *message, void *user_data)
{
struct pbap_data *pbap = user_data;
struct pullvcardentry_apparam apparam;
const char *name;
if (!pbap->path)
return g_dbus_create_error(message,
ERROR_INF ".Forbidden",
"Call Select first of all");
if (dbus_message_get_args(message, NULL,
DBUS_TYPE_STRING, &name,
DBUS_TYPE_INVALID) == FALSE)
return g_dbus_create_error(message,
ERROR_INF ".InvalidArguments", NULL);
if (pbap->msg)
return g_dbus_create_error(message,
"org.openobex.Error.InProgress",
"Transfer in progress");
apparam.filter_tag = FILTER_TAG;
apparam.filter_len = FILTER_LEN;
apparam.filter = GUINT64_TO_BE(pbap->filter);
apparam.format_tag = FORMAT_TAG;
apparam.format_len = FORMAT_LEN;
apparam.format = pbap->format;
if (obc_session_get(pbap->session, "x-bt/vcard", name, NULL,
(guint8 *)&apparam, sizeof(apparam),
pull_phonebook_callback, pbap) < 0)
return g_dbus_create_error(message,
"org.openobex.Error.Failed",
"Failed");
pbap->msg = dbus_message_ref(message);
return NULL;
}
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;
}
/**
* qmi_utils_write_guint64_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 64-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 8 bytes long.
*
* Also note that both @buffer and @buffer_size get updated after the 8 bytes
* write.
*/
void
qmi_utils_write_guint64_to_buffer (guint8 **buffer,
guint16 *buffer_size,
QmiEndian endian,
guint64 *in)
{
guint64 tmp;
g_assert (in != NULL);
g_assert (buffer != NULL);
g_assert (buffer_size != NULL);
g_assert (*buffer_size >= 8);
if (endian == QMI_ENDIAN_BIG)
tmp = GUINT64_TO_BE (*in);
else
tmp = GUINT64_TO_LE (*in);
memcpy (&(*buffer)[0], &tmp, sizeof (tmp));
*buffer = &((*buffer)[8]);
*buffer_size = (*buffer_size) - 8;
}
/**
* qmi_utils_write_sized_guint_to_buffer:
* @buffer: a buffer.
* @buffer_size: size of @buffer.
* @n_bytes: number of bytes to write.
* @endian: endianness of firmware value; swapped from host byte order if necessary
* @in: location of the variable to be written.
*
* Writes a @n_bytes-sized unsigned 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 @n_bytes bytes long.
*
* Also note that both @buffer and @buffer_size get updated after the @n_bytes
* bytes write.
*/
void
qmi_utils_write_sized_guint_to_buffer (guint8 **buffer,
guint16 *buffer_size,
guint n_bytes,
QmiEndian endian,
guint64 *in)
{
guint64 tmp;
g_assert (in != NULL);
g_assert (buffer != NULL);
g_assert (buffer_size != NULL);
g_assert (*buffer_size >= n_bytes);
if (endian == QMI_ENDIAN_BIG)
tmp = GUINT64_TO_BE (*in);
else
tmp = GUINT64_TO_LE (*in);
memcpy (*buffer, &tmp, n_bytes);
*buffer = &((*buffer)[n_bytes]);
*buffer_size = (*buffer_size) - n_bytes;
}
void
msn_write64be(char *buf, guint64 data)
{
data = GUINT64_TO_BE(data);
memcpy(buf, &data, sizeof(data));
}
/**
* Writes an unsigned 64-bit native endian value into the stream as a
* Big Endian value.
*
* @param value Value to write into the stream.
* @param stream A #VFSFile object representing the stream.
* @return TRUE if read was succesful, FALSE if there was an error.
*/
EXPORT bool_t vfs_fput_be64(uint64_t value, VFSFile *stream)
{
uint64_t tmp = GUINT64_TO_BE(value);
return vfs_fwrite(&tmp, sizeof(tmp), 1, stream) == 1;
}
void
msn_write64be(char *buf, guint64 data)
{
*(guint64 *)buf = GUINT64_TO_BE(data);
}
