Index: uspace/srv/fs/udf/udf_cksum.c =================================================================== --- uspace/srv/fs/udf/udf_cksum.c (revision 5d94b16cbc3039fadf35402057e9f7dff1917037) +++ uspace/srv/fs/udf/udf_cksum.c (revision 0a4e1c77c74b5ead21db7cd9a738ffaacc357307) @@ -73,17 +73,4 @@ }; -/** Calculate CRC16 - * - */ -uint16_t udf_cksum(uint8_t *buf, size_t len) -{ - uint16_t crc = 0; - - while (len-- > 0) - crc = crc_table[(crc >> 8 ^ *buf++) & 0xff] ^ (crc << 8); - - return crc; -} - /** Unicode checksum * @@ -103,24 +90,4 @@ return crc; -} - -/** EA checksum - * - * Calculate a 16-bit checksum of the Implementation Use - * Extended Attribute header or Application Use Extended Attribute - * header. The fields AttributeType through ImplementationIdentifier - * (or ApplicationIdentifier) inclusively represent the - * data covered by the checksum (48 bytes). - * - */ -uint16_t udf_ea_cksum(uint8_t *data) -{ - uint16_t checksum = 0; - size_t count; - - for (count = 0; count < 48; count++) - checksum += *data++; - - return checksum; } Index: uspace/srv/fs/udf/udf_cksum.h =================================================================== --- uspace/srv/fs/udf/udf_cksum.h (revision 5d94b16cbc3039fadf35402057e9f7dff1917037) +++ uspace/srv/fs/udf/udf_cksum.h (revision 0a4e1c77c74b5ead21db7cd9a738ffaacc357307) @@ -39,7 +39,5 @@ #define UDF_TAG_SIZE 16 -extern uint16_t udf_cksum(uint8_t *, size_t); extern uint16_t udf_unicode_cksum(uint16_t *, size_t); -extern uint16_t udf_ea_cksum(uint8_t *); extern uint8_t udf_tag_checksum(uint8_t *); Index: uspace/srv/fs/udf/udf_file.c =================================================================== --- uspace/srv/fs/udf/udf_file.c (revision 5d94b16cbc3039fadf35402057e9f7dff1917037) +++ uspace/srv/fs/udf/udf_file.c (revision 0a4e1c77c74b5ead21db7cd9a738ffaacc357307) @@ -57,5 +57,5 @@ * */ -int udf_read_extended_allocator(udf_node_t *node, uint16_t icb_flag, +static int udf_read_extended_allocator(udf_node_t *node, uint16_t icb_flag, uint32_t pos) { @@ -185,5 +185,5 @@ */ if (FLE32(long_d->length) >> 30 == 3) { - udf_read_extended_allocator (node, icb_flag, pos_long_ad); + udf_read_extended_allocator(node, icb_flag, pos_long_ad); break; } @@ -296,116 +296,4 @@ } -/** Read ICB sequence of allocators in Unallocated space entry descriptor - * - * This function read ICB sequence if free space is saved by space table. - * Not finished. - * - * @param uased Unallocated space entry descriptor - * @param icb_flag Type of allocators in sequence. - * According to ECMA 167 4/14.8.8 - * @param start_alloc Offset of the allocator - * @param len Length of sequence - * - * @return EOK on success or a negative error code. - * - */ -int udf_read_free_space(uint8_t *uased, uint16_t icb_flag, - uint32_t start_alloc, uint32_t len) -{ - switch (icb_flag) { - case UDF_SHORT_AD: - log_msg(LVL_DEBUG, - "UAICB: sequence of allocation descriptors - icbflag = short_ad_t"); - - /* Identify number of current partition */ - - size_t cnt = len / sizeof(udf_short_ad_t); - size_t n = 0; - - while (n < cnt) { - udf_short_ad_t *short_d = - (udf_short_ad_t *) (uased + start_alloc + n * sizeof(udf_short_ad_t)); - - if (short_d->length == 0) - break; - - n++; - } - - break; - - case UDF_LONG_AD: - log_msg(LVL_DEBUG, - "UAICB: sequence of allocation descriptors - icbflag = long_ad_t"); - - cnt = len / sizeof(udf_long_ad_t); - n = 0; - - while (n < cnt) { - udf_long_ad_t *long_d = - (udf_long_ad_t *) (uased + start_alloc + n * sizeof(udf_long_ad_t)); - - if (long_d->length == 0) - break; - - n++; - } - - break; - - case UDF_EXTENDED_AD: - log_msg(LVL_DEBUG, - "UAICB: sequence of allocation descriptors - icbflag = extended_ad_t"); - break; - - case UDF_DATA_AD: - log_msg(LVL_DEBUG, - "UAICB: sequence of allocation descriptors - icbflag = 3, node contains data itself"); - break; - } - - return EOK; -} - -/** Read Unallocated space entry descriptor - * - * Read ICB sequence if free space is saved by space table. - * Not finished. - * - */ -int udf_read_unallocated_space_entry(udf_instance_t * instance, uint64_t pos, - uint32_t len) -{ - block_t *block = NULL; - int rc = block_get(&block, instance->service_id, pos, BLOCK_FLAGS_NONE); - if (rc != EOK) - return rc; - - udf_descriptor_tag_t *desc = (udf_descriptor_tag_t *) block->data; - if (desc->checksum != udf_tag_checksum((uint8_t *) desc)) { - block_put(block); - return EINVAL; - } - - if (FLE16(desc->id) != UDF_UASPACE_ENTRY) { - // FIXME: Memory leak - return EINVAL; - } - - udf_unallocated_space_entry_descriptor_t *uased = - (udf_unallocated_space_entry_descriptor_t *) block->data; - if (uased->icbtag.file_type != UDF_ICBTYPE_UASE) { - // FIXME: Memory leak - return EINVAL; - } - - uint16_t icb_flag = uased->icbtag.flags & UDF_ICBFLAG_MASK; - - rc = udf_read_free_space((uint8_t *) uased, icb_flag, - UDF_UASE_OFFSET, uased->ad_lenght); - - return block_put(block); -} - /** Read data from disk - filling UDF node by allocators * @@ -419,23 +307,4 @@ node->link_cnt = 1; return udf_read_icb(node); -} - -/** Read directory entry - * - * @param fid Returned value - * @param block Returned value - * @param node UDF node - * @param pos Number of FID which we need to find - * - * @return EOK on success or a negative error code. - * - */ -int udf_get_fid(udf_file_identifier_descriptor_t **fid, block_t **block, - udf_node_t *node, aoff64_t pos) -{ - if (node->data == NULL) - return udf_get_fid_in_allocator(fid, block, node, pos); - - return udf_get_fid_in_data(fid, node, pos); } @@ -449,5 +318,5 @@ * */ -int udf_get_fid_in_data(udf_file_identifier_descriptor_t **fid, +static int udf_get_fid_in_data(udf_file_identifier_descriptor_t **fid, udf_node_t *node, aoff64_t pos) { @@ -488,4 +357,23 @@ return ENOENT; +} + +/** Read directory entry + * + * @param fid Returned value + * @param block Returned value + * @param node UDF node + * @param pos Number of FID which we need to find + * + * @return EOK on success or a negative error code. + * + */ +int udf_get_fid(udf_file_identifier_descriptor_t **fid, block_t **block, + udf_node_t *node, aoff64_t pos) +{ + if (node->data == NULL) + return udf_get_fid_in_allocator(fid, block, node, pos); + + return udf_get_fid_in_data(fid, node, pos); } Index: uspace/srv/fs/udf/udf_file.h =================================================================== --- uspace/srv/fs/udf/udf_file.h (revision 5d94b16cbc3039fadf35402057e9f7dff1917037) +++ uspace/srv/fs/udf/udf_file.h (revision 0a4e1c77c74b5ead21db7cd9a738ffaacc357307) @@ -197,10 +197,7 @@ extern int udf_read_allocation_sequence(udf_node_t *, uint8_t *, uint16_t, uint32_t, uint32_t); -extern int udf_read_extended_allocator(udf_node_t *, uint16_t, uint32_t); extern int udf_read_file(size_t *, ipc_callid_t, udf_node_t *, aoff64_t, size_t); extern int udf_get_fid(udf_file_identifier_descriptor_t **, block_t **, - udf_node_t *, aoff64_t); -extern int udf_get_fid_in_data(udf_file_identifier_descriptor_t **, udf_node_t *, aoff64_t); extern int udf_get_fid_in_allocator(udf_file_identifier_descriptor_t **, @@ -208,7 +205,4 @@ extern int udf_get_fid_in_sector(udf_file_identifier_descriptor_t **, block_t **, udf_node_t *, aoff64_t, size_t *, void **, size_t *); -extern int udf_read_free_space(uint8_t *, uint16_t, uint32_t, uint32_t); -extern int udf_read_unallocated_space_entry(udf_instance_t *, uint64_t, - uint32_t); #endif /* UDF_FILE_H_ */ Index: uspace/srv/fs/udf/udf_osta.c =================================================================== --- uspace/srv/fs/udf/udf_osta.c (revision 5d94b16cbc3039fadf35402057e9f7dff1917037) +++ uspace/srv/fs/udf/udf_osta.c (revision 0a4e1c77c74b5ead21db7cd9a738ffaacc357307) @@ -96,6 +96,6 @@ * */ -size_t udf_uncompress_unicode(size_t number_of_bytes, uint8_t *udf_compressed, - uint16_t *unicode, size_t unicode_max_len) +static size_t udf_uncompress_unicode(size_t number_of_bytes, + uint8_t *udf_compressed, uint16_t *unicode, size_t unicode_max_len) { /* Use udf_compressed to store current byte being read. */ @@ -129,54 +129,4 @@ return unicode_idx; -} - -/** Convert Unicode wide characters to OSTA CS0 compressed Unicode string. - * - * The Unicode MUST be in the byte order of the compiler in order - * to obtain correct results. Returns an error if the compression ID - * is invalid. - * - * NOTE: This routine assumes the implementation already knows, - * by the local environment, how many bits are appropriate and therefore - * does no checking to test if the input characters fit into that number - * of bits or not. - * - * @param[in] number_of_chars Number of unicode characters. - * @param[in] comp_id Compression ID to be used. - * @param[in] unicode Unicode characters to compress. - * @param[out] udf_compressed Compressed string, as bytes. - * - * @return The total number of bytes in the compressed OSTA CS0 string, - * including the compression ID. - * - */ -size_t udf_compress_unicode(size_t number_of_chars, uint8_t comp_id, - uint16_t *unicode, uint8_t *udf_compressed) -{ - if ((comp_id != 8) && (comp_id != 16)) - return 0; - - /* Place compression code in first byte. */ - udf_compressed[0] = comp_id; - - size_t byte_idx = 1; - size_t unicode_idx = 0; - - while (unicode_idx < number_of_chars) { - if (comp_id == 16) { - /* - * First, place the high bits of the char - * into the byte stream. - */ - udf_compressed[byte_idx++] = - (unicode[unicode_idx] & 0xFF00) >> 8; - } - - /* Then place the low bits into the stream. */ - udf_compressed[byte_idx++] = unicode[unicode_idx] & 0x00FF; - unicode_idx++; - } - - return byte_idx; } Index: uspace/srv/fs/udf/udf_osta.h =================================================================== --- uspace/srv/fs/udf/udf_osta.h (revision 5d94b16cbc3039fadf35402057e9f7dff1917037) +++ uspace/srv/fs/udf/udf_osta.h (revision 0a4e1c77c74b5ead21db7cd9a738ffaacc357307) @@ -52,6 +52,4 @@ #define PERIOD 0x002E -extern size_t udf_uncompress_unicode(size_t, uint8_t *, uint16_t *, size_t); -extern size_t udf_compress_unicode(size_t, uint8_t, uint16_t *, uint8_t *); extern size_t udf_translate_name(uint16_t *, uint16_t *, size_t); extern void udf_to_unix_name(char *, size_t, char *, size_t, udf_charspec_t *); Index: uspace/srv/fs/udf/udf_types.h =================================================================== --- uspace/srv/fs/udf/udf_types.h (revision 5d94b16cbc3039fadf35402057e9f7dff1917037) +++ uspace/srv/fs/udf/udf_types.h (revision 0a4e1c77c74b5ead21db7cd9a738ffaacc357307) @@ -142,6 +142,4 @@ } __attribute__((packed)) udf_unallocated_space_descriptor_t; -extern void udf_prepare_tag(udf_descriptor_tag_t *); - #endif Index: uspace/srv/fs/udf/udf_volume.c =================================================================== --- uspace/srv/fs/udf/udf_volume.c (revision 5d94b16cbc3039fadf35402057e9f7dff1917037) +++ uspace/srv/fs/udf/udf_volume.c (revision 0a4e1c77c74b5ead21db7cd9a738ffaacc357307) @@ -151,5 +151,5 @@ * */ -void udf_prepare_tag(udf_descriptor_tag_t *tag) +static void udf_prepare_tag(udf_descriptor_tag_t *tag) { GET_LE16(tag->id); @@ -159,4 +159,39 @@ GET_LE16(tag->descriptor_crc_length); GET_LE32(tag->location); +} + +/** Read AVD by using one of default sector size from array + * + * @param service_id + * @param avd Returned value - Anchor Volume Descriptor + * @param sector_size Expected sector size + * + * @return EOK on success or a negative error code. + * + */ +static int udf_get_anchor_volume_descriptor_by_ssize(service_id_t service_id, + udf_anchor_volume_descriptor_t *avd, uint32_t sector_size) +{ + int rc = block_read_bytes_direct(service_id, + UDF_AVDP_SECTOR * sector_size, + sizeof(udf_anchor_volume_descriptor_t), avd); + if (rc != EOK) + return rc; + + if (avd->tag.checksum != udf_tag_checksum((uint8_t *) &avd->tag)) + return EINVAL; + + // TODO: Should be tested in big-endian mode + udf_prepare_tag(&avd->tag); + + if (avd->tag.id != UDF_TAG_AVDP) + return EINVAL; + + GET_LE32(avd->main_extent.length); + GET_LE32(avd->main_extent.location); + GET_LE32(avd->reserve_extent.length); + GET_LE32(avd->reserve_extent.location); + + return EOK; } @@ -200,39 +235,4 @@ return EINVAL; -} - -/** Read AVD by using one of default sector size from array - * - * @param service_id - * @param avd Returned value - Anchor Volume Descriptor - * @param sector_size Expected sector size - * - * @return EOK on success or a negative error code. - * - */ -int udf_get_anchor_volume_descriptor_by_ssize(service_id_t service_id, - udf_anchor_volume_descriptor_t *avd, uint32_t sector_size) -{ - int rc = block_read_bytes_direct(service_id, - UDF_AVDP_SECTOR * sector_size, - sizeof(udf_anchor_volume_descriptor_t), avd); - if (rc != EOK) - return rc; - - if (avd->tag.checksum != udf_tag_checksum((uint8_t *) &avd->tag)) - return EINVAL; - - // TODO: Should be tested in BegEndian mode - udf_prepare_tag(&avd->tag); - - if (avd->tag.id != UDF_TAG_AVDP) - return EINVAL; - - GET_LE32(avd->main_extent.length); - GET_LE32(avd->main_extent.location); - GET_LE32(avd->reserve_extent.length); - GET_LE32(avd->reserve_extent.location); - - return EOK; } Index: uspace/srv/fs/udf/udf_volume.h =================================================================== --- uspace/srv/fs/udf/udf_volume.h (revision 5d94b16cbc3039fadf35402057e9f7dff1917037) +++ uspace/srv/fs/udf/udf_volume.h (revision 0a4e1c77c74b5ead21db7cd9a738ffaacc357307) @@ -215,6 +215,4 @@ extern int udf_get_anchor_volume_descriptor(service_id_t, udf_anchor_volume_descriptor_t *); -extern int udf_get_anchor_volume_descriptor_by_ssize(service_id_t, - udf_anchor_volume_descriptor_t *, uint32_t); extern int udf_read_volume_descriptor_sequence(service_id_t, udf_extent_t); extern fs_index_t udf_long_ad_to_pos(udf_instance_t *, udf_long_ad_t *);