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; }