go/src/thinfs/fs/msdosfs/direntry/filename_conversion.go - garnet - Git at Google

 // Copyright 2016 The Fuchsia Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 package direntry

 import (
 	"errors"
 	"strconv"
 	"strings"
 	"unicode/utf16"

 	"thinfs/bitops"
 )

 const (
 	cBad = 0 // Characters disallowed in both short and long filenames.
 	cRpl = 1 // Characters +,;=[] should be replaced by '_', and a generation number MUST be used.
 	cSkp = 2 // '.' or ' '. Skip this character.

 	dosBaseNameLen = 8
 	dosExtNameLen  = 3
 	dosNameLen     = dosBaseNameLen + dosExtNameLen

 	maxASCII = '\u007F' // Maximum ASCII value
 )

 var (
 	errChecksum        = errors.New("Invalid checksum")
 	errTooLong         = errors.New("Name too long")
 	errInvalidFilename = errors.New("Invalid filename cannot be converted")
 	errLongDirentry    = errors.New("Invalid long direntry")
 )

 // Converts ASCII characters [0, 0x7F] to DOS "Code page 850" characters.
 var asciiFilter = [128]byte{
 	cBad, cBad, cBad, cBad, cBad, cBad, cBad, cBad, /* 00-07 */
 	cBad, cBad, cBad, cBad, cBad, cBad, cBad, cBad, /* 08-0f */
 	cBad, cBad, cBad, cBad, cBad, cBad, cBad, cBad, /* 10-17 */
 	cBad, cBad, cBad, cBad, cBad, cBad, cBad, cBad, /* 18-1f */
 	cSkp, 0x21, cBad, 0x23, 0x24, 0x25, 0x26, 0x27, /* 20-27 */
 	0x28, 0x29, cBad, cRpl, cRpl, 0x2d, cSkp, cBad, /* 28-2f */
 	0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, /* 30-37 */
 	0x38, 0x39, cBad, cRpl, cBad, cRpl, cBad, cBad, /* 38-3f */
 	0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, /* 40-47 */
 	0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, /* 48-4f */
 	0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, /* 50-57 */
 	0x58, 0x59, 0x5a, cRpl, cBad, cRpl, 0x5e, 0x5f, /* 58-5f */
 	0x60, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, /* 60-67 */
 	0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, /* 68-6f */
 	0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, /* 70-77 */
 	0x58, 0x59, 0x5a, 0x7b, cBad, 0x7d, 0x7e, cBad, /* 78-7f */
 }

 // Converts some unicode characters to DOS "Code page 850" characters.
 var unicodeToDos = map[rune]byte{
 	'\u00C7': 0x80, '\u00FC': 0x81, '\u00E9': 0x82, '\u00E2': 0x83, '\u00E4': 0x84, '\u00E0': 0x85, '\u00E5': 0x86, '\u00E7': 0x87,
 	'\u00EA': 0x88, '\u00EB': 0x89, '\u00E8': 0x8A, '\u00EF': 0x8B, '\u00EE': 0x8C, '\u00EC': 0x8D, '\u00C4': 0x8E, '\u00C5': 0x8F,
 	'\u00C9': 0x90, '\u00E6': 0x91, '\u00C6': 0x92, '\u00F4': 0x93, '\u00F6': 0x94, '\u00F2': 0x95, '\u00FB': 0x96, '\u00F9': 0x97,
 	'\u00FF': 0x98, '\u00D6': 0x99, '\u00DC': 0x9A, '\u00F8': 0x9B, '\u00A3': 0x9C, '\u00D8': 0x9D, '\u00D7': 0x9E, '\u0192': 0x9F,
 	'\u00E1': 0xA0, '\u00ED': 0xA1, '\u00F3': 0xA2, '\u00FA': 0xA3, '\u00F1': 0xA4, '\u00D1': 0xA5, '\u00AA': 0xA6, '\u00BA': 0xA7,
 	'\u00BF': 0xA8, '\u00AE': 0xA9, '\u00AC': 0xAA, '\u00BD': 0xAB, '\u00BC': 0xAC, '\u00A1': 0xAD, '\u00AB': 0xAE, '\u00BB': 0xAF,
 	'\u2591': 0xB0, '\u2592': 0xB1, '\u2593': 0xB2, '\u2502': 0xB3, '\u2524': 0xB4, '\u00C1': 0xB5, '\u00C2': 0xB6, '\u00C0': 0xB7,
 	'\u00A9': 0xB8, '\u2563': 0xB9, '\u2551': 0xBA, '\u2557': 0xBB, '\u255D': 0xBC, '\u00A2': 0xBD, '\u00A5': 0xBE, '\u2510': 0xBF,
 	'\u2514': 0xC0, '\u2534': 0xC1, '\u252C': 0xC2, '\u251C': 0xC3, '\u2500': 0xC4, '\u253C': 0xC5, '\u00E3': 0xC6, '\u00C3': 0xC7,
 	'\u255A': 0xC8, '\u2554': 0xC9, '\u2569': 0xCA, '\u2566': 0xCB, '\u2560': 0xCC, '\u2550': 0xCD, '\u256C': 0xCE, '\u00A4': 0xCF,
 	'\u00F0': 0xD0, '\u00D0': 0xD1, '\u00CA': 0xD2, '\u00CB': 0xD3, '\u00C8': 0xD4, '\u0131': 0xD5, '\u00CD': 0xD6, '\u00CE': 0xD7,
 	'\u00CF': 0xD8, '\u2518': 0xD9, '\u250C': 0xDA, '\u2588': 0xDB, '\u2584': 0xDC, '\u00A6': 0xDD, '\u00CC': 0xDE, '\u2580': 0xDF,
 	'\u00D3': 0xE0, '\u00DF': 0xE1, '\u00D4': 0xE2, '\u00D2': 0xE3, '\u00F5': 0xE4, '\u00D5': 0xE5, '\u00B5': 0xE6, '\u00FE': 0xE7,
 	'\u00DE': 0xE8, '\u00DA': 0xE9, '\u00DB': 0xEA, '\u00D9': 0xEB, '\u00FD': 0xEC, '\u00DD': 0xED, '\u00AF': 0xEE, '\u00B4': 0xEF,
 	'\u00AD': 0xF0, '\u00B1': 0xF1, '\u2017': 0xF2, '\u00BE': 0xF3, '\u00B6': 0xF4, '\u00A7': 0xF5, '\u00F7': 0xF6, '\u00B8': 0xF7,
 	'\u00B0': 0xF8, '\u00A8': 0xF9, '\u00B7': 0xFA, '\u00B9': 0xFB, '\u00B3': 0xFC, '\u00B2': 0xFD, '\u25A0': 0xFE, '\u00A0': 0xFF,
 }

 // Converts DOS "Code page 850" characters in range [0x80, 0xFF] to Unicode runes.
 var dosToUnicode = [128]rune{
 	'\u00C7', '\u00FC', '\u00E9', '\u00E2', '\u00E4', '\u00E0', '\u00E5', '\u00E7',
 	'\u00EA', '\u00EB', '\u00E8', '\u00EF', '\u00EE', '\u00EC', '\u00C4', '\u00C5',
 	'\u00C9', '\u00E6', '\u00C6', '\u00F4', '\u00F6', '\u00F2', '\u00FB', '\u00F9',
 	'\u00FF', '\u00D6', '\u00DC', '\u00F8', '\u00A3', '\u00D8', '\u00D7', '\u0192',
 	'\u00E1', '\u00ED', '\u00F3', '\u00FA', '\u00F1', '\u00D1', '\u00AA', '\u00BA',
 	'\u00BF', '\u00AE', '\u00AC', '\u00BD', '\u00BC', '\u00A1', '\u00AB', '\u00BB',
 	'\u2591', '\u2592', '\u2593', '\u2502', '\u2524', '\u00C1', '\u00C2', '\u00C0',
 	'\u00A9', '\u2563', '\u2551', '\u2557', '\u255D', '\u00A2', '\u00A5', '\u2510',
 	'\u2514', '\u2534', '\u252C', '\u251C', '\u2500', '\u253C', '\u00E3', '\u00C3',
 	'\u255A', '\u2554', '\u2569', '\u2566', '\u2560', '\u2550', '\u256C', '\u00A4',
 	'\u00F0', '\u00D0', '\u00CA', '\u00CB', '\u00C8', '\u0131', '\u00CD', '\u00CE',
 	'\u00CF', '\u2518', '\u250C', '\u2588', '\u2584', '\u00A6', '\u00CC', '\u2580',
 	'\u00D3', '\u00DF', '\u00D4', '\u00D2', '\u00F5', '\u00D5', '\u00B5', '\u00FE',
 	'\u00DE', '\u00DA', '\u00DB', '\u00D9', '\u00FD', '\u00DD', '\u00AF', '\u00B4',
 	'\u00AD', '\u00B1', '\u2017', '\u00BE', '\u00B6', '\u00A7', '\u00F7', '\u00B8',
 	'\u00B0', '\u00A8', '\u00B7', '\u00B9', '\u00B3', '\u00B2', '\u25A0', '\u00A0',
 }

 // DOS filenames consist of:
 // 1) The "name" part ("FOO" from "FOO.TXT"), which is 8 characters long.
 // 2) The "extension part ("TXT" from "FOO.TXT"), which is 3 characters long.
 //
 // Both parts may contain trailing spaces if the filename component does not use the maximum
 // allocated space.

 // convertDOSToUnix converts a DOS filename (single byte, cp850 encoding) to a UTF-8 encoded string.
 func convertDOSToUnix(nameDOS []byte, lowercase bool) string {
 	if len(nameDOS) != dosNameLen {
 		panic("Unexpected convertDOSToUnix name len: ")
 	}

 	switch string(nameDOS) {
 	case ".          ":
 		return "."
 	case "..         ":
 		return ".."
 	}

 	nameUnix := make([]rune, 0, dosNameLen+1)
 	for i := 0; i < dosBaseNameLen && nameDOS[i] != ' '; i++ {
 		charDOS := nameDOS[i]
 		if i == 0 {
 			switch charDOS {
 			case charE5:
 				// "If DIR_Name[0] == 0x05 (SLOT_E5), then the actual file name character for this
 				// byte is 0xE5". 0xE5 is reserved to mean "free entry". DOS quirk.
 				charDOS = 0xE5
 			case charLastFree, charFree:
 				// Free entries do not have filenames
 				return ""
 			}
 		}
 		nameUnix = append(nameUnix, charDOSToUnix(charDOS))
 	}

 	// Jump to the extension.
 	extStartIndex := dosBaseNameLen
 	if nameDOS[extStartIndex] != ' ' {
 		// Add a '.' if an extension exists, then add the extension itself.
 		nameUnix = append(nameUnix, '.')
 		for i := extStartIndex; i < dosNameLen && nameDOS[i] != ' '; i++ {
 			nameUnix = append(nameUnix, charDOSToUnix(nameDOS[i]))
 		}
 	}

 	// By default, DOS strings are uppercase. Conditionally convert them to lowercase.
 	if lowercase {
 		return strings.ToLower(string(nameUnix))
 	}
 	// DOS strings should not be stored as anything other than uppercase, but just in case, convert
 	// it to uppercase.
 	return strings.ToUpper(string(nameUnix))
 }

 // convertUnixToDOS converts a unix filename to a DOS filename according to Win95 rules.
 // This function implements the "Basis-Name Generation Algorithm" and "Numeric-Tail Generation
 // Algorithm" described in the FAT documentation.
 //
 // The resulting filename may either be a short name (which should be paired with a long filename)
 // a short name (which should not be paired with a long filename), or empty (due to an error).
 func convertUnixToDOS(callback GetDirentryCallback, nameUnix string) (nameDOS []byte, longnameNeeded bool, err error) {
 	// "The UNICODE name passed to the file system is converted to upper case."
 	containsLowercase := false
 	nameUnixUpper := strings.ToUpper(nameUnix)
 	if nameUnix != nameUnixUpper {
 		containsLowercase = true
 	}
 	nameUnix = nameUnixUpper

 	nameBaseDOS := make([]byte, 0, dosBaseNameLen)
 	nameExtDOS := make([]byte, 0, dosExtNameLen)

 	// Wraps up both the "Main" and "Extension" parts of the name into one slice.
 	composeDOSName := func() []byte {
 		// Add spacing to main and ext.
 		for len(nameBaseDOS) < dosBaseNameLen {
 			nameBaseDOS = append(nameBaseDOS, ' ')
 		}
 		for len(nameExtDOS) < dosExtNameLen {
 			nameExtDOS = append(nameExtDOS, ' ')
 		}

 		// This is a DOS-ism. 'E5' is reserved for charFree, but '05' means this byte should later
 		// be replaced with 'E5'.
 		if nameBaseDOS[0] == charFree {
 			nameBaseDOS[0] = charE5
 		}
 		res := append(nameBaseDOS, nameExtDOS...)
 		return res
 	}

 	// The filenames "." and ".." are handled specially, since they don't follow DOS filename rules.
 	if string(nameUnix) == "." {
 		nameBaseDOS = append(nameBaseDOS, '.')
 		return composeDOSName(), false, nil
 	}
 	if string(nameUnix) == ".." {
 		nameBaseDOS = append(nameBaseDOS, '.', '.')
 		return composeDOSName(), false, nil
 	}

 	// Skip all trailing spaces and dots (they are ignored in both short and long names).
 	nameUnix = strings.TrimRight(nameUnix, " .")
 	if nameUnix == "" {
 		// Filenames cannot contain EXCLUSIVELY spaces and dots.
 		return nil, false, errInvalidFilename
 	}

 	// Convert the upper-case unicode name to cp850.
 	nameDOSRaw := make([]byte, 0, len(nameUnix))
 	// "lossyConversion" indicates that we may have left some characters behind that would have fit
 	// in a long name.
 	lossyConversion := false
 	leadingPeriods := true
 	for i, runeValue := range nameUnix {
 		c := charUnixToDOS(runeValue)
 		switch c {
 		case cRpl:
 			nameDOSRaw = append(nameDOSRaw, '_')
 			leadingPeriods = false
 			lossyConversion = true
 		case cSkp:
 			if nameUnix[i] == '.' {
 				if leadingPeriods { // Should be stored in long names, but not short names.
 					lossyConversion = true
 				} else { // For now, insert all non-leading/trailing '.' chars. Only one will be used.
 					nameDOSRaw = append(nameDOSRaw, '.')
 				}
 			} else {
 				// We always skip spaces for short DOS names.
 				lossyConversion = true
 			}
 		case cBad:
 			return nil, false, errInvalidFilename
 		default:
 			// Copy the converted character.
 			nameDOSRaw = append(nameDOSRaw, c)
 			leadingPeriods = false
 		}
 	}

 	// Find the last non-trailing '.' character (the extension dot).
 	var extensionDot int
 	for extensionDot = len(nameDOSRaw) - 1; extensionDot >= 0; extensionDot-- {
 		if nameDOSRaw[extensionDot] == '.' {
 			break
 		}
 	}
 	// ExtensionDot will be "-1" if it does not exist.

 	// Copy the 'base' part of the name.
 	for i := range nameDOSRaw {
 		if i == extensionDot {
 			// Copy everything up to the extension.
 			break
 		}
 		if i == dosBaseNameLen {
 			// Only copy up to "dosBaseNameLen" characters.
 			lossyConversion = true
 			break
 		}
 		charDOS := nameDOSRaw[i]
 		if charDOS == '.' {
 			// We're losing an inner '.' character.
 			lossyConversion = true
 		} else {
 			nameBaseDOS = append(nameBaseDOS, charDOS)
 		}
 	}

 	// If the extension exists...
 	if extensionDot != -1 {
 		// ... copy the 'extension' part of the name.
 		for i := extensionDot + 1; i < len(nameDOSRaw); i++ {
 			if i == extensionDot+1+dosExtNameLen {
 				// Long extension; only copy the first "dosExtNameLen" chars.
 				lossyConversion = true
 				break
 			}
 			nameExtDOS = append(nameExtDOS, nameDOSRaw[i])
 		}
 	}

 	if !lossyConversion {
 		// If there weren't any characters dropped, there is no room for generation numbers.
 		// A long name is only necessary if there were lowercase characters.
 		return composeDOSName(), containsLowercase, nil
 	}

 	maxGentextLen := 6
 	for gen := 1; ; gen++ {
 		gentext := strconv.Itoa(gen)
 		if len(gentext) > maxGentextLen {
 			// Given this filename, we have been unable to generate a corresponding short name.
 			return nil, false, errInvalidFilename
 		}
 		// If the nameMain component is too big, truncate.
 		tildeIndex := dosBaseNameLen - (len(gentext) + 1)
 		if len(nameBaseDOS) > tildeIndex {
 			nameBaseDOS = nameBaseDOS[:tildeIndex]
 		}

 		// The '~' is a special FAT character identifiying that the generator follows.
 		nameBaseDOS = append(nameBaseDOS, '~')
 		nameBaseDOS = append(nameBaseDOS, gentext[:]...)

 		// Verify the short name does not currently exist -- if it does, try using a different
 		// generation number.
 		shortName := composeDOSName()
 		if exists, err := doesShortNameExist(callback, shortName); err != nil {
 			return nil, false, err
 		} else if !exists {
 			return shortName, true, nil
 		}
 	}
 }

 // convertUnixToWin converts a unix filename to a Win95 long name directory entry.
 // This function also takes the short filename, which is used for checksumming purposes.
 //
 // Note: assumes that nameDOS is valid; assumes nameDOS was generated from nameUnix.
 func convertUnixToWin(nameUnix string, nameDOS []byte) ([]longDirentry, error) {
 	// "Leading and trailing spaces in a long name are ignored"
 	nameUnix = strings.Trim(nameUnix, " ")
 	// "Trailing periods are ignored"
 	nameUnix = strings.TrimRight(nameUnix, ".")

 	// Convert the UTF-8 Name to UCS-2 (the LFN format for FAT)
 	bufUCS2 := make([]rune, 0, len(nameUnix)/2)
 	for _, runeValue := range nameUnix {
 		bufUCS2 = append(bufUCS2, runeValue)
 	}
 	nameUCS2 := utf16.Encode(bufUCS2)
 	if longnameMaxLen < len(nameUCS2) {
 		return nil, errTooLong
 	}

 	// Iterate through the long direntries slice backwards to match the on-disk layout
 	longDirentries := make([]longDirentry, (len(nameUCS2)+longDirentLen-1)/longDirentLen)
 	dirIndex := len(longDirentries)
 	// Pre-calculate the checksum; it must be inserted into every long direntry component
 	chksum := checksum(nameDOS)
 	// True if the UCS2 name is finished being inserted into the collection of long direntries
 	end := false

 	for !end && len(nameUCS2) != 0 {
 		dirIndex--
 		longDirentries[dirIndex] = longDirentry{
 			count:      uint8(len(longDirentries) - dirIndex),
 			attributes: attrLongname,
 			reserved1:  0,
 			chksum:     uint8(chksum),
 		}
 		longDirentries[dirIndex].reserved2[0] = 0
 		longDirentries[dirIndex].reserved2[1] = 0

 		var nameUCS2Part []uint16
 		if longDirentLen <= len(nameUCS2) {
 			nameUCS2Part, nameUCS2 = nameUCS2[:longDirentLen], nameUCS2[longDirentLen:]
 		} else {
 			nameUCS2Part, nameUCS2 = nameUCS2, []uint16{}
 		}

 		// Now convert the filename parts
 		convFilenamePart := func(inputPart []uint16, outputPart []uint8, end bool) (newInput []uint16, newEnd bool) {
 			for i := 0; i < len(outputPart); i += 2 {
 				if len(inputPart) > 0 && end == false {
 					// There are characters left in the filename
 					var ucs2Char uint16
 					ucs2Char, inputPart = inputPart[0], inputPart[1:]
 					bitops.PutLE16(outputPart[i:i+2], ucs2Char)
 				} else if end == false {
 					// We JUST finished the filename -- insert the NULL terminator
 					bitops.PutLE16(outputPart[i:i+2], 0x0000)
 					end = true
 				} else {
 					// The NULL character has already been inserted. Pad with "0xFFFF"
 					bitops.PutLE16(outputPart[i:i+2], 0xFFFF)
 				}
 			}
 			return inputPart, end
 		}

 		nameUCS2Part, end = convFilenamePart(nameUCS2Part, longDirentries[dirIndex].name1[:], end)
 		nameUCS2Part, end = convFilenamePart(nameUCS2Part, longDirentries[dirIndex].name2[:], end)
 		nameUCS2Part, end = convFilenamePart(nameUCS2Part, longDirentries[dirIndex].name3[:], end)
 	}
 	longDirentries[0].count |= longLastEntry
 	return longDirentries, nil
 }

 // getShortEntryFromWin takes a long filename (via a callback) and accesses the short filename at the
 // end of the LFN components. Also return the number of slots necessary to represent the dirent on
 // disk.
 func getShortEntryFromWin(callback GetDirentryCallback, startIndex int) (shortEntry []byte, numDirentrySlots uint8, err error) {
 	buf, err := callback(startIndex)
 	if err != nil {
 		return nil, 0, err
 	}
 	dl := makeLong(buf)

 	if dl.count&longLastEntry == 0 {
 		return nil, 0, errLongDirentry
 	}
 	order := dl.count & longOrdinalMask
 	if order == 0 || maxLongDirentries < order {
 		return nil, 0, errLongDirentry
 	}

 	short, err := callback(startIndex + int(order))
 	if err != nil {
 		return nil, 0, err
 	}

 	return short, order + 1, nil
 }

 // convertWinToUnix reads long direntries, verifies them, and compiles them into a unix name.
 func convertWinToUnix(callback GetDirentryCallback, startIndex int, chksum uint8, highestOrder int) (nameUnix string, err error) {
 	order := 0
 	nameBuffer := make([]uint16, 0, longnameMaxLen)

 	// Iterate in reverse, so we can append to the namebuffer.
 	// The "highestOrder-1"-th entry should have an order of "1".
 	for direntryIndex := highestOrder - 1; direntryIndex >= 0; direntryIndex-- {
 		// Get the next long direntry component
 		buf, err := callback(startIndex + int(direntryIndex))
 		if err != nil {
 			return "", err
 		}
 		dl := makeLong(buf)

 		// Validate order, checksum
 		order = int(dl.count & longOrdinalMask)
 		if order != (highestOrder - direntryIndex) { // We must be reading in an increasing order
 			return "", errLongDirentry
 		} else if order > maxLongDirentries || order == 0 { // The order must be in bounds
 			return "", errLongDirentry
 		} else if order == highestOrder && (dl.count&longLastEntry == 0) { // The order MUST terminate at highest order
 			return "", errLongDirentry
 		} else if order != highestOrder && (dl.count&longLastEntry != 0) { // The order shouldn't terminate before that
 			return "", errLongDirentry
 		} else if chksum != dl.chksum {
 			return "", errChecksum
 		}

 		// Adds a component of the longDirentry to a name buffer.
 		// Returns "true" if a null terminator was seen, "false" otherwise.
 		convFilenamePart := func(part []uint8) (bool, error) {
 			for i := 0; i < len(part); i += 2 {
 				charWin := bitops.GetLE16(part[i : i+2])
 				switch charWin {
 				case 0:
 					// If the name is null terminated, stop writing to the namebuffer.
 					if order != highestOrder {
 						// Saw NULL terminator before reaching last order direntry
 						return false, errLongDirentry
 					}
 					return true, nil
 				case '/':
 					// Forward slashes are not allowed in unix filenames
 					return false, errInvalidFilename
 				default:
 					nameBuffer = append(nameBuffer, charWin)
 				}
 			}
 			return false, nil
 		}

 		if terminated, err := convFilenamePart(dl.name1[:]); err != nil {
 			return "", err
 		} else if terminated {
 			break
 		}
 		if terminated, err := convFilenamePart(dl.name2[:]); err != nil {
 			return "", err
 		} else if terminated {
 			break
 		}
 		if terminated, err := convFilenamePart(dl.name3[:]); err != nil {
 			return "", err
 		} else if terminated {
 			break
 		}
 	}

 	if order != highestOrder {
 		panic("Invalid internal order state while iterating; terminated before viewing all direntries")
 	}

 	result := string(utf16.Decode(nameBuffer))
 	if longnameMaxLen < len(result) {
 		return "", errTooLong
 	}
 	return result, nil
 }

 // Compute the unrolled checksum of a DOS filename for Win95 LFN use.
 func checksum(name []uint8) uint8 {
 	if len(name) != dosNameLen {
 		panic("Checksumming invalid short name")
 	}
 	var sum uint8
 	for i := 0; i < dosNameLen; i++ {
 		sum = ((sum & 1) << 7) + (sum >> 1) + name[i]
 	}
 	return sum
 }

 func charUnixToDOS(r rune) uint8 {
 	// ASCII Rune --> ASCII DOS character. Simple case.
 	if r < maxASCII {
 		return asciiFilter[r]
 	}
 	// Non-ASCII Unicode Rune --> Code page 850 character OR "replacement character"
 	if dosChar, ok := unicodeToDos[r]; ok {
 		return dosChar
 	}
 	return cRpl
 }

 func charDOSToUnix(b uint8) rune {
 	// ASCII DOS character to ASCII rune. Simple case.
 	if b < maxASCII {
 		r := asciiFilter[b]
 		switch r {
 		case cBad, cRpl, cSkp:
 			return rune('?')
 		default:
 			return rune(b)
 		}
 	}
 	return dosToUnicode[b-128]
 }
	// Copyright 2016 The Fuchsia Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	package direntry

	import (
	"errors"
	"strconv"
	"strings"
	"unicode/utf16"

	"thinfs/bitops"
	)

	const (
	cBad = 0 // Characters disallowed in both short and long filenames.
	cRpl = 1 // Characters +,;=[] should be replaced by '_', and a generation number MUST be used.
	cSkp = 2 // '.' or ' '. Skip this character.

	dosBaseNameLen = 8
	dosExtNameLen = 3
	dosNameLen = dosBaseNameLen + dosExtNameLen

	maxASCII = '\u007F' // Maximum ASCII value
	)

	var (
	errChecksum = errors.New("Invalid checksum")
	errTooLong = errors.New("Name too long")
	errInvalidFilename = errors.New("Invalid filename cannot be converted")
	errLongDirentry = errors.New("Invalid long direntry")
	)

	// Converts ASCII characters [0, 0x7F] to DOS "Code page 850" characters.
	var asciiFilter = [128]byte{
	cBad, cBad, cBad, cBad, cBad, cBad, cBad, cBad, /* 00-07 */
	cBad, cBad, cBad, cBad, cBad, cBad, cBad, cBad, /* 08-0f */
	cBad, cBad, cBad, cBad, cBad, cBad, cBad, cBad, /* 10-17 */
	cBad, cBad, cBad, cBad, cBad, cBad, cBad, cBad, /* 18-1f */
	cSkp, 0x21, cBad, 0x23, 0x24, 0x25, 0x26, 0x27, /* 20-27 */
	0x28, 0x29, cBad, cRpl, cRpl, 0x2d, cSkp, cBad, /* 28-2f */
	0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, /* 30-37 */
	0x38, 0x39, cBad, cRpl, cBad, cRpl, cBad, cBad, /* 38-3f */
	0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, /* 40-47 */
	0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, /* 48-4f */
	0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, /* 50-57 */
	0x58, 0x59, 0x5a, cRpl, cBad, cRpl, 0x5e, 0x5f, /* 58-5f */
	0x60, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, /* 60-67 */
	0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, /* 68-6f */
	0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, /* 70-77 */
	0x58, 0x59, 0x5a, 0x7b, cBad, 0x7d, 0x7e, cBad, /* 78-7f */
	}

	// Converts some unicode characters to DOS "Code page 850" characters.
	var unicodeToDos = map[rune]byte{
	'\u00C7': 0x80, '\u00FC': 0x81, '\u00E9': 0x82, '\u00E2': 0x83, '\u00E4': 0x84, '\u00E0': 0x85, '\u00E5': 0x86, '\u00E7': 0x87,
	'\u00EA': 0x88, '\u00EB': 0x89, '\u00E8': 0x8A, '\u00EF': 0x8B, '\u00EE': 0x8C, '\u00EC': 0x8D, '\u00C4': 0x8E, '\u00C5': 0x8F,
	'\u00C9': 0x90, '\u00E6': 0x91, '\u00C6': 0x92, '\u00F4': 0x93, '\u00F6': 0x94, '\u00F2': 0x95, '\u00FB': 0x96, '\u00F9': 0x97,
	'\u00FF': 0x98, '\u00D6': 0x99, '\u00DC': 0x9A, '\u00F8': 0x9B, '\u00A3': 0x9C, '\u00D8': 0x9D, '\u00D7': 0x9E, '\u0192': 0x9F,
	'\u00E1': 0xA0, '\u00ED': 0xA1, '\u00F3': 0xA2, '\u00FA': 0xA3, '\u00F1': 0xA4, '\u00D1': 0xA5, '\u00AA': 0xA6, '\u00BA': 0xA7,
	'\u00BF': 0xA8, '\u00AE': 0xA9, '\u00AC': 0xAA, '\u00BD': 0xAB, '\u00BC': 0xAC, '\u00A1': 0xAD, '\u00AB': 0xAE, '\u00BB': 0xAF,
	'\u2591': 0xB0, '\u2592': 0xB1, '\u2593': 0xB2, '\u2502': 0xB3, '\u2524': 0xB4, '\u00C1': 0xB5, '\u00C2': 0xB6, '\u00C0': 0xB7,
	'\u00A9': 0xB8, '\u2563': 0xB9, '\u2551': 0xBA, '\u2557': 0xBB, '\u255D': 0xBC, '\u00A2': 0xBD, '\u00A5': 0xBE, '\u2510': 0xBF,
	'\u2514': 0xC0, '\u2534': 0xC1, '\u252C': 0xC2, '\u251C': 0xC3, '\u2500': 0xC4, '\u253C': 0xC5, '\u00E3': 0xC6, '\u00C3': 0xC7,
	'\u255A': 0xC8, '\u2554': 0xC9, '\u2569': 0xCA, '\u2566': 0xCB, '\u2560': 0xCC, '\u2550': 0xCD, '\u256C': 0xCE, '\u00A4': 0xCF,
	'\u00F0': 0xD0, '\u00D0': 0xD1, '\u00CA': 0xD2, '\u00CB': 0xD3, '\u00C8': 0xD4, '\u0131': 0xD5, '\u00CD': 0xD6, '\u00CE': 0xD7,
	'\u00CF': 0xD8, '\u2518': 0xD9, '\u250C': 0xDA, '\u2588': 0xDB, '\u2584': 0xDC, '\u00A6': 0xDD, '\u00CC': 0xDE, '\u2580': 0xDF,
	'\u00D3': 0xE0, '\u00DF': 0xE1, '\u00D4': 0xE2, '\u00D2': 0xE3, '\u00F5': 0xE4, '\u00D5': 0xE5, '\u00B5': 0xE6, '\u00FE': 0xE7,
	'\u00DE': 0xE8, '\u00DA': 0xE9, '\u00DB': 0xEA, '\u00D9': 0xEB, '\u00FD': 0xEC, '\u00DD': 0xED, '\u00AF': 0xEE, '\u00B4': 0xEF,
	'\u00AD': 0xF0, '\u00B1': 0xF1, '\u2017': 0xF2, '\u00BE': 0xF3, '\u00B6': 0xF4, '\u00A7': 0xF5, '\u00F7': 0xF6, '\u00B8': 0xF7,
	'\u00B0': 0xF8, '\u00A8': 0xF9, '\u00B7': 0xFA, '\u00B9': 0xFB, '\u00B3': 0xFC, '\u00B2': 0xFD, '\u25A0': 0xFE, '\u00A0': 0xFF,
	}

	// Converts DOS "Code page 850" characters in range [0x80, 0xFF] to Unicode runes.
	var dosToUnicode = [128]rune{
	'\u00C7', '\u00FC', '\u00E9', '\u00E2', '\u00E4', '\u00E0', '\u00E5', '\u00E7',
	'\u00EA', '\u00EB', '\u00E8', '\u00EF', '\u00EE', '\u00EC', '\u00C4', '\u00C5',
	'\u00C9', '\u00E6', '\u00C6', '\u00F4', '\u00F6', '\u00F2', '\u00FB', '\u00F9',
	'\u00FF', '\u00D6', '\u00DC', '\u00F8', '\u00A3', '\u00D8', '\u00D7', '\u0192',
	'\u00E1', '\u00ED', '\u00F3', '\u00FA', '\u00F1', '\u00D1', '\u00AA', '\u00BA',
	'\u00BF', '\u00AE', '\u00AC', '\u00BD', '\u00BC', '\u00A1', '\u00AB', '\u00BB',
	'\u2591', '\u2592', '\u2593', '\u2502', '\u2524', '\u00C1', '\u00C2', '\u00C0',
	'\u00A9', '\u2563', '\u2551', '\u2557', '\u255D', '\u00A2', '\u00A5', '\u2510',
	'\u2514', '\u2534', '\u252C', '\u251C', '\u2500', '\u253C', '\u00E3', '\u00C3',
	'\u255A', '\u2554', '\u2569', '\u2566', '\u2560', '\u2550', '\u256C', '\u00A4',
	'\u00F0', '\u00D0', '\u00CA', '\u00CB', '\u00C8', '\u0131', '\u00CD', '\u00CE',
	'\u00CF', '\u2518', '\u250C', '\u2588', '\u2584', '\u00A6', '\u00CC', '\u2580',
	'\u00D3', '\u00DF', '\u00D4', '\u00D2', '\u00F5', '\u00D5', '\u00B5', '\u00FE',
	'\u00DE', '\u00DA', '\u00DB', '\u00D9', '\u00FD', '\u00DD', '\u00AF', '\u00B4',
	'\u00AD', '\u00B1', '\u2017', '\u00BE', '\u00B6', '\u00A7', '\u00F7', '\u00B8',
	'\u00B0', '\u00A8', '\u00B7', '\u00B9', '\u00B3', '\u00B2', '\u25A0', '\u00A0',
	}

	// DOS filenames consist of:
	// 1) The "name" part ("FOO" from "FOO.TXT"), which is 8 characters long.
	// 2) The "extension part ("TXT" from "FOO.TXT"), which is 3 characters long.
	//
	// Both parts may contain trailing spaces if the filename component does not use the maximum
	// allocated space.

	// convertDOSToUnix converts a DOS filename (single byte, cp850 encoding) to a UTF-8 encoded string.
	func convertDOSToUnix(nameDOS []byte, lowercase bool) string {
	if len(nameDOS) != dosNameLen {
	panic("Unexpected convertDOSToUnix name len: ")
	}

	switch string(nameDOS) {
	case ". ":
	return "."
	case ".. ":
	return ".."
	}

	nameUnix := make([]rune, 0, dosNameLen+1)
	for i := 0; i < dosBaseNameLen && nameDOS[i] != ' '; i++ {
	charDOS := nameDOS[i]
	if i == 0 {
	switch charDOS {
	case charE5:
	// "If DIR_Name[0] == 0x05 (SLOT_E5), then the actual file name character for this
	// byte is 0xE5". 0xE5 is reserved to mean "free entry". DOS quirk.
	charDOS = 0xE5
	case charLastFree, charFree:
	// Free entries do not have filenames
	return ""
	}
	}
	nameUnix = append(nameUnix, charDOSToUnix(charDOS))
	}

	// Jump to the extension.
	extStartIndex := dosBaseNameLen
	if nameDOS[extStartIndex] != ' ' {
	// Add a '.' if an extension exists, then add the extension itself.
	nameUnix = append(nameUnix, '.')
	for i := extStartIndex; i < dosNameLen && nameDOS[i] != ' '; i++ {
	nameUnix = append(nameUnix, charDOSToUnix(nameDOS[i]))
	}
	}

	// By default, DOS strings are uppercase. Conditionally convert them to lowercase.
	if lowercase {
	return strings.ToLower(string(nameUnix))
	}
	// DOS strings should not be stored as anything other than uppercase, but just in case, convert
	// it to uppercase.
	return strings.ToUpper(string(nameUnix))
	}

	// convertUnixToDOS converts a unix filename to a DOS filename according to Win95 rules.
	// This function implements the "Basis-Name Generation Algorithm" and "Numeric-Tail Generation
	// Algorithm" described in the FAT documentation.
	//
	// The resulting filename may either be a short name (which should be paired with a long filename)
	// a short name (which should not be paired with a long filename), or empty (due to an error).
	func convertUnixToDOS(callback GetDirentryCallback, nameUnix string) (nameDOS []byte, longnameNeeded bool, err error) {
	// "The UNICODE name passed to the file system is converted to upper case."
	containsLowercase := false
	nameUnixUpper := strings.ToUpper(nameUnix)
	if nameUnix != nameUnixUpper {
	containsLowercase = true
	}
	nameUnix = nameUnixUpper

	nameBaseDOS := make([]byte, 0, dosBaseNameLen)
	nameExtDOS := make([]byte, 0, dosExtNameLen)

	// Wraps up both the "Main" and "Extension" parts of the name into one slice.
	composeDOSName := func() []byte {
	// Add spacing to main and ext.
	for len(nameBaseDOS) < dosBaseNameLen {
	nameBaseDOS = append(nameBaseDOS, ' ')
	}
	for len(nameExtDOS) < dosExtNameLen {
	nameExtDOS = append(nameExtDOS, ' ')
	}

	// This is a DOS-ism. 'E5' is reserved for charFree, but '05' means this byte should later
	// be replaced with 'E5'.
	if nameBaseDOS[0] == charFree {
	nameBaseDOS[0] = charE5
	}
	res := append(nameBaseDOS, nameExtDOS...)
	return res
	}

	// The filenames "." and ".." are handled specially, since they don't follow DOS filename rules.
	if string(nameUnix) == "." {
	nameBaseDOS = append(nameBaseDOS, '.')
	return composeDOSName(), false, nil
	}
	if string(nameUnix) == ".." {
	nameBaseDOS = append(nameBaseDOS, '.', '.')
	return composeDOSName(), false, nil
	}

	// Skip all trailing spaces and dots (they are ignored in both short and long names).
	nameUnix = strings.TrimRight(nameUnix, " .")
	if nameUnix == "" {
	// Filenames cannot contain EXCLUSIVELY spaces and dots.
	return nil, false, errInvalidFilename
	}

	// Convert the upper-case unicode name to cp850.
	nameDOSRaw := make([]byte, 0, len(nameUnix))
	// "lossyConversion" indicates that we may have left some characters behind that would have fit
	// in a long name.
	lossyConversion := false
	leadingPeriods := true
	for i, runeValue := range nameUnix {
	c := charUnixToDOS(runeValue)
	switch c {
	case cRpl:
	nameDOSRaw = append(nameDOSRaw, '_')
	leadingPeriods = false
	lossyConversion = true
	case cSkp:
	if nameUnix[i] == '.' {
	if leadingPeriods { // Should be stored in long names, but not short names.
	lossyConversion = true
	} else { // For now, insert all non-leading/trailing '.' chars. Only one will be used.
	nameDOSRaw = append(nameDOSRaw, '.')
	}
	} else {
	// We always skip spaces for short DOS names.
	lossyConversion = true
	}
	case cBad:
	return nil, false, errInvalidFilename
	default:
	// Copy the converted character.
	nameDOSRaw = append(nameDOSRaw, c)
	leadingPeriods = false
	}
	}

	// Find the last non-trailing '.' character (the extension dot).
	var extensionDot int
	for extensionDot = len(nameDOSRaw) - 1; extensionDot >= 0; extensionDot-- {
	if nameDOSRaw[extensionDot] == '.' {
	break
	}
	}
	// ExtensionDot will be "-1" if it does not exist.

	// Copy the 'base' part of the name.
	for i := range nameDOSRaw {
	if i == extensionDot {
	// Copy everything up to the extension.
	break
	}
	if i == dosBaseNameLen {
	// Only copy up to "dosBaseNameLen" characters.
	lossyConversion = true
	break
	}
	charDOS := nameDOSRaw[i]
	if charDOS == '.' {
	// We're losing an inner '.' character.
	lossyConversion = true
	} else {
	nameBaseDOS = append(nameBaseDOS, charDOS)
	}
	}

	// If the extension exists...
	if extensionDot != -1 {
	// ... copy the 'extension' part of the name.
	for i := extensionDot + 1; i < len(nameDOSRaw); i++ {
	if i == extensionDot+1+dosExtNameLen {
	// Long extension; only copy the first "dosExtNameLen" chars.
	lossyConversion = true
	break
	}
	nameExtDOS = append(nameExtDOS, nameDOSRaw[i])
	}
	}

	if !lossyConversion {
	// If there weren't any characters dropped, there is no room for generation numbers.
	// A long name is only necessary if there were lowercase characters.
	return composeDOSName(), containsLowercase, nil
	}

	maxGentextLen := 6
	for gen := 1; ; gen++ {
	gentext := strconv.Itoa(gen)
	if len(gentext) > maxGentextLen {
	// Given this filename, we have been unable to generate a corresponding short name.
	return nil, false, errInvalidFilename
	}
	// If the nameMain component is too big, truncate.
	tildeIndex := dosBaseNameLen - (len(gentext) + 1)
	if len(nameBaseDOS) > tildeIndex {
	nameBaseDOS = nameBaseDOS[:tildeIndex]
	}

	// The '~' is a special FAT character identifiying that the generator follows.
	nameBaseDOS = append(nameBaseDOS, '~')
	nameBaseDOS = append(nameBaseDOS, gentext[:]...)

	// Verify the short name does not currently exist -- if it does, try using a different
	// generation number.
	shortName := composeDOSName()
	if exists, err := doesShortNameExist(callback, shortName); err != nil {
	return nil, false, err
	} else if !exists {
	return shortName, true, nil
	}
	}
	}

	// convertUnixToWin converts a unix filename to a Win95 long name directory entry.
	// This function also takes the short filename, which is used for checksumming purposes.
	//
	// Note: assumes that nameDOS is valid; assumes nameDOS was generated from nameUnix.
	func convertUnixToWin(nameUnix string, nameDOS []byte) ([]longDirentry, error) {
	// "Leading and trailing spaces in a long name are ignored"
	nameUnix = strings.Trim(nameUnix, " ")
	// "Trailing periods are ignored"
	nameUnix = strings.TrimRight(nameUnix, ".")

	// Convert the UTF-8 Name to UCS-2 (the LFN format for FAT)
	bufUCS2 := make([]rune, 0, len(nameUnix)/2)
	for _, runeValue := range nameUnix {
	bufUCS2 = append(bufUCS2, runeValue)
	}
	nameUCS2 := utf16.Encode(bufUCS2)
	if longnameMaxLen < len(nameUCS2) {
	return nil, errTooLong
	}

	// Iterate through the long direntries slice backwards to match the on-disk layout
	longDirentries := make([]longDirentry, (len(nameUCS2)+longDirentLen-1)/longDirentLen)
	dirIndex := len(longDirentries)
	// Pre-calculate the checksum; it must be inserted into every long direntry component
	chksum := checksum(nameDOS)
	// True if the UCS2 name is finished being inserted into the collection of long direntries
	end := false

	for !end && len(nameUCS2) != 0 {
	dirIndex--
	longDirentries[dirIndex] = longDirentry{
	count: uint8(len(longDirentries) - dirIndex),
	attributes: attrLongname,
	reserved1: 0,
	chksum: uint8(chksum),
	}
	longDirentries[dirIndex].reserved2[0] = 0
	longDirentries[dirIndex].reserved2[1] = 0

	var nameUCS2Part []uint16
	if longDirentLen <= len(nameUCS2) {
	nameUCS2Part, nameUCS2 = nameUCS2[:longDirentLen], nameUCS2[longDirentLen:]
	} else {
	nameUCS2Part, nameUCS2 = nameUCS2, []uint16{}
	}

	// Now convert the filename parts
	convFilenamePart := func(inputPart []uint16, outputPart []uint8, end bool) (newInput []uint16, newEnd bool) {
	for i := 0; i < len(outputPart); i += 2 {
	if len(inputPart) > 0 && end == false {
	// There are characters left in the filename
	var ucs2Char uint16
	ucs2Char, inputPart = inputPart[0], inputPart[1:]
	bitops.PutLE16(outputPart[i:i+2], ucs2Char)
	} else if end == false {
	// We JUST finished the filename -- insert the NULL terminator
	bitops.PutLE16(outputPart[i:i+2], 0x0000)
	end = true
	} else {
	// The NULL character has already been inserted. Pad with "0xFFFF"
	bitops.PutLE16(outputPart[i:i+2], 0xFFFF)
	}
	}
	return inputPart, end
	}

	nameUCS2Part, end = convFilenamePart(nameUCS2Part, longDirentries[dirIndex].name1[:], end)
	nameUCS2Part, end = convFilenamePart(nameUCS2Part, longDirentries[dirIndex].name2[:], end)
	nameUCS2Part, end = convFilenamePart(nameUCS2Part, longDirentries[dirIndex].name3[:], end)
	}
	longDirentries[0].count \|= longLastEntry
	return longDirentries, nil
	}

	// getShortEntryFromWin takes a long filename (via a callback) and accesses the short filename at the
	// end of the LFN components. Also return the number of slots necessary to represent the dirent on
	// disk.
	func getShortEntryFromWin(callback GetDirentryCallback, startIndex int) (shortEntry []byte, numDirentrySlots uint8, err error) {
	buf, err := callback(startIndex)
	if err != nil {
	return nil, 0, err
	}
	dl := makeLong(buf)

	if dl.count&longLastEntry == 0 {
	return nil, 0, errLongDirentry
	}
	order := dl.count & longOrdinalMask
	if order == 0 \|\| maxLongDirentries < order {
	return nil, 0, errLongDirentry
	}

	short, err := callback(startIndex + int(order))
	if err != nil {
	return nil, 0, err
	}

	return short, order + 1, nil
	}

	// convertWinToUnix reads long direntries, verifies them, and compiles them into a unix name.
	func convertWinToUnix(callback GetDirentryCallback, startIndex int, chksum uint8, highestOrder int) (nameUnix string, err error) {
	order := 0
	nameBuffer := make([]uint16, 0, longnameMaxLen)

	// Iterate in reverse, so we can append to the namebuffer.
	// The "highestOrder-1"-th entry should have an order of "1".
	for direntryIndex := highestOrder - 1; direntryIndex >= 0; direntryIndex-- {
	// Get the next long direntry component
	buf, err := callback(startIndex + int(direntryIndex))
	if err != nil {
	return "", err
	}
	dl := makeLong(buf)

	// Validate order, checksum
	order = int(dl.count & longOrdinalMask)
	if order != (highestOrder - direntryIndex) { // We must be reading in an increasing order
	return "", errLongDirentry
	} else if order > maxLongDirentries \|\| order == 0 { // The order must be in bounds
	return "", errLongDirentry
	} else if order == highestOrder && (dl.count&longLastEntry == 0) { // The order MUST terminate at highest order
	return "", errLongDirentry
	} else if order != highestOrder && (dl.count&longLastEntry != 0) { // The order shouldn't terminate before that
	return "", errLongDirentry
	} else if chksum != dl.chksum {
	return "", errChecksum
	}

	// Adds a component of the longDirentry to a name buffer.
	// Returns "true" if a null terminator was seen, "false" otherwise.
	convFilenamePart := func(part []uint8) (bool, error) {
	for i := 0; i < len(part); i += 2 {
	charWin := bitops.GetLE16(part[i : i+2])
	switch charWin {
	case 0:
	// If the name is null terminated, stop writing to the namebuffer.
	if order != highestOrder {
	// Saw NULL terminator before reaching last order direntry
	return false, errLongDirentry
	}
	return true, nil
	case '/':
	// Forward slashes are not allowed in unix filenames
	return false, errInvalidFilename
	default:
	nameBuffer = append(nameBuffer, charWin)
	}
	}
	return false, nil
	}

	if terminated, err := convFilenamePart(dl.name1[:]); err != nil {
	return "", err
	} else if terminated {
	break
	}
	if terminated, err := convFilenamePart(dl.name2[:]); err != nil {
	return "", err
	} else if terminated {
	break
	}
	if terminated, err := convFilenamePart(dl.name3[:]); err != nil {
	return "", err
	} else if terminated {
	break
	}
	}

	if order != highestOrder {
	panic("Invalid internal order state while iterating; terminated before viewing all direntries")
	}

	result := string(utf16.Decode(nameBuffer))
	if longnameMaxLen < len(result) {
	return "", errTooLong
	}
	return result, nil
	}

	// Compute the unrolled checksum of a DOS filename for Win95 LFN use.
	func checksum(name []uint8) uint8 {
	if len(name) != dosNameLen {
	panic("Checksumming invalid short name")
	}
	var sum uint8
	for i := 0; i < dosNameLen; i++ {
	sum = ((sum & 1) << 7) + (sum >> 1) + name[i]
	}
	return sum
	}

	func charUnixToDOS(r rune) uint8 {
	// ASCII Rune --> ASCII DOS character. Simple case.
	if r < maxASCII {
	return asciiFilter[r]
	}
	// Non-ASCII Unicode Rune --> Code page 850 character OR "replacement character"
	if dosChar, ok := unicodeToDos[r]; ok {
	return dosChar
	}
	return cRpl
	}

	func charDOSToUnix(b uint8) rune {
	// ASCII DOS character to ASCII rune. Simple case.
	if b < maxASCII {
	r := asciiFilter[b]
	switch r {
	case cBad, cRpl, cSkp:
	return rune('?')
	default:
	return rune(b)
	}
	}
	return dosToUnicode[b-128]
	}