void
eos_shard_writer_v1_write_to_fd (EosShardWriterV1 *self, int fd)
{
GVariant *variant;
/* Sort our records to allow for binary searches on retrieval. */
g_array_sort (self->entries, &compare_records);
variant = header_entry_variant (self->entries);
uint64_t header_size = g_variant_get_size (variant);
header_size = GUINT64_TO_LE (header_size);
g_variant_unref (variant);
lseek (fd, ALIGN (sizeof (header_size) + header_size), SEEK_SET);
int i;
for (i = 0; i < self->entries->len; i++) {
struct eos_shard_writer_v1_record_entry *e = &g_array_index (self->entries, struct eos_shard_writer_v1_record_entry, i);
write_blob (fd, &e->metadata);
write_blob (fd, &e->data);
}
lseek (fd, 0, SEEK_SET);
g_assert (write (fd, &header_size, sizeof (header_size)) >= 0);
variant = header_entry_variant (self->entries);
write_variant (fd, variant);
g_variant_unref (variant);
}
char *
msn_message_gen_slp_body(MsnMessage *msg, size_t *ret_size)
{
MsnSlpHeader header;
char *tmp, *base;
const void *body;
size_t len, body_len;
g_return_val_if_fail(msg != NULL, NULL);
len = MSN_BUF_LEN;
base = tmp = g_malloc(len + 1);
body = msn_message_get_bin_data(msg, &body_len);
header.session_id = GUINT32_TO_LE(msg->msnslp_header.session_id);
header.id = GUINT32_TO_LE(msg->msnslp_header.id);
header.offset = GUINT64_TO_LE(msg->msnslp_header.offset);
header.total_size = GUINT64_TO_LE(msg->msnslp_header.total_size);
header.length = GUINT32_TO_LE(msg->msnslp_header.length);
header.flags = GUINT32_TO_LE(msg->msnslp_header.flags);
header.ack_id = GUINT32_TO_LE(msg->msnslp_header.ack_id);
header.ack_sub_id = GUINT32_TO_LE(msg->msnslp_header.ack_sub_id);
header.ack_size = GUINT64_TO_LE(msg->msnslp_header.ack_size);
memcpy(tmp, &header, 48);
tmp += 48;
if (body != NULL)
{
memcpy(tmp, body, body_len);
tmp += body_len;
}
if (ret_size != NULL)
*ret_size = tmp - base;
return base;
}
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;
}
/**
* 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;
}
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;
}
void
msn_write64le(char *buf, guint64 data)
{
data = GUINT64_TO_LE(data);
memcpy(buf, &data, sizeof(data));
}
char *
msn_message_gen_payload(MsnMessage *msg, size_t *ret_size)
{
GList *l;
char *n, *base, *end;
int len;
size_t body_len = 0;
const void *body;
g_return_val_if_fail(msg != NULL, NULL);
len = MSN_BUF_LEN;
base = n = end = g_malloc(len + 1);
end += len;
/* Standard header. */
if (msg->charset == NULL)
{
g_snprintf(n, len,
"MIME-Version: 1.0\r\n"
"Content-Type: %s\r\n",
msg->content_type);
}
else
{
g_snprintf(n, len,
"MIME-Version: 1.0\r\n"
"Content-Type: %s; charset=%s\r\n",
msg->content_type, msg->charset);
}
n += strlen(n);
for (l = msg->attr_list; l != NULL; l = l->next)
{
const char *key;
const char *value;
key = l->data;
value = msn_message_get_attr(msg, key);
g_snprintf(n, end - n, "%s: %s\r\n", key, value);
n += strlen(n);
}
n += g_strlcpy(n, "\r\n", end - n);
body = msn_message_get_bin_data(msg, &body_len);
if (msg->msnslp_message)
{
MsnSlpHeader header;
MsnSlpFooter footer;
header.session_id = GUINT32_TO_LE(msg->msnslp_header.session_id);
header.id = GUINT32_TO_LE(msg->msnslp_header.id);
header.offset = GUINT64_TO_LE(msg->msnslp_header.offset);
header.total_size = GUINT64_TO_LE(msg->msnslp_header.total_size);
header.length = GUINT32_TO_LE(msg->msnslp_header.length);
header.flags = GUINT32_TO_LE(msg->msnslp_header.flags);
header.ack_id = GUINT32_TO_LE(msg->msnslp_header.ack_id);
header.ack_sub_id = GUINT32_TO_LE(msg->msnslp_header.ack_sub_id);
header.ack_size = GUINT64_TO_LE(msg->msnslp_header.ack_size);
memcpy(n, &header, 48);
n += 48;
if (body != NULL)
{
memcpy(n, body, body_len);
n += body_len;
}
footer.value = GUINT32_TO_BE(msg->msnslp_footer.value);
memcpy(n, &footer, 4);
n += 4;
}
else
{
if (body != NULL)
{
memcpy(n, body, body_len);
n += body_len;
}
}
if (ret_size != NULL)
{
*ret_size = n - base;
if (*ret_size > 1664)
*ret_size = 1664;
}
return base;
}
bool bucket_add(struct client *cli, const char *user, const char *bucket)
{
char *hdr, timestr[64];
enum errcode err = InternalError;
int rc;
struct db_bucket_ent ent;
bool setacl; /* is ok to put pre-existing bucket */
enum ReqACLC canacl;
DB *buckets = tdbrep.tdb.buckets;
DB *acls = tdbrep.tdb.acls;
DB_ENV *dbenv = tdbrep.tdb.env;
DB_TXN *txn = NULL;
DBT key, val;
if (!user)
return cli_err(cli, AccessDenied);
/* prepare parameters */
setacl = false;
if (cli->req.uri.query_len) {
switch (hreq_is_query(&cli->req)) {
case URIQ_ACL:
setacl = true;
break;
default:
err = InvalidURI;
goto err_par;
}
}
if ((rc = hreq_acl_canned(&cli->req)) == ACLCNUM) {
err = InvalidArgument;
goto err_par;
}
canacl = (rc == -1)? ACLC_PRIV: rc;
/* begin trans */
rc = dbenv->txn_begin(dbenv, NULL, &txn, 0);
if (rc) {
dbenv->err(dbenv, rc, "DB_ENV->txn_begin");
goto err_db;
}
memset(&key, 0, sizeof(key));
memset(&val, 0, sizeof(val));
memset(&ent, 0, sizeof(ent));
strncpy(ent.name, bucket, sizeof(ent.name));
strncpy(ent.owner, user, sizeof(ent.owner));
ent.time_create = GUINT64_TO_LE(time(NULL));
key.data = &ent.name;
key.size = strlen(ent.name) + 1;
val.data = &ent;
val.size = sizeof(ent);
if (setacl) {
/* check if the bucket exists, else insert it */
rc = bucket_find(txn, bucket, NULL, 0);
if (rc) {
if (rc != DB_NOTFOUND) {
buckets->err(buckets, rc, "buckets->find");
goto err_out;
}
rc = buckets->put(buckets, txn, &key, &val,
DB_NOOVERWRITE);
if (rc) {
buckets->err(buckets, rc, "buckets->put");
goto err_out;
}
} else {
if (!has_access(user, bucket, NULL, "WRITE_ACP")) {
err = AccessDenied;
goto err_out;
}
if (!object_del_acls(txn, bucket, ""))
goto err_out;
}
} else {
/* attempt to insert new bucket */
rc = buckets->put(buckets, txn, &key, &val, DB_NOOVERWRITE);
if (rc) {
if (rc == DB_KEYEXIST)
err = BucketAlreadyExists;
else
buckets->err(buckets, rc, "buckets->put");
goto err_out;
}
}
/* insert bucket ACL */
rc = add_access_canned(txn, bucket, "", user, canacl);
if (rc) {
acls->err(acls, rc, "acls->put");
goto err_out;
}
/* commit -- no more exception emulation with goto. */
rc = txn->commit(txn, 0);
if (rc) {
dbenv->err(dbenv, rc, "DB_ENV->txn_commit");
return cli_err(cli, InternalError);
}
if (asprintf(&hdr,
"HTTP/%d.%d 200 x\r\n"
"Content-Length: 0\r\n"
"Date: %s\r\n"
"Location: /%s\r\n"
"Server: " PACKAGE_STRING "\r\n"
"\r\n",
cli->req.major,
cli->req.minor,
hutil_time2str(timestr, sizeof(timestr), time(NULL)),
bucket) < 0)
return cli_err(cli, InternalError);
rc = atcp_writeq(&cli->wst, hdr, strlen(hdr), atcp_cb_free, hdr);
if (rc) {
free(hdr);
return true;
}
return atcp_write_start(&cli->wst);
err_out:
rc = txn->abort(txn);
if (rc)
dbenv->err(dbenv, rc, "DB_ENV->txn_abort");
err_db:
err_par:
return cli_err(cli, err);
}
/* Write a record for a packet to a dump file.
Returns TRUE on success, FALSE on failure. */
static gboolean netmon_dump(wtap_dumper *wdh, const struct wtap_pkthdr *phdr,
const guint8 *pd, int *err)
{
const union wtap_pseudo_header *pseudo_header = &phdr->pseudo_header;
netmon_dump_t *netmon = (netmon_dump_t *)wdh->priv;
struct netmonrec_1_x_hdr rec_1_x_hdr;
struct netmonrec_2_x_hdr rec_2_x_hdr;
void *hdrp;
size_t rec_size;
struct netmonrec_2_1_trlr rec_2_x_trlr;
size_t hdr_size;
struct netmon_atm_hdr atm_hdr;
int atm_hdrsize;
gint64 secs;
gint32 nsecs;
if (wdh->encap == WTAP_ENCAP_PER_PACKET) {
/*
* Is this network type supported?
*/
if (phdr->pkt_encap < 0 ||
(unsigned) phdr->pkt_encap >= NUM_WTAP_ENCAPS ||
wtap_encap[phdr->pkt_encap] == -1) {
/*
* No. Fail.
*/
*err = WTAP_ERR_UNSUPPORTED_ENCAP;
return FALSE;
}
/*
* Fill in the trailer with the network type.
*/
phtoles(rec_2_x_trlr.network, wtap_encap[phdr->pkt_encap]);
}
/*
* Will the file offset of this frame fit in a 32-bit unsigned
* integer?
*/
if (netmon->no_more_room) {
/*
* No, so the file is too big for NetMon format to
* handle.
*/
*err = EFBIG;
return FALSE;
}
/*
* NetMon files have a capture start time in the file header,
* and have times relative to that in the packet headers;
* pick the time of the first packet as the capture start
* time.
*
* That time has millisecond resolution, so chop any
* sub-millisecond part of the time stamp off.
*/
if (!netmon->got_first_record_time) {
netmon->first_record_time.secs = phdr->ts.secs;
netmon->first_record_time.nsecs =
(phdr->ts.nsecs/1000000)*1000000;
netmon->got_first_record_time = TRUE;
}
if (wdh->encap == WTAP_ENCAP_ATM_PDUS)
atm_hdrsize = sizeof (struct netmon_atm_hdr);
else
atm_hdrsize = 0;
secs = (gint64)(phdr->ts.secs - netmon->first_record_time.secs);
nsecs = phdr->ts.nsecs - netmon->first_record_time.nsecs;
while (nsecs < 0) {
/*
* Propagate a borrow into the seconds.
* The seconds is a time_t, and can be < 0
* (unlikely, as neither UN*X nor DOS
* nor the original Mac System existed
* before January 1, 1970, 00:00:00 UTC),
* while the nanoseconds should be positive,
* as in "nanoseconds since the instant of time
* represented by the seconds".
*
* We do not want t to be negative, as, according
* to the C90 standard, "if either operand [of /
* or %] is negative, whether the result of the
* / operator is the largest integer less than or
* equal to the algebraic quotient or the smallest
* greater than or equal to the algebraic quotient
* is implementation-defined, as is the sign of
* the result of the % operator", and we want
* the result of the division and remainder
* operations to be the same on all platforms.
*/
nsecs += 1000000000;
secs--;
}
switch (wdh->file_type_subtype) {
case WTAP_FILE_TYPE_SUBTYPE_NETMON_1_x:
rec_1_x_hdr.ts_delta = GUINT32_TO_LE(secs*1000 + (nsecs + 500000)/1000000);
rec_1_x_hdr.orig_len = GUINT16_TO_LE(phdr->len + atm_hdrsize);
rec_1_x_hdr.incl_len = GUINT16_TO_LE(phdr->caplen + atm_hdrsize);
hdrp = &rec_1_x_hdr;
hdr_size = sizeof rec_1_x_hdr;
break;
case WTAP_FILE_TYPE_SUBTYPE_NETMON_2_x:
rec_2_x_hdr.ts_delta = GUINT64_TO_LE(secs*1000000 + (nsecs + 500)/1000);
rec_2_x_hdr.orig_len = GUINT32_TO_LE(phdr->len + atm_hdrsize);
rec_2_x_hdr.incl_len = GUINT32_TO_LE(phdr->caplen + atm_hdrsize);
hdrp = &rec_2_x_hdr;
hdr_size = sizeof rec_2_x_hdr;
break;
default:
/* We should never get here - our open routine
should only get called for the types above. */
*err = WTAP_ERR_UNSUPPORTED_FILE_TYPE;
return FALSE;
}
/*
* Keep track of the record size, as we need to update
* the current file offset.
*/
rec_size = 0;
if (!wtap_dump_file_write(wdh, hdrp, hdr_size, err))
return FALSE;
rec_size += hdr_size;
if (wdh->encap == WTAP_ENCAP_ATM_PDUS) {
/*
* Write the ATM header.
* We supply all-zero destination and source addresses.
*/
memset(&atm_hdr.dest, 0, sizeof atm_hdr.dest);
memset(&atm_hdr.src, 0, sizeof atm_hdr.src);
atm_hdr.vpi = g_htons(pseudo_header->atm.vpi);
atm_hdr.vci = g_htons(pseudo_header->atm.vci);
if (!wtap_dump_file_write(wdh, &atm_hdr, sizeof atm_hdr, err))
return FALSE;
rec_size += sizeof atm_hdr;
}
if (!wtap_dump_file_write(wdh, pd, phdr->caplen, err))
return FALSE;
rec_size += phdr->caplen;
if (wdh->encap == WTAP_ENCAP_PER_PACKET) {
/*
* Write out the trailer.
*/
if (!wtap_dump_file_write(wdh, &rec_2_x_trlr,
sizeof rec_2_x_trlr, err))
return FALSE;
rec_size += sizeof rec_2_x_trlr;
}
/*
* Stash the file offset of this frame.
*/
if (netmon->frame_table_size == 0) {
/*
* Haven't yet allocated the buffer for the frame table.
*/
netmon->frame_table = (guint32 *)g_malloc(1024 * sizeof *netmon->frame_table);
netmon->frame_table_size = 1024;
} else {
/*
* We've allocated it; are we at the end?
*/
if (netmon->frame_table_index >= netmon->frame_table_size) {
/*
* Yes - double the size of the frame table.
*/
netmon->frame_table_size *= 2;
netmon->frame_table = (guint32 *)g_realloc(netmon->frame_table,
netmon->frame_table_size * sizeof *netmon->frame_table);
}
}
netmon->frame_table[netmon->frame_table_index] =
GUINT32_TO_LE(netmon->frame_table_offset);
/*
* Is this the last record we can write?
* I.e., will the frame table offset of the next record not fit
* in a 32-bit frame table offset entry?
*
* (We don't bother checking whether the number of frames
* will fit in a 32-bit value, as, even if each record were
* 1 byte, if there were more than 2^32-1 packets, the frame
* table offset of at least one of those packets will be >
* 2^32 - 1.)
*
* Note: this also catches the unlikely possibility that
* the record itself is > 2^32 - 1 bytes long.
*/
if ((guint64)netmon->frame_table_offset + rec_size > G_MAXUINT32) {
/*
* Yup, too big.
*/
netmon->no_more_room = TRUE;
}
netmon->frame_table_index++;
netmon->frame_table_offset += (guint32) rec_size;
return TRUE;
}
void
msn_write64le(char *buf, guint64 data)
{
*(guint64 *)buf = GUINT64_TO_LE(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_le64(uint64_t value, VFSFile *stream)
{
uint64_t tmp = GUINT64_TO_LE(value);
return vfs_fwrite(&tmp, sizeof(tmp), 1, stream) == 1;
}
void wu64(uint64_t val, char **ptr)
{
*(uint64_t *)(*ptr) = GUINT64_TO_LE(val);
*ptr += 8;
}
