1 | /* SPDX-License-Identifier: GPL-2.0-or-later */ |
2 | /* |
3 | * Some of the source code in this file came from fs/cifs/cifs_unicode.c |
4 | * and then via server/unicode.c |
5 | * cifs_unicode: Unicode kernel case support |
6 | * |
7 | * Function: |
8 | * Convert a unicode character to upper or lower case using |
9 | * compressed tables. |
10 | * |
11 | * Copyright (c) International Business Machines Corp., 2000,2009 |
12 | * |
13 | * |
14 | * Notes: |
15 | * These APIs are based on the C library functions. The semantics |
16 | * should match the C functions but with expanded size operands. |
17 | * |
18 | * The upper/lower functions are based on a table created by mkupr. |
19 | * This is a compressed table of upper and lower case conversion. |
20 | * |
21 | */ |
22 | #ifndef _NLS_UCS2_UTILS_H |
23 | #define _NLS_UCS2_UTILS_H |
24 | |
25 | #include <asm/byteorder.h> |
26 | #include <linux/types.h> |
27 | #include <linux/nls.h> |
28 | #include <linux/unicode.h> |
29 | #include "nls_ucs2_data.h" |
30 | |
31 | /* |
32 | * Windows maps these to the user defined 16 bit Unicode range since they are |
33 | * reserved symbols (along with \ and /), otherwise illegal to store |
34 | * in filenames in NTFS |
35 | */ |
36 | #define UNI_ASTERISK ((__u16)('*' + 0xF000)) |
37 | #define UNI_QUESTION ((__u16)('?' + 0xF000)) |
38 | #define UNI_COLON ((__u16)(':' + 0xF000)) |
39 | #define UNI_GRTRTHAN ((__u16)('>' + 0xF000)) |
40 | #define UNI_LESSTHAN ((__u16)('<' + 0xF000)) |
41 | #define UNI_PIPE ((__u16)('|' + 0xF000)) |
42 | #define UNI_SLASH ((__u16)('\\' + 0xF000)) |
43 | |
44 | /* |
45 | * UniStrcat: Concatenate the second string to the first |
46 | * |
47 | * Returns: |
48 | * Address of the first string |
49 | */ |
50 | static inline wchar_t *UniStrcat(wchar_t *ucs1, const wchar_t *ucs2) |
51 | { |
52 | wchar_t *anchor = ucs1; /* save a pointer to start of ucs1 */ |
53 | |
54 | while (*ucs1++) |
55 | /*NULL*/; /* To end of first string */ |
56 | ucs1--; /* Return to the null */ |
57 | while ((*ucs1++ = *ucs2++)) |
58 | /*NULL*/; /* copy string 2 over */ |
59 | return anchor; |
60 | } |
61 | |
62 | /* |
63 | * UniStrchr: Find a character in a string |
64 | * |
65 | * Returns: |
66 | * Address of first occurrence of character in string |
67 | * or NULL if the character is not in the string |
68 | */ |
69 | static inline wchar_t *UniStrchr(const wchar_t *ucs, wchar_t uc) |
70 | { |
71 | while ((*ucs != uc) && *ucs) |
72 | ucs++; |
73 | |
74 | if (*ucs == uc) |
75 | return (wchar_t *)ucs; |
76 | return NULL; |
77 | } |
78 | |
79 | /* |
80 | * UniStrcmp: Compare two strings |
81 | * |
82 | * Returns: |
83 | * < 0: First string is less than second |
84 | * = 0: Strings are equal |
85 | * > 0: First string is greater than second |
86 | */ |
87 | static inline int UniStrcmp(const wchar_t *ucs1, const wchar_t *ucs2) |
88 | { |
89 | while ((*ucs1 == *ucs2) && *ucs1) { |
90 | ucs1++; |
91 | ucs2++; |
92 | } |
93 | return (int)*ucs1 - (int)*ucs2; |
94 | } |
95 | |
96 | /* |
97 | * UniStrcpy: Copy a string |
98 | */ |
99 | static inline wchar_t *UniStrcpy(wchar_t *ucs1, const wchar_t *ucs2) |
100 | { |
101 | wchar_t *anchor = ucs1; /* save the start of result string */ |
102 | |
103 | while ((*ucs1++ = *ucs2++)) |
104 | /*NULL*/; |
105 | return anchor; |
106 | } |
107 | |
108 | /* |
109 | * UniStrlen: Return the length of a string (in 16 bit Unicode chars not bytes) |
110 | */ |
111 | static inline size_t UniStrlen(const wchar_t *ucs1) |
112 | { |
113 | int i = 0; |
114 | |
115 | while (*ucs1++) |
116 | i++; |
117 | return i; |
118 | } |
119 | |
120 | /* |
121 | * UniStrnlen: Return the length (in 16 bit Unicode chars not bytes) of a |
122 | * string (length limited) |
123 | */ |
124 | static inline size_t UniStrnlen(const wchar_t *ucs1, int maxlen) |
125 | { |
126 | int i = 0; |
127 | |
128 | while (*ucs1++) { |
129 | i++; |
130 | if (i >= maxlen) |
131 | break; |
132 | } |
133 | return i; |
134 | } |
135 | |
136 | /* |
137 | * UniStrncat: Concatenate length limited string |
138 | */ |
139 | static inline wchar_t *UniStrncat(wchar_t *ucs1, const wchar_t *ucs2, size_t n) |
140 | { |
141 | wchar_t *anchor = ucs1; /* save pointer to string 1 */ |
142 | |
143 | while (*ucs1++) |
144 | /*NULL*/; |
145 | ucs1--; /* point to null terminator of s1 */ |
146 | while (n-- && (*ucs1 = *ucs2)) { /* copy s2 after s1 */ |
147 | ucs1++; |
148 | ucs2++; |
149 | } |
150 | *ucs1 = 0; /* Null terminate the result */ |
151 | return anchor; |
152 | } |
153 | |
154 | /* |
155 | * UniStrncmp: Compare length limited string |
156 | */ |
157 | static inline int UniStrncmp(const wchar_t *ucs1, const wchar_t *ucs2, size_t n) |
158 | { |
159 | if (!n) |
160 | return 0; /* Null strings are equal */ |
161 | while ((*ucs1 == *ucs2) && *ucs1 && --n) { |
162 | ucs1++; |
163 | ucs2++; |
164 | } |
165 | return (int)*ucs1 - (int)*ucs2; |
166 | } |
167 | |
168 | /* |
169 | * UniStrncmp_le: Compare length limited string - native to little-endian |
170 | */ |
171 | static inline int |
172 | UniStrncmp_le(const wchar_t *ucs1, const wchar_t *ucs2, size_t n) |
173 | { |
174 | if (!n) |
175 | return 0; /* Null strings are equal */ |
176 | while ((*ucs1 == __le16_to_cpu(*ucs2)) && *ucs1 && --n) { |
177 | ucs1++; |
178 | ucs2++; |
179 | } |
180 | return (int)*ucs1 - (int)__le16_to_cpu(*ucs2); |
181 | } |
182 | |
183 | /* |
184 | * UniStrncpy: Copy length limited string with pad |
185 | */ |
186 | static inline wchar_t *UniStrncpy(wchar_t *ucs1, const wchar_t *ucs2, size_t n) |
187 | { |
188 | wchar_t *anchor = ucs1; |
189 | |
190 | while (n-- && *ucs2) /* Copy the strings */ |
191 | *ucs1++ = *ucs2++; |
192 | |
193 | n++; |
194 | while (n--) /* Pad with nulls */ |
195 | *ucs1++ = 0; |
196 | return anchor; |
197 | } |
198 | |
199 | /* |
200 | * UniStrncpy_le: Copy length limited string with pad to little-endian |
201 | */ |
202 | static inline wchar_t *UniStrncpy_le(wchar_t *ucs1, const wchar_t *ucs2, size_t n) |
203 | { |
204 | wchar_t *anchor = ucs1; |
205 | |
206 | while (n-- && *ucs2) /* Copy the strings */ |
207 | *ucs1++ = __le16_to_cpu(*ucs2++); |
208 | |
209 | n++; |
210 | while (n--) /* Pad with nulls */ |
211 | *ucs1++ = 0; |
212 | return anchor; |
213 | } |
214 | |
215 | /* |
216 | * UniStrstr: Find a string in a string |
217 | * |
218 | * Returns: |
219 | * Address of first match found |
220 | * NULL if no matching string is found |
221 | */ |
222 | static inline wchar_t *UniStrstr(const wchar_t *ucs1, const wchar_t *ucs2) |
223 | { |
224 | const wchar_t *anchor1 = ucs1; |
225 | const wchar_t *anchor2 = ucs2; |
226 | |
227 | while (*ucs1) { |
228 | if (*ucs1 == *ucs2) { |
229 | /* Partial match found */ |
230 | ucs1++; |
231 | ucs2++; |
232 | } else { |
233 | if (!*ucs2) /* Match found */ |
234 | return (wchar_t *)anchor1; |
235 | ucs1 = ++anchor1; /* No match */ |
236 | ucs2 = anchor2; |
237 | } |
238 | } |
239 | |
240 | if (!*ucs2) /* Both end together */ |
241 | return (wchar_t *)anchor1; /* Match found */ |
242 | return NULL; /* No match */ |
243 | } |
244 | |
245 | #ifndef UNIUPR_NOUPPER |
246 | /* |
247 | * UniToupper: Convert a unicode character to upper case |
248 | */ |
249 | static inline wchar_t UniToupper(register wchar_t uc) |
250 | { |
251 | register const struct UniCaseRange *rp; |
252 | |
253 | if (uc < sizeof(NlsUniUpperTable)) { |
254 | /* Latin characters */ |
255 | return uc + NlsUniUpperTable[uc]; /* Use base tables */ |
256 | } |
257 | |
258 | rp = NlsUniUpperRange; /* Use range tables */ |
259 | while (rp->start) { |
260 | if (uc < rp->start) /* Before start of range */ |
261 | return uc; /* Uppercase = input */ |
262 | if (uc <= rp->end) /* In range */ |
263 | return uc + rp->table[uc - rp->start]; |
264 | rp++; /* Try next range */ |
265 | } |
266 | return uc; /* Past last range */ |
267 | } |
268 | |
269 | /* |
270 | * UniStrupr: Upper case a unicode string |
271 | */ |
272 | static inline __le16 *UniStrupr(register __le16 *upin) |
273 | { |
274 | register __le16 *up; |
275 | |
276 | up = upin; |
277 | while (*up) { /* For all characters */ |
278 | *up = cpu_to_le16(UniToupper(le16_to_cpu(*up))); |
279 | up++; |
280 | } |
281 | return upin; /* Return input pointer */ |
282 | } |
283 | #endif /* UNIUPR_NOUPPER */ |
284 | |
285 | #endif /* _NLS_UCS2_UTILS_H */ |
286 | |