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 */
50static 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 */
69static 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 */
87static 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 */
99static 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 */
111static 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 */
124static 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 */
139static 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 */
157static 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 */
171static inline int
172UniStrncmp_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 */
186static 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 */
202static 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 */
222static 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 */
249static 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 */
272static 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

source code of linux/fs/nls/nls_ucs2_utils.h