1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Copyright (C) 2016 Namjae Jeon <linkinjeon@kernel.org> 4 * Copyright (C) 2018 Samsung Electronics Co., Ltd. 5 */ 6 7 #include <linux/kernel.h> 8 #include <linux/xattr.h> 9 #include <linux/fs.h> 10 #include <linux/unicode.h> 11 12 #include "misc.h" 13 #include "smb_common.h" 14 #include "connection.h" 15 #include "vfs.h" 16 17 #include "mgmt/share_config.h" 18 19 /** 20 * match_pattern() - compare a string with a pattern which might include 21 * wildcard '*' and '?' 22 * TODO : implement consideration about DOS_DOT, DOS_QM and DOS_STAR 23 * 24 * @str: string to compare with a pattern 25 * @len: string length 26 * @pattern: pattern string which might include wildcard '*' and '?' 27 * 28 * Return: 0 if pattern matched with the string, otherwise non zero value 29 */ 30 int match_pattern(const char *str, size_t len, const char *pattern) 31 { 32 const char *s = str; 33 const char *p = pattern; 34 bool star = false; 35 36 while (*s && len) { 37 switch (*p) { 38 case '?': 39 s++; 40 len--; 41 p++; 42 break; 43 case '*': 44 star = true; 45 str = s; 46 if (!*++p) 47 return true; 48 pattern = p; 49 break; 50 default: 51 if (tolower(*s) == tolower(*p)) { 52 s++; 53 len--; 54 p++; 55 } else { 56 if (!star) 57 return false; 58 str++; 59 s = str; 60 p = pattern; 61 } 62 break; 63 } 64 } 65 66 if (*p == '*') 67 ++p; 68 return !*p; 69 } 70 71 /* 72 * is_char_allowed() - check for valid character 73 * @ch: input character to be checked 74 * 75 * Return: 1 if char is allowed, otherwise 0 76 */ 77 static inline int is_char_allowed(char ch) 78 { 79 /* check for control chars, wildcards etc. */ 80 if (!(ch & 0x80) && 81 (ch <= 0x1f || 82 ch == '?' || ch == '"' || ch == '<' || 83 ch == '>' || ch == '|' || ch == '*')) 84 return 0; 85 86 return 1; 87 } 88 89 int ksmbd_validate_filename(char *filename) 90 { 91 while (*filename) { 92 char c = *filename; 93 94 filename++; 95 if (!is_char_allowed(c)) { 96 ksmbd_debug(VFS, "File name validation failed: 0x%x\n", c); 97 return -ENOENT; 98 } 99 } 100 101 return 0; 102 } 103 104 static int ksmbd_validate_stream_name(char *stream_name) 105 { 106 while (*stream_name) { 107 char c = *stream_name; 108 109 stream_name++; 110 if (c == '/' || c == ':' || c == '\\') { 111 pr_err("Stream name validation failed: %c\n", c); 112 return -ENOENT; 113 } 114 } 115 116 return 0; 117 } 118 119 int parse_stream_name(char *filename, char **stream_name, int *s_type) 120 { 121 char *stream_type; 122 char *s_name; 123 int rc = 0; 124 125 s_name = filename; 126 filename = strsep(&s_name, ":"); 127 ksmbd_debug(SMB, "filename : %s, streams : %s\n", filename, s_name); 128 if (strchr(s_name, ':')) { 129 stream_type = s_name; 130 s_name = strsep(&stream_type, ":"); 131 132 rc = ksmbd_validate_stream_name(s_name); 133 if (rc < 0) { 134 rc = -ENOENT; 135 goto out; 136 } 137 138 ksmbd_debug(SMB, "stream name : %s, stream type : %s\n", s_name, 139 stream_type); 140 if (!strncasecmp("$data", stream_type, 5)) 141 *s_type = DATA_STREAM; 142 else if (!strncasecmp("$index_allocation", stream_type, 17)) 143 *s_type = DIR_STREAM; 144 else 145 rc = -ENOENT; 146 } 147 148 *stream_name = s_name; 149 out: 150 return rc; 151 } 152 153 /** 154 * convert_to_nt_pathname() - extract and return windows path string 155 * whose share directory prefix was removed from file path 156 * @share: ksmbd_share_config pointer 157 * @path: path to report 158 * 159 * Return : windows path string or error 160 */ 161 162 char *convert_to_nt_pathname(struct ksmbd_share_config *share, 163 const struct path *path) 164 { 165 char *pathname, *ab_pathname, *nt_pathname; 166 int share_path_len = share->path_sz; 167 size_t ab_pathname_len; 168 int prefix; 169 170 pathname = kmalloc(PATH_MAX, KSMBD_DEFAULT_GFP); 171 if (!pathname) 172 return ERR_PTR(-EACCES); 173 174 ab_pathname = d_path(path, pathname, PATH_MAX); 175 if (IS_ERR(ab_pathname)) { 176 nt_pathname = ERR_PTR(-EACCES); 177 goto free_pathname; 178 } 179 180 if (strncmp(ab_pathname, share->path, share_path_len)) { 181 nt_pathname = ERR_PTR(-EACCES); 182 goto free_pathname; 183 } 184 185 ab_pathname_len = strlen(&ab_pathname[share_path_len]); 186 prefix = ab_pathname[share_path_len] == '\0' ? 1 : 0; 187 nt_pathname = kmalloc(prefix + ab_pathname_len + 1, KSMBD_DEFAULT_GFP); 188 if (!nt_pathname) { 189 nt_pathname = ERR_PTR(-ENOMEM); 190 goto free_pathname; 191 } 192 193 if (prefix) 194 *nt_pathname = '/'; 195 memcpy(nt_pathname + prefix, &ab_pathname[share_path_len], 196 ab_pathname_len + 1); 197 198 ksmbd_conv_path_to_windows(nt_pathname); 199 200 free_pathname: 201 kfree(pathname); 202 return nt_pathname; 203 } 204 205 int get_nlink(struct kstat *st) 206 { 207 int nlink; 208 209 nlink = st->nlink; 210 if (S_ISDIR(st->mode)) 211 nlink--; 212 213 return nlink; 214 } 215 216 void ksmbd_conv_path_to_unix(char *path) 217 { 218 strreplace(path, '\\', '/'); 219 } 220 221 void ksmbd_strip_last_slash(char *path) 222 { 223 int len = strlen(path); 224 225 while (len && path[len - 1] == '/') { 226 path[len - 1] = '\0'; 227 len--; 228 } 229 } 230 231 void ksmbd_conv_path_to_windows(char *path) 232 { 233 strreplace(path, '/', '\\'); 234 } 235 236 char *ksmbd_casefold_sharename(struct unicode_map *um, const char *name) 237 { 238 char *cf_name; 239 int cf_len; 240 241 cf_name = kzalloc(KSMBD_REQ_MAX_SHARE_NAME, KSMBD_DEFAULT_GFP); 242 if (!cf_name) 243 return ERR_PTR(-ENOMEM); 244 245 if (IS_ENABLED(CONFIG_UNICODE) && um) { 246 const struct qstr q_name = {.name = name, .len = strlen(name)}; 247 248 cf_len = utf8_casefold(um, &q_name, cf_name, 249 KSMBD_REQ_MAX_SHARE_NAME); 250 if (cf_len < 0) 251 goto out_ascii; 252 253 return cf_name; 254 } 255 256 out_ascii: 257 cf_len = strscpy(cf_name, name, KSMBD_REQ_MAX_SHARE_NAME); 258 if (cf_len < 0) { 259 kfree(cf_name); 260 return ERR_PTR(-E2BIG); 261 } 262 263 for (; *cf_name; ++cf_name) 264 *cf_name = isascii(*cf_name) ? tolower(*cf_name) : *cf_name; 265 return cf_name - cf_len; 266 } 267 268 /** 269 * ksmbd_extract_sharename() - get share name from tree connect request 270 * @um: pointer to a unicode_map structure for character encoding handling 271 * @treename: buffer containing tree name and share name 272 * 273 * Return: share name on success, otherwise error 274 */ 275 char *ksmbd_extract_sharename(struct unicode_map *um, const char *treename) 276 { 277 const char *name = treename, *pos = strrchr(name, '\\'); 278 279 if (pos) 280 name = (pos + 1); 281 282 /* caller has to free the memory */ 283 return ksmbd_casefold_sharename(um, name); 284 } 285 286 /** 287 * convert_to_unix_name() - convert windows name to unix format 288 * @share: ksmbd_share_config pointer 289 * @name: file name that is relative to share 290 * 291 * Return: converted name on success, otherwise NULL 292 */ 293 char *convert_to_unix_name(struct ksmbd_share_config *share, const char *name) 294 { 295 int no_slash = 0, name_len, path_len; 296 char *new_name; 297 298 if (name[0] == '/') 299 name++; 300 301 path_len = share->path_sz; 302 name_len = strlen(name); 303 new_name = kmalloc(path_len + name_len + 2, KSMBD_DEFAULT_GFP); 304 if (!new_name) 305 return new_name; 306 307 memcpy(new_name, share->path, path_len); 308 if (new_name[path_len - 1] != '/') { 309 new_name[path_len] = '/'; 310 no_slash = 1; 311 } 312 313 memcpy(new_name + path_len + no_slash, name, name_len); 314 path_len += name_len + no_slash; 315 new_name[path_len] = 0x00; 316 return new_name; 317 } 318 319 char *ksmbd_convert_dir_info_name(struct ksmbd_dir_info *d_info, 320 const struct nls_table *local_nls, 321 int *conv_len) 322 { 323 char *conv; 324 int sz = min(4 * d_info->name_len, PATH_MAX); 325 326 if (!sz) 327 return NULL; 328 329 conv = kmalloc(sz, KSMBD_DEFAULT_GFP); 330 if (!conv) 331 return NULL; 332 333 /* XXX */ 334 *conv_len = smbConvertToUTF16((__le16 *)conv, d_info->name, 335 d_info->name_len, local_nls, 0); 336 *conv_len *= 2; 337 338 /* We allocate buffer twice bigger than needed. */ 339 conv[*conv_len] = 0x00; 340 conv[*conv_len + 1] = 0x00; 341 return conv; 342 } 343 344 /* 345 * Convert the NT UTC (based 1601-01-01, in hundred nanosecond units) 346 * into Unix UTC (based 1970-01-01, in seconds). 347 */ 348 struct timespec64 ksmbd_NTtimeToUnix(__le64 ntutc) 349 { 350 struct timespec64 ts; 351 352 /* Subtract the NTFS time offset, then convert to 1s intervals. */ 353 s64 t = le64_to_cpu(ntutc) - NTFS_TIME_OFFSET; 354 u64 abs_t; 355 356 /* 357 * Unfortunately can not use normal 64 bit division on 32 bit arch, but 358 * the alternative, do_div, does not work with negative numbers so have 359 * to special case them 360 */ 361 if (t < 0) { 362 abs_t = -t; 363 ts.tv_nsec = do_div(abs_t, 10000000) * 100; 364 ts.tv_nsec = -ts.tv_nsec; 365 ts.tv_sec = -abs_t; 366 } else { 367 abs_t = t; 368 ts.tv_nsec = do_div(abs_t, 10000000) * 100; 369 ts.tv_sec = abs_t; 370 } 371 372 return ts; 373 } 374 375 /* Convert the Unix UTC into NT UTC. */ 376 inline u64 ksmbd_UnixTimeToNT(struct timespec64 t) 377 { 378 /* Convert to 100ns intervals and then add the NTFS time offset. */ 379 return (u64)t.tv_sec * 10000000 + t.tv_nsec / 100 + NTFS_TIME_OFFSET; 380 } 381 382 inline long long ksmbd_systime(void) 383 { 384 struct timespec64 ts; 385 386 ktime_get_real_ts64(&ts); 387 return ksmbd_UnixTimeToNT(ts); 388 } 389