static gboolean _load_v4(PersistState *self, gboolean load_all_entries) { gint fd; gint64 file_size; gpointer map; gpointer key_block; guint32 key_size; PersistFileHeader *header; gint key_count, i; fd = open(self->commited_filename, O_RDONLY); if (fd < 0) { /* no previous data found */ return TRUE; } file_size = lseek(fd, 0, SEEK_END); if (file_size > ((1LL << 31) - 1)) { msg_error("Persistent file too large", evt_tag_str("filename", self->commited_filename), evt_tag_printf("size", "%" G_GINT64_FORMAT, file_size), NULL); return FALSE; } map = mmap(NULL, file_size, PROT_READ, MAP_SHARED, fd, 0); close(fd); if (map == MAP_FAILED) { msg_error("Error mapping persistent file into memory", evt_tag_str("filename", self->commited_filename), evt_tag_errno("error", errno), NULL); return FALSE; } header = (PersistFileHeader *) map; key_block = ((gchar *) map) + offsetof(PersistFileHeader, initial_key_store); key_size = sizeof((((PersistFileHeader *) NULL))->initial_key_store); key_count = GUINT32_FROM_BE(header->key_count); i = 0; while (i < key_count) { gchar *name; guint32 entry_ofs, chain_ofs; SerializeArchive *sa; sa = serialize_buffer_archive_new(key_block, key_size); while (i < key_count) { if (!serialize_read_cstring(sa, &name, NULL)) { serialize_archive_free(sa); msg_error("Persistent file format error, unable to fetch key name", NULL); goto free_and_exit; } if (name[0]) { if (serialize_read_uint32(sa, &entry_ofs)) { PersistValueHeader *value_header; i++; if (entry_ofs < sizeof(PersistFileHeader) || entry_ofs > file_size) { serialize_archive_free(sa); g_free(name); msg_error("Persistent file format error, entry offset is out of bounds", NULL); goto free_and_exit; } value_header = (PersistValueHeader *) ((gchar *) map + entry_ofs - sizeof(PersistValueHeader)); if ((value_header->in_use) || load_all_entries) { gpointer new_block; PersistEntryHandle new_handle; new_handle = _alloc_value(self, GUINT32_FROM_BE(value_header->size), FALSE, value_header->version); new_block = persist_state_map_entry(self, new_handle); memcpy(new_block, value_header + 1, GUINT32_FROM_BE(value_header->size)); persist_state_unmap_entry(self, new_handle); /* add key to the current file */ _add_key(self, name, new_handle); } g_free(name); } else { /* bad format */ serialize_archive_free(sa); g_free(name); msg_error("Persistent file format error, unable to fetch key name", NULL); goto free_and_exit; } } else { g_free(name); if (serialize_read_uint32(sa, &chain_ofs)) { /* end of block, chain to the next one */ if (chain_ofs == 0 || chain_ofs > file_size) { msg_error("Persistent file format error, key block chain offset is too large or zero", evt_tag_printf("key_block", "%08lx", (gulong) ((gchar *) key_block - (gchar *) map)), evt_tag_printf("key_size", "%d", key_size), evt_tag_int("ofs", chain_ofs), NULL); serialize_archive_free(sa); goto free_and_exit; } key_block = ((gchar *) map) + chain_ofs; key_size = GUINT32_FROM_BE(*(guint32 *) (((gchar *) key_block) - sizeof(PersistValueHeader))); if (chain_ofs + key_size > file_size) { msg_error("Persistent file format error, key block size is too large", evt_tag_int("key_size", key_size), NULL); serialize_archive_free(sa); goto free_and_exit; } break; } else { serialize_archive_free(sa); msg_error("Persistent file format error, unable to fetch chained key block offset", NULL); goto free_and_exit; } } } serialize_archive_free(sa); } free_and_exit: munmap(map, file_size); return TRUE; }
/* Incrementally load the next chunk of data. */ static gboolean gdk_pixbuf__qtif_image_load_increment (gpointer data, const guchar *buf, guint size, GError **error) { QTIFContext *context = (QTIFContext *)data; GError *tmp = NULL; gboolean ret = TRUE; /* Return TRUE for insufficient data. */ while(ret && (size != 0u)) { switch(context->state) { case STATE_READY: /* Abort if we have seen too mant atoms. */ if(context->atom_count == 0u) { g_set_error_literal (error, GDK_PIXBUF_ERROR, GDK_PIXBUF_ERROR_CORRUPT_IMAGE, _("Failed to find an image data atom.")); return FALSE; } context->atom_count--; /* Copy to header buffer in context, in case supplied data is not enough. */ while(context->run_length < sizeof(QtHeader)) { context->header_buffer[context->run_length] = *buf; context->run_length++; buf++; size--; } /* Parse buffer as QT header. */ if(context->run_length == sizeof(QtHeader)) { QtHeader *hdr = (QtHeader *)context->header_buffer; context->run_length = GUINT32_FROM_BE(hdr->length) - sizeof(QtHeader); /* Atom max size check. */ if(context->run_length > ATOM_SIZE_MAX) { g_set_error(error, GDK_PIXBUF_ERROR, GDK_PIXBUF_ERROR_CORRUPT_IMAGE, ngettext ( "QTIF atom size too large (%d byte)", "QTIF atom size too large (%d bytes)", hdr->length), hdr->length); return FALSE; } /* Set state according to atom type. */ if(GUINT32_FROM_BE(hdr->tag) == QTIF_TAG_IDATA) { GError *tmp = NULL; context->state = STATE_DATA; /* Create GdkPixbufLoader for this image data. */ ret = gdk_pixbuf__qtif_image_create_loader(context, &tmp); if(!ret) { g_propagate_error (error, tmp); } } else { context->state = STATE_OTHER; } } break; default: /* Both STATE_DATA and STATE_OTHER will come here. */ /* Check for atom boundary. */ if(context->run_length > size) { /* Supply image data to GdkPixbufLoader if in STATE_DATA. */ if(context->state == STATE_DATA) { tmp = NULL; ret = gdk_pixbuf_loader_write(context->loader, buf, size, &tmp); if(!ret && (error != NULL) && (*error == NULL)) { g_propagate_error (error, tmp); } } context->run_length -= size; size = 0u; } else { /* Supply image data to GdkPixbufLoader if in STATE_DATA. */ if(context->state == STATE_DATA) { gboolean r; /* Here we should have concluded a complete image atom. */ tmp = NULL; ret = gdk_pixbuf_loader_write(context->loader, buf, context->run_length, &tmp); if(!ret && (error != NULL) && (*error == NULL)) { g_propagate_error (error, tmp); } /* Free GdkPixbufLoader and handle callback. */ tmp = NULL; r = gdk_pixbuf__qtif_image_free_loader(context, &tmp); if(!r) { if((error != NULL) && (*error == NULL)) { g_propagate_error (error, tmp); } ret = FALSE; } } buf = &buf[context->run_length]; size -= context->run_length; context->run_length = 0u; context->state = STATE_READY; } break; } } return ret; }
/* * NOTE: can only be called from the main thread (e.g. log_pipe_init/deinit). */ static gboolean _add_key(PersistState *self, const gchar *key, PersistEntryHandle handle) { PersistEntry *entry; gpointer key_area; gboolean new_block_created = FALSE; SerializeArchive *sa; g_assert(key[0] != 0); entry = g_new(PersistEntry, 1); entry->ofs = handle; g_hash_table_insert(self->keys, g_strdup(key), entry); /* we try to insert the key into the current block first, then if it doesn't fit, we create a new block */ while (1) { /* the size of the key block chain part, 4 byte for the empty string length, guint32 for the link to the next block */ guint32 chain_size = sizeof(guint32) + sizeof(guint32); gboolean success; key_area = persist_state_map_entry(self, self->current_key_block); /* we reserve space for the next area pointer */ sa = serialize_buffer_archive_new(key_area + self->current_key_ofs, self->current_key_size - self->current_key_ofs - chain_size); sa->silent = TRUE; success = serialize_write_cstring(sa, key, -1) && serialize_write_uint32(sa, handle); if (!success) { serialize_archive_free(sa); if (!new_block_created) { PersistEntryHandle new_block; /* we unmap the key_area as otherwise we can't grow because of the pending maps */ persist_state_unmap_entry(self, self->current_key_block); /* ah, we couldn't fit into the current block, create a new one and link it off the old one */ new_block = _alloc_value(self, PERSIST_STATE_KEY_BLOCK_SIZE, TRUE, 0); if (!new_block) { msg_error("Unable to allocate space in the persistent file for key store", NULL); return FALSE; } key_area = persist_state_map_entry(self, self->current_key_block); sa = serialize_buffer_archive_new(key_area + self->current_key_ofs, self->current_key_size - self->current_key_ofs); if (!serialize_write_cstring(sa, "", 0) || !serialize_write_uint32(sa, new_block)) { /* hmmm. now this is bad, we couldn't write the tail of the block even though we always reserved space for it, this is a programming error somewhere in this function. */ g_assert_not_reached(); } serialize_archive_free(sa); persist_state_unmap_entry(self, self->current_key_block); self->current_key_block = new_block; self->current_key_size = PERSIST_STATE_KEY_BLOCK_SIZE; self->current_key_ofs = 0; new_block_created = TRUE; } else { /* if this happens, that means that the current key * entry won't fit even into a freshly initialized key * block, this means that the key is too large. */ msg_error("Persistent key too large, it cannot be larger than somewhat less than 4k", evt_tag_str("key", key), NULL); persist_state_unmap_entry(self, self->current_key_block); return FALSE; } } else { self->header->key_count = GUINT32_TO_BE(GUINT32_FROM_BE(self->header->key_count) + 1); self->current_key_ofs += serialize_buffer_archive_get_pos(sa); serialize_archive_free(sa); persist_state_unmap_entry(self, self->current_key_block); return TRUE; } } g_assert_not_reached(); }
WhsPattern * whs_pattern_load (const gchar *filename) { g_return_val_if_fail (filename != NULL && *filename != '\0', NULL); FILE *f = g_fopen (filename, "rb"); size_t ret; if (!f) { g_warning ("Can't open file"); return NULL; } // Header gchar header[4]; if ((ret = fread (&header, 1, 4, f)) < 4) { if (ret >= 0) g_warning ("Read only %d of 4 bytes", ret); else g_warning ("Read failed: %s", strerror (ret)); fclose (f); return NULL; } if (strncmp (header, "WHSP", 4) != 0) { g_warning ("Not a valid pattern file"); fclose (f); return NULL; } // Min and max frequency guint32 min_freq, max_freq; if ((ret = fread (&min_freq, 1, 4, f)) < 4) { if (ret >= 0) g_warning ("Read only %d of 4 bytes", ret); else g_warning ("Read failed: %s", strerror (ret)); fclose (f); return NULL; } min_freq = GUINT32_FROM_BE (min_freq); if ((ret = fread (&max_freq, 1, 4, f)) < 4) { if (ret >= 0) g_warning ("Read only %d of 4 bytes", ret); else g_warning ("Read failed: %s", strerror (ret)); fclose (f); return NULL; } max_freq = GUINT32_FROM_BE (max_freq); // Sample rate guint32 sample_rate; if ((ret = fread (&sample_rate, 1, 4, f)) < 4) { if (ret >= 0) g_warning ("Read only %d of 4 bytes", ret); else g_warning ("Read failed: %s", strerror (ret)); fclose (f); return NULL; } sample_rate = GUINT32_FROM_BE (sample_rate); // Classifier name size guint32 size; if ((ret = fread (&size, 1, 4, f)) < 4) { if (ret >= 0) g_warning ("Read only %d of 4 bytes", ret); else g_warning ("Read failed: %s", strerror (ret)); fclose (f); return NULL; } size = GUINT32_FROM_BE (size); if (size <= 0) { g_warning ("No classifier name"); fclose (f); return NULL; } // Classifier name gchar *classifier = g_new0 (gchar, size); if ((ret = fread (classifier, 1, size, f)) < size) { if (ret >= 0) g_warning ("Read only %d of %d bytes", ret, size); else g_warning ("Read failed: %s", strerror (ret)); g_free (classifier); fclose (f); return NULL; } // Classifier data size if ((ret = fread (&size, 1, 4, f)) < 4) { if (ret >= 0) g_warning ("Read only %d of 4 bytes", ret); else g_warning ("Read failed: %s", strerror (ret)); g_free (classifier); fclose (f); return NULL; } size = GUINT32_FROM_BE (size); if (size <= 0) { g_warning ("No classifier data"); fclose (f); g_free (classifier); return NULL; } // Classifier data guint8 *data = g_new0 (guint8, size); if ((ret = fread (data, 1, size, f)) < size) { if (ret >= 0) g_warning ("Read only %d of %d bytes", ret, size); else g_warning ("Read failed: %s", strerror (ret)); g_free (classifier); g_free (data); fclose (f); return NULL; } WhsPattern *self = WHS_PATTERN_CAST (g_type_create_instance (WHS_TYPE_PATTERN)); self->priv->classifier = classifier; self->priv->classifier_data = data; self->priv->size = size; self->priv->min_freq = min_freq; self->priv->max_freq = max_freq; self->priv->sample_rate = sample_rate; fclose (f); return self; }
/* Load QTIF from a file handler. */ static GdkPixbuf *gdk_pixbuf__qtif_image_load (FILE *f, GError **error) { guint count; if(f == NULL) { g_set_error_literal (error, GDK_PIXBUF_ERROR, GDK_PIXBUF_ERROR_BAD_OPTION, _("Input file descriptor is NULL.")); return NULL; } for(count = QTIF_ATOM_COUNT_MAX; count != 0u; count--) { QtHeader hdr; size_t rd; /* Read QtHeader. */ rd = fread(&hdr, 1, sizeof(QtHeader), f); if(rd != sizeof(QtHeader)) { g_set_error_literal(error, GDK_PIXBUF_ERROR, GDK_PIXBUF_ERROR_CORRUPT_IMAGE, _("Failed to read QTIF header")); return NULL; } hdr.length = GUINT32_FROM_BE(hdr.length) - sizeof(QtHeader); if(hdr.length > ATOM_SIZE_MAX) { g_set_error(error, GDK_PIXBUF_ERROR, GDK_PIXBUF_ERROR_CORRUPT_IMAGE, ngettext ( "QTIF atom size too large (%d byte)", "QTIF atom size too large (%d bytes)", hdr.length), hdr.length); return NULL; } switch(GUINT32_FROM_BE(hdr.tag)) { case QTIF_TAG_IDATA: /* "idat" data atom. */ { /* Load image using GdkPixbufLoader. */ guchar *buf; GdkPixbufLoader *loader; GdkPixbuf *pixbuf = NULL; GError *tmp = NULL; /* Allocate read buffer. */ buf = g_try_malloc(READ_BUFFER_SIZE); if(buf == NULL) { g_set_error(error, GDK_PIXBUF_ERROR, GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY, ngettext ( "Failed to allocate %d byte for file read buffer", "Failed to allocate %d bytes for file read buffer", READ_BUFFER_SIZE ), READ_BUFFER_SIZE); return NULL; } /* Create GdkPixbufLoader. */ loader = gdk_pixbuf_loader_new(); if(loader == NULL) { g_set_error(error, GDK_PIXBUF_ERROR, GDK_PIXBUF_ERROR_CORRUPT_IMAGE, ngettext ( "QTIF atom size too large (%d byte)", "QTIF atom size too large (%d bytes)", hdr.length), hdr.length); goto clean_up; } /* Read atom data. */ while(hdr.length != 0u) { rd = (hdr.length > READ_BUFFER_SIZE) ? READ_BUFFER_SIZE : hdr.length; rd = fread(buf, 1, rd, f); if(rd < 0) { g_set_error(error, GDK_PIXBUF_ERROR, GDK_PIXBUF_ERROR_CORRUPT_IMAGE, _("File error when reading QTIF atom: %s"), g_strerror(errno)); break; } if(!gdk_pixbuf_loader_write(loader, buf, rd, &tmp)) { g_propagate_error (error, tmp); break; } hdr.length -= rd; } clean_up: /* Release loader */ if(loader != NULL) { gdk_pixbuf_loader_close(loader, NULL); pixbuf = gdk_pixbuf_loader_get_pixbuf(loader); if(pixbuf != NULL) { g_object_ref(pixbuf); } g_object_unref(loader); } if(buf != NULL) { g_free(buf); } return pixbuf; } default: /* Skip any other types of atom. */ if(!fseek(f, hdr.length, SEEK_CUR)) { g_set_error(error, GDK_PIXBUF_ERROR, GDK_PIXBUF_ERROR_CORRUPT_IMAGE, ngettext ( "Failed to skip the next %d byte with seek().", "Failed to skip the next %d bytes with seek().", hdr.length), hdr.length); return NULL; } break; } } return NULL; }
static gboolean RAS2State(struct rasterfile *RAS, struct ras_progressive_state *State, GError **error) { State->Header.width = GUINT32_FROM_BE(RAS->width); State->Header.height = GUINT32_FROM_BE(RAS->height); State->Header.depth = GUINT32_FROM_BE(RAS->depth); State->Header.type = GUINT32_FROM_BE(RAS->type); State->Header.maptype = GUINT32_FROM_BE(RAS->maptype); State->Header.maplength = GUINT32_FROM_BE(RAS->maplength); if ((gint)State->Header.width <= 0 || (gint)State->Header.height <= 0 || State->Header.maplength > 768) { g_set_error_literal (error, GDK_PIXBUF_ERROR, GDK_PIXBUF_ERROR_CORRUPT_IMAGE, _("RAS image has bogus header data")); return FALSE; } State->RasType = State->Header.depth; /* This may be less trivial someday */ State->HeaderSize = 32 + State->Header.maplength; if (State->RasType == 32) State->LineWidth = State->Header.width * 4; else if (State->RasType == 24) State->LineWidth = State->Header.width * 3; else if (State->RasType == 8) State->LineWidth = State->Header.width * 1; else if (State->RasType == 1) { State->LineWidth = State->Header.width / 8; if ((State->Header.width & 7) != 0) State->LineWidth++; } else { g_set_error_literal (error, GDK_PIXBUF_ERROR, GDK_PIXBUF_ERROR_CORRUPT_IMAGE, _("RAS image has unknown type")); return FALSE; } if (State->Header.type > 2 || State->Header.maptype > 1) { g_set_error_literal (error, GDK_PIXBUF_ERROR, GDK_PIXBUF_ERROR_CORRUPT_IMAGE, _("unsupported RAS image variation")); return FALSE; } /* Now pad the line to be a multiple of 16 bits */ if ((State->LineWidth & 1) != 0) State->LineWidth++; if (!State->LineBuf) { State->LineBuf = g_try_malloc (State->LineWidth); if (!State->LineBuf) { g_set_error_literal (error, GDK_PIXBUF_ERROR, GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY, _("Not enough memory to load RAS image")); return FALSE; } } if (!State->pixbuf) { if (State->size_func) { gint width = State->Header.width; gint height = State->Header.height; (*State->size_func) (&width, &height, State->user_data); if (width == 0 || height == 0) return FALSE; } if (State->RasType == 32) State->pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE, 8, (gint) State->Header.width, (gint) State->Header.height); else State->pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, FALSE, 8, (gint) State->Header.width, (gint) State->Header.height); if (!State->pixbuf) { g_set_error_literal (error, GDK_PIXBUF_ERROR, GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY, _("Not enough memory to load RAS image")); return FALSE; } if (State->prepared_func != NULL) /* Notify the client that we are ready to go */ (*State->prepared_func) (State->pixbuf, NULL, State->user_data); } if ((State->Header.maplength == 0) && (State->RasType == 1)) { State->HeaderBuf[32] = 255; State->HeaderBuf[33] = 0; State->HeaderBuf[34] = 255; State->HeaderBuf[35] = 0; State->HeaderBuf[36] = 255; State->HeaderBuf[37] = 0; } return TRUE; }
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); }
static PartitionTable * part_table_parse_apple (int fd, guint64 offset, guint64 size) { int n; PartitionTable *p; struct { guint16 signature; guint16 block_size; guint32 block_count; /* more stuff */ } __attribute__ ((packed)) mac_header; struct { guint16 signature; guint16 res1; guint32 map_count; guint32 start_block; guint32 block_count; char name[32]; char type[32]; guint32 data_start; guint32 data_count; guint32 status; guint32 boot_start; guint32 boot_size; guint32 boot_load; guint32 boot_load2; guint32 boot_entry; guint32 boot_entry2; guint32 boot_cksum; char processor[16]; /* identifies ISA of boot */ /* more stuff */ } __attribute__ ((packed)) mac_part; int block_size; int block_count; int map_count; HAL_INFO (("Entering Apple parser")); p = NULL; /* Check Mac start of disk signature */ if (lseek (fd, offset + 0, SEEK_SET) < 0) { HAL_INFO (("lseek failed (%s)", strerror (errno))); goto out; } if (read (fd, &mac_header, sizeof (mac_header)) != sizeof (mac_header)) { HAL_INFO (("read failed (%s)", strerror (errno))); goto out; } if (memcmp (&(mac_header.signature), MAC_MAGIC, 2) != 0) { HAL_INFO (("No MAC_MAGIC found")); goto out; } block_size = GUINT16_FROM_BE (mac_header.block_size); block_count = GUINT32_FROM_BE (mac_header.block_count); /* num blocks on whole disk */ HAL_INFO (("Mac MAGIC found, block_size=%d", block_size)); p = part_table_new_empty (PART_TYPE_APPLE); p->offset = offset; p->size = size; /* get number of entries from first entry */ if (lseek (fd, offset + block_size, SEEK_SET) < 0) { HAL_INFO (("lseek failed (%s)", strerror (errno))); goto out; } if (read (fd, &mac_part, sizeof (mac_part)) != sizeof (mac_part)) { HAL_INFO (("read failed (%s)", strerror (errno))); goto out; } map_count = GUINT32_FROM_BE (mac_part.map_count); /* num blocks in part map */ HAL_INFO (("map_count = %d", map_count)); for (n = 0; n < map_count; n++) { PartitionEntry *pe; if (memcmp (&(mac_part.signature), MAC_PART_MAGIC, 2) != 0) { HAL_INFO (("No MAC_PART_MAGIC found")); break; } if (lseek (fd, offset + (n + 1) * block_size, SEEK_SET) < 0) { HAL_INFO (("lseek failed (%s)", strerror (errno))); goto out; } if (read (fd, &mac_part, sizeof (mac_part)) != sizeof (mac_part)) { HAL_INFO (("read failed (%s)", strerror (errno))); goto out; } pe = part_entry_new (NULL, (guint8*) &mac_part, sizeof (mac_part), offset + (n + 1) * block_size); p->entries = g_slist_append (p->entries, pe); } out: HAL_INFO (("Leaving Apple parser")); return p; }
static guint32 get_be32 (const void *buf) { return GUINT32_FROM_BE ( * ((guint32 *) buf) ); }
static inline guint32 guint32_from_be (const guint32_be be) { guint32 tmp; memcpy (&tmp, &be, sizeof tmp); return GUINT32_FROM_BE (tmp); }
uint32_t rd_long(uint8_t *p) { uint32_t *p32 = (uint32_t *)p; return GUINT32_FROM_BE(*p32); }
static gpointer open_thread_func (gpointer user_data) { SyncData *data = user_data; GVfsAfpConnection *conn = data->conn; GVfsAfpConnectionPrivate *priv = conn->priv; GSocketClient *client; guint16 req_id; gboolean res = FALSE; char *reply; DSIHeader dsi_header; guint pos; client = g_socket_client_new (); priv->stream = G_IO_STREAM (g_socket_client_connect (client, priv->addr, data->cancellable, data->error)); g_object_unref (client); if (!priv->stream) goto out; req_id = get_request_id (conn); res = send_request_sync (g_io_stream_get_output_stream (priv->stream), DSI_OPEN_SESSION, req_id, 0, 0, NULL, data->cancellable, data->error); if (!res) goto out; res = read_reply_sync (g_io_stream_get_input_stream (priv->stream), &dsi_header, &reply, data->cancellable, data->error); if (!res) goto out; pos = 0; while ((dsi_header.totalDataLength - pos) > 2) { guint8 optionType; guint8 optionLength; optionType = reply[pos++]; optionLength = reply[pos++]; switch (optionType) { case 0x00: if (optionLength == 4 && (dsi_header.totalDataLength - pos) >= 4) priv->kRequestQuanta = GUINT32_FROM_BE (*(guint32 *)(reply + pos)); break; case 0x02: if (optionLength == 4 && (dsi_header.totalDataLength - pos) >= 4) priv->kServerReplayCacheSize = GUINT32_FROM_BE (*(guint32 *)(reply + pos)); break; default: g_debug ("Unknown DSI option\n"); } pos += optionLength; } g_free (reply); out: if (res) g_atomic_int_set (&priv->atomic_state, STATE_CONNECTED); /* Signal sync call thread */ data->res = res; sync_data_signal (data); /* Return from thread on failure */ if (!res) { g_clear_object (&priv->stream); return NULL; } /* Create MainLoop */ priv->worker_context = g_main_context_new (); priv->worker_loop = g_main_loop_new (priv->worker_context, TRUE); read_reply (conn); /* Run mainloop */ g_main_loop_run (priv->worker_loop); return NULL; }