modules/charset_macosxfs.c

ソースコードを見る。

関数
static void *	resize_buffer (void *buffer, size_t *size, size_t newsize)
static void	swap_bytes (char *dst, const char *src, size_t len)
static void	swap_bytes_inplace (char *cp, size_t len)
static UniChar *	set_ucbuffer_with_le_copy (UniChar *buffer, size_t *bufsize, const void *data, size_t size, size_t reserve)
static void	hexdump (const char *label, const char *s, size_t len)
static size_t	macosxfs_encoding_pull (void *cd, char **inbuf, size_t *inbytesleft, char **outbuf, size_t *outbytesleft)
static size_t	macosxfs_encoding_push (void *cd, char **inbuf, size_t *inbytesleft, char **outbuf, size_t *outbytesleft)
NTSTATUS	charset_macosxfs_init (void)
変数
static struct charset_functions	macosxfs_encoding_functions

---

関数

static void* resize_buffer	(	void *	buffer,
		size_t *	size,
		size_t	newsize
	)			[inline, static]

charset_macosxfs.c の 61 行で定義されています。

参照元 macosxfs_encoding_pull()・set_ucbuffer_with_le_copy().

{
        if (newsize > *size) {
                *size = newsize + 128;
                buffer = SMB_REALLOC(buffer, *size);
        }
        return buffer;
}

static void swap_bytes	(	char *	dst,
		const char *	src,
		size_t	len
	)			[inline, static]

charset_macosxfs.c の 87 行で定義されています。

{
        const char *srcend = src + len;
        while (src < srcend) {
                dst[0] = src[1];
                dst[1] = src[0];
                dst += 2;
                src += 2;
        }
}

static void swap_bytes_inplace	(	char *	cp,
		size_t	len
	)			[inline, static]

charset_macosxfs.c の 97 行で定義されています。

{
        char temp;
        char *end = cp + len;
        while (cp  < end) {
                temp = cp[1];
                cp[1] = cp[0];
                cp[0] = temp;
                cp += 2;
        }
}

static UniChar* set_ucbuffer_with_le_copy	(	UniChar *	buffer,
		size_t *	bufsize,
		const void *	data,
		size_t	size,
		size_t	reserve
	)			[inline, static]

charset_macosxfs.c の 123 行で定義されています。

参照先 resize_buffer().

参照元 macosxfs_encoding_push().

{
        buffer = resize_buffer(buffer, bufsize, size+reserve);
        le_to_native((char*)buffer,data,size);
        return buffer;
}

static void hexdump	(	const char *	label,
		const char *	s,
		size_t	len
	)			[static]

charset_macosxfs.c の 140 行で定義されています。

参照先 line・sprintf().

参照元 macosxfs_encoding_pull()・macosxfs_encoding_push().

{
        size_t restlen = len;
        debug_out("<<<<<<<\n");
        debug_out(label);
        debug_out("\n");
        while (restlen > 0) {
                char line[100];
                size_t i, j;
                char * d = line;
#undef sprintf
                d += sprintf(d, "%04X ", (unsigned)(len-restlen));
                *d++ = ' ';
                for( i = 0; i<restlen && i<8; ++i ) {
                        d += sprintf(d, "%02X ", ((unsigned)s[i]) & 0xFF);
                }
                for( j = i; j<8; ++j ) {
                        d += sprintf(d, "   ");
                }
                *d++ = ' ';
                for( i = 8; i<restlen && i<16; ++i ) {
                        d += sprintf(d, "%02X ", ((unsigned)s[i]) & 0xFF);
                }
                for( j = i; j<16; ++j ) {
                        d += sprintf(d, "   ");
                }
                *d++ = ' ';
                for( i = 0; i<restlen && i<16; ++i ) {
                        if(s[i] < ' ' || s[i] >= 0x7F || !isprint(s[i]))
                                *d++ = '.';
                        else
                                *d++ = s[i];
                }
                *d++ = '\n';
                *d = 0;
                restlen -= i;
                s += i;
                debug_out(line);
        }
        debug_out(">>>>>>>\n");
}

