static void print_obj(struct db_obj_ent *obj) { uint32_t n_str = GUINT32_FROM_LE(obj->n_str); int i; void *p; uint16_t *slenp; char *dbstr; if (GUINT32_FROM_LE(obj->flags) & DB_OBJ_INLINE) { printf("%s\t%s\t%s\t[%u]\t%u\n", obj->bucket, obj->owner, obj->md5, (unsigned) GUINT64_FROM_LE(obj->size), n_str); } else { printf("%s\t%s\t%s\t%llX", obj->bucket, obj->owner, obj->md5, (long long) GUINT64_FROM_LE(obj->d.a.oid)); for (i = 0; i < MAXWAY; i++) { if (i == 0) { printf("\t"); } else { printf(","); } printf("%d", GUINT32_FROM_LE(obj->d.a.nidv[i])); } printf(" %u\n", n_str); } p = obj; p += sizeof(*obj); slenp = p; p += n_str * sizeof(uint16_t); for (i = 0; i < n_str; i++) { char pfx[16]; dbstr = p; p += GUINT16_FROM_LE(*slenp); slenp++; if (i == 0) strcpy(pfx, "key: "); else sprintf(pfx, "str%d: ", i); printf("%s%s\n", pfx, dbstr); } printf("====\n"); }
guint64 msn_read64le(const char *buf) { guint64 val; memcpy(&val, buf, sizeof(val)); return GUINT64_FROM_LE(val); }
double mdb_get_double(unsigned char *buf, int offset) { union {guint64 g; double d;} d; memcpy(&d, &buf[offset], 8); d.g = GUINT64_FROM_LE(d.g); return d.d; }
static guint64 get_longlong (gchar **p) { guint64 v = * (guint64 *) *p; *p += 8; return GUINT64_FROM_LE (v); }
void tiger_final(tiger_ctx_t *ctx, char result[24]) { unsigned index = (unsigned)ctx->length & 63; guint64 *msg64 = (guint64 *)ctx->message; /* pad message and run for last block */ /* append the byte 0x01 to the message */ ctx->message[index++] = 0x01; /* if no room left in the message to store 64-bit message length */ if(index > 56) { /* then fill the rest with zeros and process it */ while(index < 64) ctx->message[index++] = 0; tiger_process_block(ctx->hash, msg64); index = 0; } while(index < 56) ctx->message[index++] = 0; msg64[7] = GUINT64_FROM_LE(ctx->length << 3); tiger_process_block(ctx->hash, msg64); /* save result hash */ guint64 *res = (guint64 *)result; res[0] = GINT64_TO_LE(ctx->hash[0]); res[1] = GINT64_TO_LE(ctx->hash[1]); res[2] = GINT64_TO_LE(ctx->hash[2]); }
double mdb_get_double(void *buf, int offset) { union {guint64 g; double d;} d; memcpy(&d, buf + offset, 8); d.g = GUINT64_FROM_LE(d.g); return d.d; }
/** * Reads an unsigned 64-bit Little Endian value from the stream into native endian format. * * @param value Pointer to the variable to read the value into. * @param stream A #VFSFile object representing the stream. * @return TRUE if read was succesful, FALSE if there was an error. */ EXPORT bool_t vfs_fget_le64(uint64_t *value, VFSFile *stream) { uint64_t tmp; if (vfs_fread(&tmp, sizeof(tmp), 1, stream) != 1) return FALSE; *value = GUINT64_FROM_LE(tmp); return TRUE; }
/** * g_bytes_vector_read_uint64: * @vector: (in): A #GBytesVector. * @value: (out): A location for a #guint64. * * Reads a #guint64 from the vector of buffers in @vector. If successful * then @value is set and %TRUE is returned. * * Returns: %TRUE if successful; otherwise %FALSE. */ gboolean g_bytes_vector_read_uint64 (GBytesVector *vector, guint64 *value) { gboolean ret; if ((ret = g_bytes_vector_read(vector, (guint8 *)value, sizeof *value))) { *value = GUINT64_FROM_LE(*value); } return ret; }
void msn_message_parse_slp_body(MsnMessage *msg, const char *body, size_t len) { MsnSlpHeader header; const char *tmp; int body_len; tmp = body; if (len < sizeof(header)) { g_return_if_reached(); } /* Import the header. */ memcpy(&header, tmp, sizeof(header)); tmp += sizeof(header); msg->msnslp_header.session_id = GUINT32_FROM_LE(header.session_id); msg->msnslp_header.id = GUINT32_FROM_LE(header.id); msg->msnslp_header.offset = GUINT64_FROM_LE(header.offset); msg->msnslp_header.total_size = GUINT64_FROM_LE(header.total_size); msg->msnslp_header.length = GUINT32_FROM_LE(header.length); msg->msnslp_header.flags = GUINT32_FROM_LE(header.flags); msg->msnslp_header.ack_id = GUINT32_FROM_LE(header.ack_id); msg->msnslp_header.ack_sub_id = GUINT32_FROM_LE(header.ack_sub_id); msg->msnslp_header.ack_size = GUINT64_FROM_LE(header.ack_size); /* Import the body. */ body_len = len - (tmp - body); /* msg->body_len = msg->msnslp_header.length; */ if (body_len > 0) { msg->body_len = len - (tmp - body); msg->body = g_malloc0(msg->body_len + 1); memcpy(msg->body, tmp, msg->body_len); tmp += body_len; } }
static BlueSkyCleanerItem *bluesky_cleaner_deserialize(BlueSkyRCStr *raw) { const char *data = raw->data; size_t len = raw->len; const char *data1, *data2, *data3; size_t len1, len2, len3; g_assert(len > 4); if (len < sizeof(struct cloudlog_header) || memcmp(data, CLOUDLOG_MAGIC, 4) != 0) { g_warning("Deserializing garbage cloud log item from cleaner!"); return NULL; }; struct cloudlog_header *header = (struct cloudlog_header *)data; len1 = GUINT32_FROM_LE(header->size1); len2 = GUINT32_FROM_LE(header->size2); len3 = GUINT32_FROM_LE(header->size3); data1 = data + sizeof(struct cloudlog_header); data2 = data1 + len1; data3 = data2 + len2; g_assert(data3 + len3 - data <= len); BlueSkyCleanerItem *item = g_new0(BlueSkyCleanerItem, 1); item->type = header->type - '0'; item->inum = GUINT64_FROM_LE(header->inum); memcpy(&item->id, &header->id, sizeof(BlueSkyCloudID)); int link_count = len2 / sizeof(BlueSkyCloudID); g_print("Outgoing links: %d\n", link_count); item->links = g_array_new(FALSE, TRUE, sizeof(BlueSkyCleanerLink)); for (int i = 0; i < link_count; i++) { BlueSkyCleanerLink link; g_assert(len2 >= sizeof(link.id)); memcpy(&link.id, data2, sizeof(link.id)); data2 += sizeof(link.id); len2 -= sizeof(link.id); g_assert(len3 >= sizeof(link.location)); memcpy(&link.location, data3, sizeof(link.location)); data3 += sizeof(link.location); len3 -= sizeof(link.location); g_array_append_val(item->links, link); } return item; }
static void tiger_process_block(guint64 state[3], guint64 *block) { /* Optimized for GCC IA32. The order of declarations is important for compiler. */ guint64 a, b, c; guint64 x0, x1, x2, x3, x4, x5, x6, x7; #ifndef CPU_X64 guint64 tmp; char i; #endif x0=GUINT64_FROM_LE(block[0]); x1=GUINT64_FROM_LE(block[1]); x2=GUINT64_FROM_LE(block[2]); x3=GUINT64_FROM_LE(block[3]); x4=GUINT64_FROM_LE(block[4]); x5=GUINT64_FROM_LE(block[5]); x6=GUINT64_FROM_LE(block[6]); x7=GUINT64_FROM_LE(block[7]); a = state[0]; b = state[1]; c = state[2]; /* passes and key shedules */ #ifndef CPU_X64 for(i=0; i<3; i++) { if(i != 0) key_schedule; pass(a, b, c, (i==0 ? 5 : i==1 ? 7 : 9)); tmp=a; a=c; c=b; b=tmp; } #else pass(a, b, c, 5); key_schedule; pass(c, a, b, 7); key_schedule; pass(b, c, a, 9); #endif /* feedforward operation */ state[0] = a ^ state[0]; state[1] = b - state[1]; state[2] = c + state[2]; }
static gboolean read_word (EvaDebugLog *log, guint64 *out) { if (log->is_64bit) { guint64 val; if (fread (&val, 8, 1, log->fp) != 1) return FALSE; *out = log->little_endian ? GUINT64_FROM_LE (val) : GUINT64_FROM_BE (val); } else { guint32 val; if (fread (&val, 4, 1, log->fp) != 1) return FALSE; *out = log->little_endian ? GUINT32_FROM_LE (val) : GUINT32_FROM_BE (val); } return TRUE; }
static void do_bucket_list(void) { int rc; DBC *cur = NULL; DBT key, val; unsigned long count = 0; struct db_bucket_ent *ent; memset(&key, 0, sizeof(key)); memset(&val, 0, sizeof(val)); val.flags = DB_DBT_MALLOC; rc = tdb.buckets->cursor(tdb.buckets, NULL, &cur, 0); if (rc) { tdb.buckets->err(tdb.buckets, rc, "cursor create"); exit(1); } printf("name\towner\ttime_created\n"); while (1) { rc = cur->get(cur, &key, &val, DB_NEXT); if (rc) break; ent = val.data; printf("%s\t%s\t%llu\n", ent->name, ent->owner, (unsigned long long) GUINT64_FROM_LE(ent->time_create)); count++; free(ent); } fprintf(stderr, "%lu records\n", count); cur->close(cur); }
static void do_obj_cnt(void) { DBC *cur = NULL; DBT key, val; uint64_t cntbuf; /* LE */ uint64_t objcount; /* Host order */ int rc; rc = tdb.oids->cursor(tdb.oids, NULL, &cur, 0); if (rc) { tdb.oids->err(tdb.oids, rc, "cursor create"); exit(1); } memset(&key, 0, sizeof(key)); memset(&val, 0, sizeof(val)); val.flags = DB_DBT_USERMEM; val.data = &cntbuf; val.ulen = sizeof(uint64_t); /* read existing counter, if any */ rc = cur->get(cur, &key, &val, DB_NEXT); if (rc == DB_NOTFOUND) { printf("-\n"); } else if (rc) { printf("\n"); fprintf(stderr, "objid get error %d\n", rc); exit(1); } else { if (val.size != sizeof(uint64_t)) { printf("\n"); fprintf(stderr, "objid_init got size %d\n", val.size); exit(1); } objcount = GUINT64_FROM_LE(*(uint64_t *)val.data); printf("%llu\n", (unsigned long long) objcount); } cur->close(cur); }
/** * qmi_utils_read_guint64_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 an unsigned 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_guint64_from_buffer (const guint8 **buffer, guint16 *buffer_size, QmiEndian endian, guint64 *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 = GUINT64_FROM_BE (*out); else *out = GUINT64_FROM_LE (*out); print_read_bytes_trace ("guint64", &(*buffer)[0], out, 8); *buffer = &((*buffer)[8]); *buffer_size = (*buffer_size) - 8; }
static void *read_tiff_tag_8(FILE *f, int64_t count, int64_t offset, uint16_t endian) { uint64_t *result = g_try_new(uint64_t, count); if (result == NULL) { goto FAIL; } if (!read_tiff_tag(f, count * sizeof *result, result, offset, NULL)) { goto FAIL; } // swap? for (int64_t i = 0; i < count; i++) { if (endian == TIFF_BIGENDIAN) { result[i] = GUINT64_FROM_BE(result[i]); } else { result[i] = GUINT64_FROM_LE(result[i]); } } /* g_debug(" count %" PRId64, count); for (int i = 0; i < count; i++) { if (i > 50) { g_debug(" ..."); break; } g_debug(" %" PRIu64, result[i]); } g_debug(" "); */ return result; FAIL: g_free(result); return NULL; }
/** * qmi_utils_read_sized_guint_from_buffer: * @buffer: a buffer with raw binary data. * @buffer_size: size of @buffer. * @n_bytes: number of bytes to read. * @endian: endianness of firmware value; swapped to host byte order if necessary * @out: return location for the read variable. * * Reads a @n_bytes-sized unsigned 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 @n_bytes bytes are available * in the buffer. * * Also note that both @buffer and @buffer_size get updated after the @n_bytes * bytes read. */ void qmi_utils_read_sized_guint_from_buffer (const guint8 **buffer, guint16 *buffer_size, guint n_bytes, QmiEndian endian, guint64 *out) { g_assert (out != NULL); g_assert (buffer != NULL); g_assert (buffer_size != NULL); g_assert (*buffer_size >= n_bytes); *out = 0; memcpy (out, *buffer, n_bytes); if (endian == QMI_ENDIAN_BIG) *out = GUINT64_FROM_BE (*out); else *out = GUINT64_FROM_LE (*out); *buffer = &((*buffer)[n_bytes]); *buffer_size = (*buffer_size) - n_bytes; }
static inline gint rspamd_archive_rar_read_vint (const guchar *start, gsize remain, guint64 *res) { /* * From http://www.rarlab.com/technote.htm: * Variable length integer. Can include one or more bytes, where * lower 7 bits of every byte contain integer data and highest bit * in every byte is the continuation flag. * If highest bit is 0, this is the last byte in sequence. * So first byte contains 7 least significant bits of integer and * continuation flag. Second byte, if present, contains next 7 bits and so on. */ guint64 t = 0; guint shift = 0; const guchar *p = start; while (remain > 0 && shift <= 57) { if (*p & 0x80) { t |= ((guint64)(*p & 0x7f)) << shift; } else { t |= ((guint64)(*p & 0x7f)) << shift; p ++; break; } shift += 7; p++; remain --; } if (remain == 0 || shift > 64) { return -1; } *res = GUINT64_FROM_LE (t); return p - start; }
void msn_message_parse_payload(MsnMessage *msg, const char *payload, size_t payload_len) { char *tmp_base, *tmp; const char *content_type; char *end; char **elems, **cur, **tokens; g_return_if_fail(payload != NULL); tmp_base = tmp = g_malloc0(payload_len + 1); memcpy(tmp_base, payload, payload_len); /* Parse the attributes. */ end = strstr(tmp, "\r\n\r\n"); /* TODO? some clients use \r delimiters instead of \r\n, the official client * doesn't send such messages, but does handle receiving them. We'll just * avoid crashing for now */ if (end == NULL) { g_free(tmp_base); g_return_if_reached(); } *end = '\0'; elems = g_strsplit(tmp, "\r\n", 0); for (cur = elems; *cur != NULL; cur++) { const char *key, *value; tokens = g_strsplit(*cur, ": ", 2); key = tokens[0]; value = tokens[1]; if (!strcmp(key, "MIME-Version")) { g_strfreev(tokens); continue; } if (!strcmp(key, "Content-Type")) { char *charset, *c; if ((c = strchr(value, ';')) != NULL) { if ((charset = strchr(c, '=')) != NULL) { charset++; msn_message_set_charset(msg, charset); } *c = '\0'; } msn_message_set_content_type(msg, value); } else { msn_message_set_attr(msg, key, value); } g_strfreev(tokens); } g_strfreev(elems); /* Proceed to the end of the "\r\n\r\n" */ tmp = end + 4; /* Now we *should* be at the body. */ content_type = msn_message_get_content_type(msg); if (content_type != NULL && !strcmp(content_type, "application/x-msnmsgrp2p")) { MsnSlpHeader header; MsnSlpFooter footer; int body_len; if (payload_len - (tmp - tmp_base) < sizeof(header)) { g_free(tmp_base); g_return_if_reached(); } msg->msnslp_message = TRUE; /* Import the header. */ memcpy(&header, tmp, sizeof(header)); tmp += sizeof(header); msg->msnslp_header.session_id = GUINT32_FROM_LE(header.session_id); msg->msnslp_header.id = GUINT32_FROM_LE(header.id); msg->msnslp_header.offset = GUINT64_FROM_LE(header.offset); msg->msnslp_header.total_size = GUINT64_FROM_LE(header.total_size); msg->msnslp_header.length = GUINT32_FROM_LE(header.length); msg->msnslp_header.flags = GUINT32_FROM_LE(header.flags); msg->msnslp_header.ack_id = GUINT32_FROM_LE(header.ack_id); msg->msnslp_header.ack_sub_id = GUINT32_FROM_LE(header.ack_sub_id); msg->msnslp_header.ack_size = GUINT64_FROM_LE(header.ack_size); body_len = payload_len - (tmp - tmp_base) - sizeof(footer); /* Import the body. */ if (body_len > 0) { msg->body_len = body_len; msg->body = g_malloc0(msg->body_len + 1); memcpy(msg->body, tmp, msg->body_len); tmp += body_len; } /* Import the footer. */ if (body_len >= 0) { memcpy(&footer, tmp, sizeof(footer)); tmp += sizeof(footer); msg->msnslp_footer.value = GUINT32_FROM_BE(footer.value); } } else { if (payload_len - (tmp - tmp_base) > 0) { msg->body_len = payload_len - (tmp - tmp_base); msg->body = g_malloc0(msg->body_len + 1); memcpy(msg->body, tmp, msg->body_len); } } g_free(tmp_base); }
/* reads the next packet */ static gboolean observer_read(wtap *wth, int *err, gchar **err_info, gint64 *data_offset) { int offset; packet_entry_header packet_header; /* * Skip records other than data records. */ for (;;) { *data_offset = wth->data_offset; /* process the packet header, including TLVs */ offset = read_packet_header(wth->fh, &packet_header, err, err_info); if (offset <= 0) return FALSE; /* EOF or error */ wth->data_offset += offset; if (packet_header.packet_type == PACKET_TYPE_DATA_PACKET) break; /* skip to next packet */ packet_header.offset_to_next_packet = GUINT16_FROM_LE(packet_header.offset_to_next_packet); if (!skip_to_next_packet(wth, offset, packet_header.offset_to_next_packet, err, err_info)) return FALSE; /* EOF or error */ } /* set-up the packet header */ packet_header.network_size = GUINT16_FROM_LE(packet_header.network_size); /* neglect frame markers for wiretap */ if (packet_header.network_size < 4) { *err = WTAP_ERR_BAD_RECORD; *err_info = g_strdup_printf("Observer: bad record: Packet length %u < 4", packet_header.network_size); return FALSE; } packet_header.network_size -= 4; packet_header.captured_size = GUINT16_FROM_LE(packet_header.captured_size); wth->phdr.pkt_encap = observer_encap[packet_header.network_type]; wth->phdr.len = packet_header.network_size; wth->phdr.caplen = MIN(packet_header.captured_size, wth->phdr.len); packet_header.nano_seconds_since_2000 = GUINT64_FROM_LE(packet_header.nano_seconds_since_2000); wth->phdr.ts.secs = (time_t) (packet_header.nano_seconds_since_2000/1000000000 + seconds1970to2000); wth->phdr.ts.nsecs = (int) (packet_header.nano_seconds_since_2000%1000000000); /* set-up the packet buffer */ buffer_assure_space(wth->frame_buffer, packet_header.captured_size); /* read data */ if (!read_packet_data(wth->fh, packet_header.offset_to_frame, offset, buffer_start_ptr(wth->frame_buffer), packet_header.captured_size, err, err_info)) return FALSE; wth->data_offset += packet_header.captured_size; offset += packet_header.captured_size; /* update the pseudo header */ switch (wth->file_encap) { case WTAP_ENCAP_ETHERNET: /* There is no FCS in the frame */ wth->pseudo_header.eth.fcs_len = 0; break; } return TRUE; }
static bool bucket_list_keys(struct client *cli, const char *user, const char *bucket) { GHashTable *param; enum errcode err = InternalError; char *prefix, *marker, *maxkeys_str, *delim, *s; int maxkeys = 100, i, rc; GList *content, *tmpl; size_t pfx_len; struct bucket_list_info bli; bool rcb; DB_ENV *dbenv = tdbrep.tdb.env; DB_TXN *txn = NULL; DB *objs = tdbrep.tdb.objs; DBC *cur = NULL; DBT pkey, pval; struct db_obj_key *obj_key; size_t alloc_len; bool seen_prefix = false; int get_flags; /* verify READ access */ if (!user || !has_access(user, bucket, NULL, "READ")) { err = AccessDenied; goto err_out; } /* parse URI query string */ param = hreq_query(&cli->req); if (!param) goto err_out; /* read useful params from query string */ prefix = g_hash_table_lookup(param, "prefix"); pfx_len = prefix ? strlen(prefix) : 0; marker = g_hash_table_lookup(param, "marker"); delim = g_hash_table_lookup(param, "delimiter"); maxkeys_str = g_hash_table_lookup(param, "max-keys"); if (maxkeys_str) { i = atoi(maxkeys_str); if (i > 0 && i < maxkeys) maxkeys = i; } /* open transaction */ rc = dbenv->txn_begin(dbenv, NULL, &txn, 0); if (rc) { dbenv->err(dbenv, rc, "DB_ENV->txn_begin"); goto err_out; } /* search for (bucket, *) in object database, to see if * any objects associated with this bucket exist */ rc = objs->cursor(objs, txn, &cur, 0); if (rc) { objs->err(objs, rc, "objs->cursor"); goto err_out; } alloc_len = sizeof(*obj_key) + (marker ? strlen(marker) : pfx_len) + 1; obj_key = alloca(alloc_len); memset(obj_key, 0, alloc_len); strncpy(obj_key->bucket, bucket, sizeof(obj_key->bucket)); strcpy(obj_key->key, marker ? marker : prefix ? prefix : ""); memset(&pkey, 0, sizeof(pkey)); pkey.data = obj_key; pkey.size = alloc_len; memset(&bli, 0, sizeof(bli)); bli.prefix = prefix; bli.pfx_len = pfx_len; bli.delim = delim; bli.common_pfx = g_hash_table_new_full(g_str_hash, g_str_equal, free, NULL); bli.maxkeys = maxkeys; /* iterate through each returned data row */ get_flags = DB_SET_RANGE; while (1) { struct obj_vitals v; struct db_obj_key *tmpkey; struct db_obj_ent *obj; memset(&pval, 0, sizeof(pval)); pval.flags = DB_DBT_MALLOC; rc = cur->get(cur, &pkey, &pval, get_flags); if (rc) { if (rc != DB_NOTFOUND) objs->err(objs, rc, "bucket_list_keys iter"); break; } get_flags = DB_NEXT; tmpkey = pkey.data; obj = pval.data; if (strcmp(tmpkey->bucket, bucket)) { free(obj); break; } if (prefix) { if (strncmp(tmpkey->key, prefix, pfx_len) != 0) { free(obj); if (!seen_prefix) /* continue searching for * a record that begins with this * prefix */ continue; else /* no more records with our prefix */ break; } seen_prefix = true; } memset(&v, 0, sizeof(v)); strcpy(v.md5, obj->md5); strncpy(v.owner, obj->owner, sizeof(v.owner)-1); if (!(GUINT32_FROM_LE(obj->flags) & DB_OBJ_INLINE)) memcpy(&v.addr, &obj->d.a, sizeof(v.addr)); v.mtime = GUINT64_FROM_LE(obj->mtime); v.size = GUINT64_FROM_LE(obj->size); free(obj); if (bucket_list_iter(tmpkey->key, &v, &bli)) break; } /* close cursor, transaction */ rc = cur->close(cur); if (rc) { objs->err(objs, rc, "objs->cursor close"); goto err_out_rb; } rc = txn->commit(txn, 0); if (rc) { dbenv->err(dbenv, rc, "DB_ENV->txn_commit"); goto err_out_param; } s = g_markup_printf_escaped( "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n" "<ListBucketResult xmlns=\"http://indy.yyz.us/doc/2006-03-01/\">\r\n" " <Name>%s</Name>\r\n" " <MaxKeys>%d</MaxKeys>\r\n" " <IsTruncated>%s</IsTruncated>\r\n", bucket, maxkeys, bli.trunc ? "true" : "false"); content = g_list_append(NULL, s); if (prefix) { s = g_markup_printf_escaped(" <Prefix>%s</Prefix>\n", prefix); content = g_list_append(content, s); } if (marker) { s = g_markup_printf_escaped(" <Marker>%s</Marker>\n", marker); content = g_list_append(content, s); } tmpl = bli.res; while (tmpl) { char timestr[64]; struct obj_vitals *vp; vp = tmpl->data; tmpl = tmpl->next; /* * FIXME Use the vp->addr to verify that key still exists. * And if it doesn't, then what? (addr.nid can be 0 for inline) */ s = g_markup_printf_escaped( " <Contents>\r\n" " <Key>%s</Key>\r\n" " <LastModified>%s</LastModified>\r\n" " <ETag>%s</ETag>\r\n" " <Size>%llu</Size>\r\n" " <StorageClass>STANDARD</StorageClass>\r\n" " <Owner>\r\n" " <ID>%s</ID>\r\n" " <DisplayName>%s</DisplayName>\r\n" " </Owner>\r\n" " </Contents>\r\n", vp->key, hutil_time2str(timestr, sizeof(timestr), vp->mtime / 1000000), vp->md5, (unsigned long long) vp->size, vp->owner, vp->owner); content = g_list_append(content, s); free(vp->key); free(vp); } g_list_free(bli.res); content = bucket_list_pfx(content, bli.common_pfx, bli.delim); s = strdup("</ListBucketResult>\r\n"); content = g_list_append(content, s); free(bli.last_comp); g_hash_table_destroy(bli.common_pfx); g_hash_table_destroy(param); rcb = cli_resp_xml(cli, 200, content); g_list_free(content); return rcb; err_out_rb: rc = txn->abort(txn); if (rc) dbenv->err(dbenv, rc, "DB_ENV->txn_abort"); err_out_param: g_hash_table_destroy(param); err_out: return cli_err(cli, err); }
bool service_list(struct client *cli, const char *user) { GList *files = NULL, *content = NULL; char *s; enum errcode err = InternalError; int rc; bool rcb; DB_TXN *txn = NULL; DBC *cur = NULL; DB_ENV *dbenv = tdbrep.tdb.env; DB *bidx = tdbrep.tdb.buckets_idx; DBT skey, pkey, pval; if (asprintf(&s, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n" "<ListAllMyBucketsResult xmlns=\"http://indy.yyz.us/doc/2006-03-01/\">\r\n" " <Owner>\r\n" " <ID>%s</ID>\r\n" " <DisplayName>%s</DisplayName>\r\n" " </Owner>\r\n" " <Buckets>\r\n", user, user) < 0) goto err_out; content = g_list_append(content, s); /* open transaction, search cursor */ rc = dbenv->txn_begin(dbenv, NULL, &txn, 0); if (rc) { dbenv->err(dbenv, rc, "DB_ENV->txn_begin"); goto err_out_content; } rc = bidx->cursor(bidx, txn, &cur, 0); if (rc) { bidx->err(bidx, rc, "bidx->cursor"); goto err_out_content; } memset(&skey, 0, sizeof(skey)); memset(&pkey, 0, sizeof(pkey)); memset(&pval, 0, sizeof(pval)); skey.data = (char *) user; skey.size = strlen(user) + 1; /* FIXME: Use of DB_NEXT rather than DB_SET to begin search * means we iterate through entire db, rather than * starting at the first matching key. */ /* loop through matching buckets, if any */ while (1) { char timestr[64]; struct db_bucket_ent *ent; rc = cur->pget(cur, &skey, &pkey, &pval, DB_NEXT); if (rc) break; ent = pval.data; s = g_markup_printf_escaped( " <Bucket>\r\n" " <Name>%s</Name>\r\n" " <CreationDate>%s</CreationDate>\r\n" " </Bucket>\r\n", ent->name, hutil_time2str(timestr, sizeof(timestr), GUINT64_FROM_LE(ent->time_create))); if (!s) goto err_out_content; content = g_list_append(content, s); } if (rc != DB_NOTFOUND) bidx->err(bidx, rc, "service_list iter"); /* close cursor, transaction */ rc = cur->close(cur); if (rc) bidx->err(bidx, rc, "bidx->cursor close"); rc = txn->commit(txn, 0); if (rc) dbenv->err(dbenv, rc, "DB_ENV->txn_commit"); if (asprintf(&s, " </Buckets>\r\n" "</ListAllMyBucketsResult>\r\n") < 0) goto err_out_content; content = g_list_append(content, s); rcb = cli_resp_xml(cli, 200, content); strlist_free(files); g_list_free(content); return rcb; err_out_content: strlist_free(content); err_out: strlist_free(files); return cli_err(cli, err); }
guint64 msn_read64le(const char *buf) { return GUINT64_FROM_LE(*(guint64 *)buf); }
char * arv_uvcp_packet_to_string (const ArvUvcpPacket *packet) { GString *string; char *c_string; int packet_size; guint32 value; g_return_val_if_fail (packet != NULL, NULL); string = g_string_new (""); g_string_append_printf (string, "packet_type = %s\n", arv_uvcp_packet_type_to_string (GUINT16_FROM_LE (packet->header.packet_type))); g_string_append_printf (string, "command = %s\n", arv_uvcp_command_to_string (GUINT16_FROM_LE (packet->header.command))); g_string_append_printf (string, "size = %d\n", GUINT16_FROM_LE (packet->header.size)); g_string_append_printf (string, "id = %d\n", GUINT16_FROM_LE (packet->header.id)); switch (GUINT16_FROM_LE (packet->header.command)) { case ARV_UVCP_COMMAND_READ_MEMORY_CMD: { ArvUvcpReadMemoryCmd *cmd_packet = (void *) packet; value = GUINT64_FROM_LE (cmd_packet->infos.address); g_string_append_printf (string, "address = %10u (0x%08x)\n", value, value); value = GUINT16_FROM_LE (cmd_packet->infos.size); g_string_append_printf (string, "size = %10u (0x%08x)\n", value, value); break; } case ARV_UVCP_COMMAND_READ_MEMORY_ACK: { break; } case ARV_UVCP_COMMAND_WRITE_MEMORY_CMD: { ArvUvcpWriteMemoryCmd *cmd_packet = (void *) packet; value = GUINT64_FROM_LE (cmd_packet->infos.address); g_string_append_printf (string, "address = %10u (0x%08x)\n", value, value); } case ARV_UVCP_COMMAND_WRITE_MEMORY_ACK: { ArvUvcpWriteMemoryAck *cmd_packet = (void *) packet; value = GUINT64_FROM_LE (cmd_packet->infos.bytes_written); g_string_append_printf (string, "written = %10u (0x%08x)\n", value, value); } } packet_size = sizeof (ArvUvcpHeader) + GUINT16_FROM_LE (packet->header.size); arv_g_string_append_hex_dump (string, packet, packet_size); c_string = string->str; g_string_free (string, FALSE); return c_string; }
static guint64 get_le64 (const void *buf) { return GUINT64_FROM_LE ( * ((guint64 *) buf) ); }
uint64_t ru64(char **ptr) { *ptr += 8; return GUINT64_FROM_LE(*(uint64_t *)(*ptr - 8)); }