Loading...
1#include <linux/ucs2_string.h>
2#include <linux/module.h>
3
4/* Return the number of unicode characters in data */
5unsigned long
6ucs2_strnlen(const ucs2_char_t *s, size_t maxlength)
7{
8 unsigned long length = 0;
9
10 while (*s++ != 0 && length < maxlength)
11 length++;
12 return length;
13}
14EXPORT_SYMBOL(ucs2_strnlen);
15
16unsigned long
17ucs2_strlen(const ucs2_char_t *s)
18{
19 return ucs2_strnlen(s, ~0UL);
20}
21EXPORT_SYMBOL(ucs2_strlen);
22
23/*
24 * Return the number of bytes is the length of this string
25 * Note: this is NOT the same as the number of unicode characters
26 */
27unsigned long
28ucs2_strsize(const ucs2_char_t *data, unsigned long maxlength)
29{
30 return ucs2_strnlen(data, maxlength/sizeof(ucs2_char_t)) * sizeof(ucs2_char_t);
31}
32EXPORT_SYMBOL(ucs2_strsize);
33
34int
35ucs2_strncmp(const ucs2_char_t *a, const ucs2_char_t *b, size_t len)
36{
37 while (1) {
38 if (len == 0)
39 return 0;
40 if (*a < *b)
41 return -1;
42 if (*a > *b)
43 return 1;
44 if (*a == 0) /* implies *b == 0 */
45 return 0;
46 a++;
47 b++;
48 len--;
49 }
50}
51EXPORT_SYMBOL(ucs2_strncmp);
52
53unsigned long
54ucs2_utf8size(const ucs2_char_t *src)
55{
56 unsigned long i;
57 unsigned long j = 0;
58
59 for (i = 0; src[i]; i++) {
60 u16 c = src[i];
61
62 if (c >= 0x800)
63 j += 3;
64 else if (c >= 0x80)
65 j += 2;
66 else
67 j += 1;
68 }
69
70 return j;
71}
72EXPORT_SYMBOL(ucs2_utf8size);
73
74/*
75 * copy at most maxlength bytes of whole utf8 characters to dest from the
76 * ucs2 string src.
77 *
78 * The return value is the number of characters copied, not including the
79 * final NUL character.
80 */
81unsigned long
82ucs2_as_utf8(u8 *dest, const ucs2_char_t *src, unsigned long maxlength)
83{
84 unsigned int i;
85 unsigned long j = 0;
86 unsigned long limit = ucs2_strnlen(src, maxlength);
87
88 for (i = 0; maxlength && i < limit; i++) {
89 u16 c = src[i];
90
91 if (c >= 0x800) {
92 if (maxlength < 3)
93 break;
94 maxlength -= 3;
95 dest[j++] = 0xe0 | (c & 0xf000) >> 12;
96 dest[j++] = 0x80 | (c & 0x0fc0) >> 6;
97 dest[j++] = 0x80 | (c & 0x003f);
98 } else if (c >= 0x80) {
99 if (maxlength < 2)
100 break;
101 maxlength -= 2;
102 dest[j++] = 0xc0 | (c & 0x7c0) >> 6;
103 dest[j++] = 0x80 | (c & 0x03f);
104 } else {
105 maxlength -= 1;
106 dest[j++] = c & 0x7f;
107 }
108 }
109 if (maxlength)
110 dest[j] = '\0';
111 return j;
112}
113EXPORT_SYMBOL(ucs2_as_utf8);
1// SPDX-License-Identifier: GPL-2.0
2#include <linux/ucs2_string.h>
3#include <linux/module.h>
4
5/* Return the number of unicode characters in data */
6unsigned long
7ucs2_strnlen(const ucs2_char_t *s, size_t maxlength)
8{
9 unsigned long length = 0;
10
11 while (*s++ != 0 && length < maxlength)
12 length++;
13 return length;
14}
15EXPORT_SYMBOL(ucs2_strnlen);
16
17unsigned long
18ucs2_strlen(const ucs2_char_t *s)
19{
20 return ucs2_strnlen(s, ~0UL);
21}
22EXPORT_SYMBOL(ucs2_strlen);
23
24/*
25 * Return the number of bytes is the length of this string
26 * Note: this is NOT the same as the number of unicode characters
27 */
28unsigned long
29ucs2_strsize(const ucs2_char_t *data, unsigned long maxlength)
30{
31 return ucs2_strnlen(data, maxlength/sizeof(ucs2_char_t)) * sizeof(ucs2_char_t);
32}
33EXPORT_SYMBOL(ucs2_strsize);
34
35/**
36 * ucs2_strscpy() - Copy a UCS2 string into a sized buffer.
37 *
38 * @dst: Pointer to the destination buffer where to copy the string to.
39 * @src: Pointer to the source buffer where to copy the string from.
40 * @count: Size of the destination buffer, in UCS2 (16-bit) characters.
41 *
42 * Like strscpy(), only for UCS2 strings.
43 *
44 * Copy the source string @src, or as much of it as fits, into the destination
45 * buffer @dst. The behavior is undefined if the string buffers overlap. The
46 * destination buffer @dst is always NUL-terminated, unless it's zero-sized.
47 *
48 * Return: The number of characters copied into @dst (excluding the trailing
49 * %NUL terminator) or -E2BIG if @count is 0 or @src was truncated due to the
50 * destination buffer being too small.
51 */
52ssize_t ucs2_strscpy(ucs2_char_t *dst, const ucs2_char_t *src, size_t count)
53{
54 long res;
55
56 /*
57 * Ensure that we have a valid amount of space. We need to store at
58 * least one NUL-character.
59 */
60 if (count == 0 || WARN_ON_ONCE(count > INT_MAX / sizeof(*dst)))
61 return -E2BIG;
62
63 /*
64 * Copy at most 'count' characters, return early if we find a
65 * NUL-terminator.
66 */
67 for (res = 0; res < count; res++) {
68 ucs2_char_t c;
69
70 c = src[res];
71 dst[res] = c;
72
73 if (!c)
74 return res;
75 }
76
77 /*
78 * The loop above terminated without finding a NUL-terminator,
79 * exceeding the 'count': Enforce proper NUL-termination and return
80 * error.
81 */
82 dst[count - 1] = 0;
83 return -E2BIG;
84}
85EXPORT_SYMBOL(ucs2_strscpy);
86
87int
88ucs2_strncmp(const ucs2_char_t *a, const ucs2_char_t *b, size_t len)
89{
90 while (1) {
91 if (len == 0)
92 return 0;
93 if (*a < *b)
94 return -1;
95 if (*a > *b)
96 return 1;
97 if (*a == 0) /* implies *b == 0 */
98 return 0;
99 a++;
100 b++;
101 len--;
102 }
103}
104EXPORT_SYMBOL(ucs2_strncmp);
105
106unsigned long
107ucs2_utf8size(const ucs2_char_t *src)
108{
109 unsigned long i;
110 unsigned long j = 0;
111
112 for (i = 0; src[i]; i++) {
113 u16 c = src[i];
114
115 if (c >= 0x800)
116 j += 3;
117 else if (c >= 0x80)
118 j += 2;
119 else
120 j += 1;
121 }
122
123 return j;
124}
125EXPORT_SYMBOL(ucs2_utf8size);
126
127/*
128 * copy at most maxlength bytes of whole utf8 characters to dest from the
129 * ucs2 string src.
130 *
131 * The return value is the number of characters copied, not including the
132 * final NUL character.
133 */
134unsigned long
135ucs2_as_utf8(u8 *dest, const ucs2_char_t *src, unsigned long maxlength)
136{
137 unsigned int i;
138 unsigned long j = 0;
139 unsigned long limit = ucs2_strnlen(src, maxlength);
140
141 for (i = 0; maxlength && i < limit; i++) {
142 u16 c = src[i];
143
144 if (c >= 0x800) {
145 if (maxlength < 3)
146 break;
147 maxlength -= 3;
148 dest[j++] = 0xe0 | (c & 0xf000) >> 12;
149 dest[j++] = 0x80 | (c & 0x0fc0) >> 6;
150 dest[j++] = 0x80 | (c & 0x003f);
151 } else if (c >= 0x80) {
152 if (maxlength < 2)
153 break;
154 maxlength -= 2;
155 dest[j++] = 0xc0 | (c & 0x7c0) >> 6;
156 dest[j++] = 0x80 | (c & 0x03f);
157 } else {
158 maxlength -= 1;
159 dest[j++] = c & 0x7f;
160 }
161 }
162 if (maxlength)
163 dest[j] = '\0';
164 return j;
165}
166EXPORT_SYMBOL(ucs2_as_utf8);
167
168MODULE_LICENSE("GPL v2");