static size_t macosxfs_encoding_pull	(	void *	cd,
		char **	inbuf,
		size_t *	inbytesleft,
		char **	outbuf,
		size_t *	outbytesleft
	)			[static]

charset_macosxfs.c の 204 行で定義されています。

参照先 errno・hexdump()・resize_buffer().

{
        static const int script_code = kCFStringEncodingUTF8;
        static CFMutableStringRef cfstring = NULL;
        size_t outsize;
        CFRange range;

        (void) cd; /* UNUSED */

        if (0 == *inbytesleft) {
                return 0;
        }

        if (NULL == cfstring) {
                /*
                 * A version with an external backing store as in the
                 * push function should have been more efficient, but
                 * testing shows, that it is actually slower (!).
                 * Maybe kCFAllocatorDefault gets shortcut evaluation
                 * internally, while kCFAllocatorNull doesn't.
                 */
                cfstring = CFStringCreateMutable(kCFAllocatorDefault,0);
        }

        /*
         * Three methods of appending to a CFString, choose the most
         * efficient.
         */
        if (0 == (*inbuf)[*inbytesleft-1]) {
                CFStringAppendCString(cfstring, *inbuf, script_code);
        } else if (*inbytesleft <= 255) {
                Str255 buffer;
                buffer[0] = *inbytesleft;
                memcpy(buffer+1, *inbuf, buffer[0]);
                CFStringAppendPascalString(cfstring, buffer, script_code);
        } else {
                /*
                 * We would like to use a fixed buffer and a loop
                 * here, but than we can't garantee that the input is
                 * well-formed UTF-8, as we are supposed to do.
                 */
                static char *buffer = NULL;
                static size_t buflen = 0;
                buffer = resize_buffer(buffer, &buflen, *inbytesleft+1);
                memcpy(buffer, *inbuf, *inbytesleft);
                buffer[*inbytesleft] = 0;
                CFStringAppendCString(cfstring, *inbuf, script_code);
        }

        /*
         * Compose characters, using the non-canonical composition
         * form.
         */
        CFStringNormalize(cfstring, kCFStringNormalizationFormC);

        outsize = CFStringGetLength(cfstring);
        range = CFRangeMake(0,outsize);

        if (outsize == 0) {
                /*
                 * HACK: smbd/mangle_hash2.c:is_legal_name() expects
                 * errors here.  That function will always pass 2
                 * characters.  smbd/open.c:check_for_pipe() cuts a
                 * patchname to 10 characters blindly.  Suppress the
                 * debug output in those cases.
                 */
                if(2 != *inbytesleft && 10 != *inbytesleft) {
                        debug_out("String conversion: "
                                  "An unknown error occurred\n");
                        hexdump("UTF8->UTF16LE (old) input",
                                *inbuf, *inbytesleft);
                }
                errno = EILSEQ; /* Not sure, but this is what we have
                                 * actually seen. */
                return -1;
        }
        if (outsize*2 > *outbytesleft) {
                CFStringDelete(cfstring, range);
                debug_out("String conversion: "
                          "Output buffer too small\n");
                hexdump("UTF8->UTF16LE (old) input",
                        *inbuf, *inbytesleft);
                errno = E2BIG;
                return -1;
        }

        CFStringGetCharacters(cfstring, range, (UniChar*)*outbuf);
        CFStringDelete(cfstring, range);

        native_to_le(*outbuf, outsize*2);

        /*
         * Add a converted null byte, if the CFString conversions
         * prevented that until now.
         */
        if (0 == (*inbuf)[*inbytesleft-1] && 
            (0 != (*outbuf)[outsize*2-1] || 0 != (*outbuf)[outsize*2-2])) {

                if ((outsize*2+2) > *outbytesleft) {
                        debug_out("String conversion: "
                                  "Output buffer too small\n");
                        hexdump("UTF8->UTF16LE (old) input",
                                *inbuf, *inbytesleft);
                        errno = E2BIG;
                        return -1;
                }

                (*outbuf)[outsize*2] = (*outbuf)[outsize*2+1] = 0;
                outsize += 2;
        }

        *inbuf += *inbytesleft;
        *inbytesleft = 0;
        *outbuf += outsize*2;
        *outbytesleft -= outsize*2;

        return 0;
}

static size_t macosxfs_encoding_push	(	void *	cd,
		char **	inbuf,
		size_t *	inbytesleft,
		char **	outbuf,
		size_t *	outbytesleft
	)			[static]

charset_macosxfs.c の 326 行で定義されています。

参照先 errno・hexdump()・set_ucbuffer_with_le_copy().

{
        static const int script_code = kCFStringEncodingUTF8;
        static CFMutableStringRef cfstring = NULL;
        static UniChar *buffer = NULL;
        static size_t buflen = 0;
        CFIndex outsize, cfsize, charsconverted;

        (void) cd; /* UNUSED */

        if (0 == *inbytesleft) {
                return 0;
        }

        /*
         * We need a buffer that can hold 4 times the original data,
         * because that is the theoretical maximum that decomposition
         * can create currently (in Unicode 4.0).
         */
        buffer = set_ucbuffer_with_le_copy(
                buffer, &buflen, *inbuf, *inbytesleft, 3 * *inbytesleft);

        if (NULL == cfstring) {
                cfstring = CFStringCreateMutableWithExternalCharactersNoCopy(
                        kCFAllocatorDefault,
                        buffer, *inbytesleft/2, buflen/2,
                        kCFAllocatorNull);
        } else {
                CFStringSetExternalCharactersNoCopy(
                        cfstring,
                        buffer, *inbytesleft/2, buflen/2);
        }

        /*
         * Decompose characters, using the non-canonical decomposition
         * form.
         *
         * NB: This isn't exactly what HFS+ wants (see note on
         * kCFStringEncodingUseHFSPlusCanonical in
         * CFStringEncodingConverter.h), but AFAIK it's the best that
         * the official API can do.
         */
        CFStringNormalize(cfstring, kCFStringNormalizationFormD);

        cfsize = CFStringGetLength(cfstring);
        charsconverted = CFStringGetBytes(
                cfstring, CFRangeMake(0,cfsize),
                script_code, 0, False,
                *outbuf, *outbytesleft, &outsize);

        if (0 == charsconverted) {
                debug_out("String conversion: "
                          "Buffer too small or not convertable\n");
                hexdump("UTF16LE->UTF8 (old) input",
                        *inbuf, *inbytesleft);
                errno = EILSEQ; /* Probably more likely. */
                return -1;
        }

        /*
         * Add a converted null byte, if the CFString conversions
         * prevented that until now.
         */
        if (0 == (*inbuf)[*inbytesleft-1] && 0 == (*inbuf)[*inbytesleft-2] &&
            (0 != (*outbuf)[outsize-1])) {

                if (((size_t)outsize+1) > *outbytesleft) {
                        debug_out("String conversion: "
                                  "Output buffer too small\n");
                        hexdump("UTF16LE->UTF8 (old) input",
                                *inbuf, *inbytesleft);
                        errno = E2BIG;
                        return -1;
                }

                (*outbuf)[outsize] = 0;
                ++outsize;
        }

        *inbuf += *inbytesleft;
        *inbytesleft = 0;
        *outbuf += outsize;
        *outbytesleft -= outsize;

        return 0;
}

NTSTATUS charset_macosxfs_init

(

void

)

charset_macosxfs.c の 597 行で定義されています。

参照先 macosxfs_encoding_functions・smb_register_charset().

{
        return smb_register_charset(&macosxfs_encoding_functions);
}

---

変数

struct charset_functions macosxfs_encoding_functions [static]

初期値:

 {
        "MACOSXFS", macosxfs_encoding_pull, macosxfs_encoding_push
}

charset_macosxfs.c の 593 行で定義されています。

参照元 charset_macosxfs_init().

---