fs/ncpfs/ncplib_kernel.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  *  ncplib_kernel.c
   4  *
   5  *  Copyright (C) 1995, 1996 by Volker Lendecke
   6  *  Modified for big endian by J.F. Chadima and David S. Miller
   7  *  Modified 1997 Peter Waltenberg, Bill Hawes, David Woodhouse for 2.1 dcache
   8  *  Modified 1999 Wolfram Pienkoss for NLS
   9  *  Modified 2000 Ben Harris, University of Cambridge for NFS NS meta-info
  10  *
  11  */
  12
  13 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  14
  15 #include "ncp_fs.h"
  16
  17 static inline void assert_server_locked(struct ncp_server *server)
  18 {
  19         if (server->lock == 0) {
  20                 ncp_dbg(1, "server not locked!\n");
  21         }
  22 }
  23
  24 static void ncp_add_byte(struct ncp_server *server, __u8 x)
  25 {
  26         assert_server_locked(server);
  27         *(__u8 *) (&(server->packet[server->current_size])) = x;
  28         server->current_size += 1;
  29         return;
  30 }
  31
  32 static void ncp_add_word(struct ncp_server *server, __le16 x)
  33 {
  34         assert_server_locked(server);
  35         put_unaligned(x, (__le16 *) (&(server->packet[server->current_size])));
  36         server->current_size += 2;
  37         return;
  38 }
  39
  40 static void ncp_add_be16(struct ncp_server *server, __u16 x)
  41 {
  42         assert_server_locked(server);
  43         put_unaligned(cpu_to_be16(x), (__be16 *) (&(server->packet[server->current_size])));
  44         server->current_size += 2;
  45 }
  46
  47 static void ncp_add_dword(struct ncp_server *server, __le32 x)
  48 {
  49         assert_server_locked(server);
  50         put_unaligned(x, (__le32 *) (&(server->packet[server->current_size])));
  51         server->current_size += 4;
  52         return;
  53 }
  54
  55 static void ncp_add_be32(struct ncp_server *server, __u32 x)
  56 {
  57         assert_server_locked(server);
  58         put_unaligned(cpu_to_be32(x), (__be32 *)(&(server->packet[server->current_size])));
  59         server->current_size += 4;
  60 }
  61
  62 static inline void ncp_add_dword_lh(struct ncp_server *server, __u32 x) {
  63         ncp_add_dword(server, cpu_to_le32(x));
  64 }
  65
  66 static void ncp_add_mem(struct ncp_server *server, const void *source, int size)
  67 {
  68         assert_server_locked(server);
  69         memcpy(&(server->packet[server->current_size]), source, size);
  70         server->current_size += size;
  71         return;
  72 }
  73
  74 static void ncp_add_pstring(struct ncp_server *server, const char *s)
  75 {
  76         int len = strlen(s);
  77         assert_server_locked(server);
  78         if (len > 255) {
  79                 ncp_dbg(1, "string too long: %s\n", s);
  80                 len = 255;
  81         }
  82         ncp_add_byte(server, len);
  83         ncp_add_mem(server, s, len);
  84         return;
  85 }
  86
  87 static inline void ncp_init_request(struct ncp_server *server)
  88 {
  89         ncp_lock_server(server);
  90
  91         server->current_size = sizeof(struct ncp_request_header);
  92         server->has_subfunction = 0;
  93 }
  94
  95 static inline void ncp_init_request_s(struct ncp_server *server, int subfunction)
  96 {
  97         ncp_lock_server(server);
  98
  99         server->current_size = sizeof(struct ncp_request_header) + 2;
 100         ncp_add_byte(server, subfunction);
 101
 102         server->has_subfunction = 1;
 103 }
 104
 105 static inline char *
 106 ncp_reply_data(struct ncp_server *server, int offset)
 107 {
 108         return &(server->packet[sizeof(struct ncp_reply_header) + offset]);
 109 }
 110
 111 static inline u8 BVAL(const void *data)
 112 {
 113         return *(const u8 *)data;
 114 }
 115
 116 static u8 ncp_reply_byte(struct ncp_server *server, int offset)
 117 {
 118         return *(const u8 *)ncp_reply_data(server, offset);
 119 }
 120
 121 static inline u16 WVAL_LH(const void *data)
 122 {
 123         return get_unaligned_le16(data);
 124 }
 125
 126 static u16
 127 ncp_reply_le16(struct ncp_server *server, int offset)
 128 {
 129         return get_unaligned_le16(ncp_reply_data(server, offset));
 130 }
 131
 132 static u16
 133 ncp_reply_be16(struct ncp_server *server, int offset)
 134 {
 135         return get_unaligned_be16(ncp_reply_data(server, offset));
 136 }
 137
 138 static inline u32 DVAL_LH(const void *data)
 139 {
 140         return get_unaligned_le32(data);
 141 }
 142
 143 static __le32
 144 ncp_reply_dword(struct ncp_server *server, int offset)
 145 {
 146         return get_unaligned((__le32 *)ncp_reply_data(server, offset));
 147 }
 148
 149 static inline __u32 ncp_reply_dword_lh(struct ncp_server* server, int offset) {
 150         return le32_to_cpu(ncp_reply_dword(server, offset));
 151 }
 152
 153 int
 154 ncp_negotiate_buffersize(struct ncp_server *server, int size, int *target)
 155 {
 156         int result;
 157
 158         ncp_init_request(server);
 159         ncp_add_be16(server, size);
 160
 161         if ((result = ncp_request(server, 33)) != 0) {
 162                 ncp_unlock_server(server);
 163                 return result;
 164         }
 165         *target = min_t(unsigned int, ncp_reply_be16(server, 0), size);
 166
 167         ncp_unlock_server(server);
 168         return 0;
 169 }
 170
 171
 172 /* options:
 173  *      bit 0   ipx checksum
 174  *      bit 1   packet signing
 175  */
 176 int
 177 ncp_negotiate_size_and_options(struct ncp_server *server,
 178         int size, int options, int *ret_size, int *ret_options) {
 179         int result;
 180
 181         /* there is minimum */
 182         if (size < NCP_BLOCK_SIZE) size = NCP_BLOCK_SIZE;
 183
 184         ncp_init_request(server);
 185         ncp_add_be16(server, size);
 186         ncp_add_byte(server, options);
 187
 188         if ((result = ncp_request(server, 0x61)) != 0)
 189         {
 190                 ncp_unlock_server(server);
 191                 return result;
 192         }
 193
 194         /* NCP over UDP returns 0 (!!!) */
 195         result = ncp_reply_be16(server, 0);
 196         if (result >= NCP_BLOCK_SIZE)
 197                 size = min(result, size);
 198         *ret_size = size;
 199         *ret_options = ncp_reply_byte(server, 4);
 200
 201         ncp_unlock_server(server);
 202         return 0;
 203 }
 204
 205 int ncp_get_volume_info_with_number(struct ncp_server* server,
 206                              int n, struct ncp_volume_info* target) {
 207         int result;
 208         int len;
 209
 210         ncp_init_request_s(server, 44);
 211         ncp_add_byte(server, n);
 212
 213         if ((result = ncp_request(server, 22)) != 0) {
 214                 goto out;
 215         }
 216         target->total_blocks = ncp_reply_dword_lh(server, 0);
 217         target->free_blocks = ncp_reply_dword_lh(server, 4);
 218         target->purgeable_blocks = ncp_reply_dword_lh(server, 8);
 219         target->not_yet_purgeable_blocks = ncp_reply_dword_lh(server, 12);
 220         target->total_dir_entries = ncp_reply_dword_lh(server, 16);
 221         target->available_dir_entries = ncp_reply_dword_lh(server, 20);
 222         target->sectors_per_block = ncp_reply_byte(server, 28);
 223
 224         memset(&(target->volume_name), 0, sizeof(target->volume_name));
 225
 226         result = -EIO;
 227         len = ncp_reply_byte(server, 29);
 228         if (len > NCP_VOLNAME_LEN) {
 229                 ncp_dbg(1, "volume name too long: %d\n", len);
 230                 goto out;
 231         }
 232         memcpy(&(target->volume_name), ncp_reply_data(server, 30), len);
 233         result = 0;
 234 out:
 235         ncp_unlock_server(server);
 236         return result;
 237 }
 238
 239 int ncp_get_directory_info(struct ncp_server* server, __u8 n,
 240                            struct ncp_volume_info* target) {
 241         int result;
 242         int len;
 243
 244         ncp_init_request_s(server, 45);
 245         ncp_add_byte(server, n);
 246
 247         if ((result = ncp_request(server, 22)) != 0) {
 248                 goto out;
 249         }
 250         target->total_blocks = ncp_reply_dword_lh(server, 0);
 251         target->free_blocks = ncp_reply_dword_lh(server, 4);
 252         target->purgeable_blocks = 0;
 253         target->not_yet_purgeable_blocks = 0;
 254         target->total_dir_entries = ncp_reply_dword_lh(server, 8);
 255         target->available_dir_entries = ncp_reply_dword_lh(server, 12);
 256         target->sectors_per_block = ncp_reply_byte(server, 20);
 257
 258         memset(&(target->volume_name), 0, sizeof(target->volume_name));
 259
 260         result = -EIO;
 261         len = ncp_reply_byte(server, 21);
 262         if (len > NCP_VOLNAME_LEN) {
 263                 ncp_dbg(1, "volume name too long: %d\n", len);
 264                 goto out;
 265         }
 266         memcpy(&(target->volume_name), ncp_reply_data(server, 22), len);
 267         result = 0;
 268 out:
 269         ncp_unlock_server(server);
 270         return result;
 271 }
 272
 273 int
 274 ncp_close_file(struct ncp_server *server, const char *file_id)
 275 {
 276         int result;
 277
 278         ncp_init_request(server);
 279         ncp_add_byte(server, 0);
 280         ncp_add_mem(server, file_id, 6);
 281
 282         result = ncp_request(server, 66);
 283         ncp_unlock_server(server);
 284         return result;
 285 }
 286
 287 int
 288 ncp_make_closed(struct inode *inode)
 289 {
 290         int err;
 291
 292         err = 0;
 293         mutex_lock(&NCP_FINFO(inode)->open_mutex);
 294         if (atomic_read(&NCP_FINFO(inode)->opened) == 1) {
 295                 atomic_set(&NCP_FINFO(inode)->opened, 0);
 296                 err = ncp_close_file(NCP_SERVER(inode), NCP_FINFO(inode)->file_handle);
 297
 298                 if (!err)
 299                         ncp_vdbg("volnum=%d, dirent=%u, error=%d\n",
 300                                  NCP_FINFO(inode)->volNumber,
 301                                  NCP_FINFO(inode)->dirEntNum, err);
 302         }
 303         mutex_unlock(&NCP_FINFO(inode)->open_mutex);
 304         return err;
 305 }
 306
 307 static void ncp_add_handle_path(struct ncp_server *server, __u8 vol_num,
 308                                 __le32 dir_base, int have_dir_base,
 309                                 const char *path)
 310 {
 311         ncp_add_byte(server, vol_num);
 312         ncp_add_dword(server, dir_base);
 313         if (have_dir_base != 0) {
 314                 ncp_add_byte(server, 1);        /* dir_base */
 315         } else {
 316                 ncp_add_byte(server, 0xff);     /* no handle */
 317         }
 318         if (path != NULL) {
 319                 ncp_add_byte(server, 1);        /* 1 component */
 320                 ncp_add_pstring(server, path);
 321         } else {
 322                 ncp_add_byte(server, 0);
 323         }
 324 }
 325
 326 int ncp_dirhandle_alloc(struct ncp_server* server, __u8 volnum, __le32 dirent,
 327                         __u8* dirhandle) {
 328         int result;
 329
 330         ncp_init_request(server);
 331         ncp_add_byte(server, 12);               /* subfunction */
 332         ncp_add_byte(server, NW_NS_DOS);
 333         ncp_add_byte(server, 0);
 334         ncp_add_word(server, 0);
 335         ncp_add_handle_path(server, volnum, dirent, 1, NULL);
 336         if ((result = ncp_request(server, 87)) == 0) {
 337                 *dirhandle = ncp_reply_byte(server, 0);
 338         }
 339         ncp_unlock_server(server);
 340         return result;
 341 }
 342
 343 int ncp_dirhandle_free(struct ncp_server* server, __u8 dirhandle) {
 344         int result;
 345
 346         ncp_init_request_s(server, 20);
 347         ncp_add_byte(server, dirhandle);
 348         result = ncp_request(server, 22);
 349         ncp_unlock_server(server);
 350         return result;
 351 }
 352
 353 void ncp_extract_file_info(const void *structure, struct nw_info_struct *target)
 354 {
 355         const __u8 *name_len;
 356         const int info_struct_size = offsetof(struct nw_info_struct, nameLen);
 357
 358         memcpy(target, structure, info_struct_size);
 359         name_len = structure + info_struct_size;
 360         target->nameLen = *name_len;
 361         memcpy(target->entryName, name_len + 1, *name_len);
 362         target->entryName[*name_len] = '\0';
 363         target->volNumber = le32_to_cpu(target->volNumber);
 364         return;
 365 }
 366
 367 #ifdef CONFIG_NCPFS_NFS_NS
 368 static inline void ncp_extract_nfs_info(const unsigned char *structure,
 369                                  struct nw_nfs_info *target)
 370 {
 371         target->mode = DVAL_LH(structure);
 372         target->rdev = DVAL_LH(structure + 8);
 373 }
 374 #endif
 375
 376 int ncp_obtain_nfs_info(struct ncp_server *server,
 377                         struct nw_info_struct *target)
 378
 379 {
 380         int result = 0;
 381 #ifdef CONFIG_NCPFS_NFS_NS
 382         __u32 volnum = target->volNumber;
 383
 384         if (ncp_is_nfs_extras(server, volnum)) {
 385                 ncp_init_request(server);
 386                 ncp_add_byte(server, 19);       /* subfunction */
 387                 ncp_add_byte(server, server->name_space[volnum]);
 388                 ncp_add_byte(server, NW_NS_NFS);
 389                 ncp_add_byte(server, 0);
 390                 ncp_add_byte(server, volnum);
 391                 ncp_add_dword(server, target->dirEntNum);
 392                 /* We must retrieve both nlinks and rdev, otherwise some server versions
 393                    report zeroes instead of valid data */
 394                 ncp_add_dword_lh(server, NSIBM_NFS_MODE | NSIBM_NFS_NLINKS | NSIBM_NFS_RDEV);
 395
 396                 if ((result = ncp_request(server, 87)) == 0) {
 397                         ncp_extract_nfs_info(ncp_reply_data(server, 0), &target->nfs);
 398                         ncp_dbg(1, "(%s) mode=0%o, rdev=0x%x\n",
 399                                 target->entryName, target->nfs.mode,
 400                                 target->nfs.rdev);
 401                 } else {
 402                         target->nfs.mode = 0;
 403                         target->nfs.rdev = 0;
 404                 }
 405                 ncp_unlock_server(server);
 406
 407         } else
 408 #endif
 409         {
 410                 target->nfs.mode = 0;
 411                 target->nfs.rdev = 0;
 412         }
 413         return result;
 414 }
 415
 416 /*
 417  * Returns information for a (one-component) name relative to
 418  * the specified directory.
 419  */
 420 int ncp_obtain_info(struct ncp_server *server, struct inode *dir, const char *path,
 421                         struct nw_info_struct *target)
 422 {
 423         __u8  volnum = NCP_FINFO(dir)->volNumber;
 424         __le32 dirent = NCP_FINFO(dir)->dirEntNum;
 425         int result;
 426
 427         if (target == NULL) {
 428                 pr_err("%s: invalid call\n", __func__);
 429                 return -EINVAL;
 430         }
 431         ncp_init_request(server);
 432         ncp_add_byte(server, 6);        /* subfunction */
 433         ncp_add_byte(server, server->name_space[volnum]);
 434         ncp_add_byte(server, server->name_space[volnum]); /* N.B. twice ?? */
 435         ncp_add_word(server, cpu_to_le16(0x8006));      /* get all */
 436         ncp_add_dword(server, RIM_ALL);
 437         ncp_add_handle_path(server, volnum, dirent, 1, path);
 438
 439         if ((result = ncp_request(server, 87)) != 0)
 440                 goto out;
 441         ncp_extract_file_info(ncp_reply_data(server, 0), target);
 442         ncp_unlock_server(server);
 443
 444         result = ncp_obtain_nfs_info(server, target);
 445         return result;
 446
 447 out:
 448         ncp_unlock_server(server);
 449         return result;
 450 }
 451
 452 #ifdef CONFIG_NCPFS_NFS_NS
 453 static int
 454 ncp_obtain_DOS_dir_base(struct ncp_server *server,
 455                 __u8 ns, __u8 volnum, __le32 dirent,
 456                 const char *path, /* At most 1 component */
 457                 __le32 *DOS_dir_base)
 458 {
 459         int result;
 460
 461         ncp_init_request(server);
 462         ncp_add_byte(server, 6); /* subfunction */
 463         ncp_add_byte(server, ns);
 464         ncp_add_byte(server, ns);
 465         ncp_add_word(server, cpu_to_le16(0x8006)); /* get all */
 466         ncp_add_dword(server, RIM_DIRECTORY);
 467         ncp_add_handle_path(server, volnum, dirent, 1, path);
 468
 469         if ((result = ncp_request(server, 87)) == 0)
 470         {
 471                 if (DOS_dir_base) *DOS_dir_base=ncp_reply_dword(server, 0x34);
 472         }
 473         ncp_unlock_server(server);
 474         return result;
 475 }
 476 #endif /* CONFIG_NCPFS_NFS_NS */
 477
 478 static inline int
 479 ncp_get_known_namespace(struct ncp_server *server, __u8 volume)
 480 {
 481 #if defined(CONFIG_NCPFS_OS2_NS) || defined(CONFIG_NCPFS_NFS_NS)
 482         int result;
 483         __u8 *namespace;
 484         __u16 no_namespaces;
 485
 486         ncp_init_request(server);
 487         ncp_add_byte(server, 24);       /* Subfunction: Get Name Spaces Loaded */
 488         ncp_add_word(server, 0);
 489         ncp_add_byte(server, volume);
 490
 491         if ((result = ncp_request(server, 87)) != 0) {
 492                 ncp_unlock_server(server);
 493                 return NW_NS_DOS; /* not result ?? */
 494         }
 495
 496         result = NW_NS_DOS;
 497         no_namespaces = ncp_reply_le16(server, 0);
 498         namespace = ncp_reply_data(server, 2);
 499
 500         while (no_namespaces > 0) {
 501                 ncp_dbg(1, "found %d on %d\n", *namespace, volume);
 502
 503 #ifdef CONFIG_NCPFS_NFS_NS
 504                 if ((*namespace == NW_NS_NFS) && !(server->m.flags&NCP_MOUNT_NO_NFS))
 505                 {
 506                         result = NW_NS_NFS;
 507                         break;
 508                 }
 509 #endif  /* CONFIG_NCPFS_NFS_NS */
 510 #ifdef CONFIG_NCPFS_OS2_NS
 511                 if ((*namespace == NW_NS_OS2) && !(server->m.flags&NCP_MOUNT_NO_OS2))
 512                 {
 513                         result = NW_NS_OS2;
 514                 }
 515 #endif  /* CONFIG_NCPFS_OS2_NS */
 516                 namespace += 1;
 517                 no_namespaces -= 1;
 518         }
 519         ncp_unlock_server(server);
 520         return result;
 521 #else   /* neither OS2 nor NFS - only DOS */
 522         return NW_NS_DOS;
 523 #endif  /* defined(CONFIG_NCPFS_OS2_NS) || defined(CONFIG_NCPFS_NFS_NS) */
 524 }
 525
 526 int
 527 ncp_update_known_namespace(struct ncp_server *server, __u8 volume, int *ret_ns)
 528 {
 529         int ns = ncp_get_known_namespace(server, volume);
 530
 531         if (ret_ns)
 532                 *ret_ns = ns;
 533
 534         ncp_dbg(1, "namespace[%d] = %d\n", volume, server->name_space[volume]);
 535
 536         if (server->name_space[volume] == ns)
 537                 return 0;
 538         server->name_space[volume] = ns;
 539         return 1;
 540 }
 541
 542 static int
 543 ncp_ObtainSpecificDirBase(struct ncp_server *server,
 544                 __u8 nsSrc, __u8 nsDst, __u8 vol_num, __le32 dir_base,
 545                 const char *path, /* At most 1 component */
 546                 __le32 *dirEntNum, __le32 *DosDirNum)
 547 {
 548         int result;
 549
 550         ncp_init_request(server);
 551         ncp_add_byte(server, 6); /* subfunction */
 552         ncp_add_byte(server, nsSrc);
 553         ncp_add_byte(server, nsDst);
 554         ncp_add_word(server, cpu_to_le16(0x8006)); /* get all */
 555         ncp_add_dword(server, RIM_ALL);
 556         ncp_add_handle_path(server, vol_num, dir_base, 1, path);
 557
 558         if ((result = ncp_request(server, 87)) != 0)
 559         {
 560                 ncp_unlock_server(server);
 561                 return result;
 562         }
 563
 564         if (dirEntNum)
 565                 *dirEntNum = ncp_reply_dword(server, 0x30);
 566         if (DosDirNum)
 567                 *DosDirNum = ncp_reply_dword(server, 0x34);
 568         ncp_unlock_server(server);
 569         return 0;
 570 }
 571
 572 int
 573 ncp_mount_subdir(struct ncp_server *server,
 574                  __u8 volNumber, __u8 srcNS, __le32 dirEntNum,
 575                  __u32* volume, __le32* newDirEnt, __le32* newDosEnt)
 576 {
 577         int dstNS;
 578         int result;
 579
 580         ncp_update_known_namespace(server, volNumber, &dstNS);
 581         if ((result = ncp_ObtainSpecificDirBase(server, srcNS, dstNS, volNumber,
 582                                       dirEntNum, NULL, newDirEnt, newDosEnt)) != 0)
 583         {
 584                 return result;
 585         }
 586         *volume = volNumber;
 587         server->m.mounted_vol[1] = 0;
 588         server->m.mounted_vol[0] = 'X';
 589         return 0;
 590 }
 591
 592 int
 593 ncp_get_volume_root(struct ncp_server *server,
 594                     const char *volname, __u32* volume, __le32* dirent, __le32* dosdirent)
 595 {
 596         int result;
 597
 598         ncp_dbg(1, "looking up vol %s\n", volname);
 599
 600         ncp_init_request(server);
 601         ncp_add_byte(server, 22);       /* Subfunction: Generate dir handle */
 602         ncp_add_byte(server, 0);        /* DOS namespace */
 603         ncp_add_byte(server, 0);        /* reserved */
 604         ncp_add_byte(server, 0);        /* reserved */
 605         ncp_add_byte(server, 0);        /* reserved */
 606
 607         ncp_add_byte(server, 0);        /* faked volume number */
 608         ncp_add_dword(server, 0);       /* faked dir_base */
 609         ncp_add_byte(server, 0xff);     /* Don't have a dir_base */
 610         ncp_add_byte(server, 1);        /* 1 path component */
 611         ncp_add_pstring(server, volname);
 612
 613         if ((result = ncp_request(server, 87)) != 0) {
 614                 ncp_unlock_server(server);
 615                 return result;
 616         }
 617         *dirent = *dosdirent = ncp_reply_dword(server, 4);
 618         *volume = ncp_reply_byte(server, 8);
 619         ncp_unlock_server(server);
 620         return 0;
 621 }
 622
 623 int
 624 ncp_lookup_volume(struct ncp_server *server,
 625                   const char *volname, struct nw_info_struct *target)
 626 {
 627         int result;
 628
 629         memset(target, 0, sizeof(*target));
 630         result = ncp_get_volume_root(server, volname,
 631                         &target->volNumber, &target->dirEntNum, &target->DosDirNum);
 632         if (result) {
 633                 return result;
 634         }
 635         ncp_update_known_namespace(server, target->volNumber, NULL);
 636         target->nameLen = strlen(volname);
 637         memcpy(target->entryName, volname, target->nameLen+1);
 638         target->attributes = aDIR;
 639         /* set dates to Jan 1, 1986  00:00 */
 640         target->creationTime = target->modifyTime = cpu_to_le16(0x0000);
 641         target->creationDate = target->modifyDate = target->lastAccessDate = cpu_to_le16(0x0C21);
 642         target->nfs.mode = 0;
 643         return 0;
 644 }
 645
 646 int ncp_modify_file_or_subdir_dos_info_path(struct ncp_server *server,
 647                                             struct inode *dir,
 648                                             const char *path,
 649                                             __le32 info_mask,
 650                                             const struct nw_modify_dos_info *info)
 651 {
 652         __u8  volnum = NCP_FINFO(dir)->volNumber;
 653         __le32 dirent = NCP_FINFO(dir)->dirEntNum;
 654         int result;
 655
 656         ncp_init_request(server);
 657         ncp_add_byte(server, 7);        /* subfunction */
 658         ncp_add_byte(server, server->name_space[volnum]);
 659         ncp_add_byte(server, 0);        /* reserved */
 660         ncp_add_word(server, cpu_to_le16(0x8006));      /* search attribs: all */
 661
 662         ncp_add_dword(server, info_mask);
 663         ncp_add_mem(server, info, sizeof(*info));
 664         ncp_add_handle_path(server, volnum, dirent, 1, path);
 665
 666         result = ncp_request(server, 87);
 667         ncp_unlock_server(server);
 668         return result;
 669 }
 670
 671 int ncp_modify_file_or_subdir_dos_info(struct ncp_server *server,
 672                                        struct inode *dir,
 673                                        __le32 info_mask,
 674                                        const struct nw_modify_dos_info *info)
 675 {
 676         return ncp_modify_file_or_subdir_dos_info_path(server, dir, NULL,
 677                 info_mask, info);
 678 }
 679
 680 #ifdef CONFIG_NCPFS_NFS_NS
 681 int ncp_modify_nfs_info(struct ncp_server *server, __u8 volnum, __le32 dirent,
 682                                __u32 mode, __u32 rdev)
 683
 684 {
 685         int result = 0;
 686
 687         ncp_init_request(server);
 688         if (server->name_space[volnum] == NW_NS_NFS) {
 689                 ncp_add_byte(server, 25);       /* subfunction */
 690                 ncp_add_byte(server, server->name_space[volnum]);
 691                 ncp_add_byte(server, NW_NS_NFS);
 692                 ncp_add_byte(server, volnum);
 693                 ncp_add_dword(server, dirent);
 694                 /* we must always operate on both nlinks and rdev, otherwise
 695                    rdev is not set */
 696                 ncp_add_dword_lh(server, NSIBM_NFS_MODE | NSIBM_NFS_NLINKS | NSIBM_NFS_RDEV);
 697                 ncp_add_dword_lh(server, mode);
 698                 ncp_add_dword_lh(server, 1);    /* nlinks */
 699                 ncp_add_dword_lh(server, rdev);
 700                 result = ncp_request(server, 87);
 701         }
 702         ncp_unlock_server(server);
 703         return result;
 704 }
 705 #endif
 706
 707
 708 static int
 709 ncp_DeleteNSEntry(struct ncp_server *server,
 710                   __u8 have_dir_base, __u8 volnum, __le32 dirent,
 711                   const char* name, __u8 ns, __le16 attr)
 712 {
 713         int result;
 714
 715         ncp_init_request(server);
 716         ncp_add_byte(server, 8);        /* subfunction */
 717         ncp_add_byte(server, ns);
 718         ncp_add_byte(server, 0);        /* reserved */
 719         ncp_add_word(server, attr);     /* search attribs: all */
 720         ncp_add_handle_path(server, volnum, dirent, have_dir_base, name);
 721
 722         result = ncp_request(server, 87);
 723         ncp_unlock_server(server);
 724         return result;
 725 }
 726
 727 int
 728 ncp_del_file_or_subdir2(struct ncp_server *server,
 729                         struct dentry *dentry)
 730 {
 731         struct inode *inode = d_inode(dentry);
 732         __u8  volnum;
 733         __le32 dirent;
 734
 735         if (!inode) {
 736                 return 0xFF;    /* Any error */
 737         }
 738         volnum = NCP_FINFO(inode)->volNumber;
 739         dirent = NCP_FINFO(inode)->DosDirNum;
 740         return ncp_DeleteNSEntry(server, 1, volnum, dirent, NULL, NW_NS_DOS, cpu_to_le16(0x8006));
 741 }
 742
 743 int
 744 ncp_del_file_or_subdir(struct ncp_server *server,
 745                        struct inode *dir, const char *name)
 746 {
 747         __u8  volnum = NCP_FINFO(dir)->volNumber;
 748         __le32 dirent = NCP_FINFO(dir)->dirEntNum;
 749         int name_space;
 750
 751         name_space = server->name_space[volnum];
 752 #ifdef CONFIG_NCPFS_NFS_NS
 753         if (name_space == NW_NS_NFS)
 754         {
 755                 int result;
 756
 757                 result=ncp_obtain_DOS_dir_base(server, name_space, volnum, dirent, name, &dirent);
 758                 if (result) return result;
 759                 name = NULL;
 760                 name_space = NW_NS_DOS;
 761         }
 762 #endif  /* CONFIG_NCPFS_NFS_NS */
 763         return ncp_DeleteNSEntry(server, 1, volnum, dirent, name, name_space, cpu_to_le16(0x8006));
 764 }
 765
 766 static inline void ConvertToNWfromDWORD(__u16 v0, __u16 v1, __u8 ret[6])
 767 {
 768         __le16 *dest = (__le16 *) ret;
 769         dest[1] = cpu_to_le16(v0);
 770         dest[2] = cpu_to_le16(v1);
 771         dest[0] = cpu_to_le16(v0 + 1);
 772         return;
 773 }
 774
 775 /* If both dir and name are NULL, then in target there's already a
 776    looked-up entry that wants to be opened. */
 777 int ncp_open_create_file_or_subdir(struct ncp_server *server,
 778                                    struct inode *dir, const char *name,
 779                                    int open_create_mode,
 780                                    __le32 create_attributes,
 781                                    __le16 desired_acc_rights,
 782                                    struct ncp_entry_info *target)
 783 {
 784         __le16 search_attribs = cpu_to_le16(0x0006);
 785         __u8  volnum;
 786         __le32 dirent;
 787         int result;
 788
 789         volnum = NCP_FINFO(dir)->volNumber;
 790         dirent = NCP_FINFO(dir)->dirEntNum;
 791
 792         if ((create_attributes & aDIR) != 0) {
 793                 search_attribs |= cpu_to_le16(0x8000);
 794         }
 795         ncp_init_request(server);
 796         ncp_add_byte(server, 1);        /* subfunction */
 797         ncp_add_byte(server, server->name_space[volnum]);
 798         ncp_add_byte(server, open_create_mode);
 799         ncp_add_word(server, search_attribs);
 800         ncp_add_dword(server, RIM_ALL);
 801         ncp_add_dword(server, create_attributes);
 802         /* The desired acc rights seem to be the inherited rights mask
 803            for directories */
 804         ncp_add_word(server, desired_acc_rights);
 805         ncp_add_handle_path(server, volnum, dirent, 1, name);
 806
 807         if ((result = ncp_request(server, 87)) != 0)
 808                 goto out;
 809         if (!(create_attributes & aDIR))
 810                 target->opened = 1;
 811
 812         /* in target there's a new finfo to fill */
 813         ncp_extract_file_info(ncp_reply_data(server, 6), &(target->i));
 814         target->volume = target->i.volNumber;
 815         ConvertToNWfromDWORD(ncp_reply_le16(server, 0),
 816                              ncp_reply_le16(server, 2),
 817                              target->file_handle);
 818
 819         ncp_unlock_server(server);
 820
 821         (void)ncp_obtain_nfs_info(server, &(target->i));
 822         return 0;
 823
 824 out:
 825         ncp_unlock_server(server);
 826         return result;
 827 }
 828
 829 int
 830 ncp_initialize_search(struct ncp_server *server, struct inode *dir,
 831                         struct nw_search_sequence *target)
 832 {
 833         __u8  volnum = NCP_FINFO(dir)->volNumber;
 834         __le32 dirent = NCP_FINFO(dir)->dirEntNum;
 835         int result;
 836
 837         ncp_init_request(server);
 838         ncp_add_byte(server, 2);        /* subfunction */
 839         ncp_add_byte(server, server->name_space[volnum]);
 840         ncp_add_byte(server, 0);        /* reserved */
 841         ncp_add_handle_path(server, volnum, dirent, 1, NULL);
 842
 843         result = ncp_request(server, 87);
 844         if (result)
 845                 goto out;
 846         memcpy(target, ncp_reply_data(server, 0), sizeof(*target));
 847
 848 out:
 849         ncp_unlock_server(server);
 850         return result;
 851 }
 852
 853 int ncp_search_for_fileset(struct ncp_server *server,
 854                            struct nw_search_sequence *seq,
 855                            int* more,
 856                            int* cnt,
 857                            char* buffer,
 858                            size_t bufsize,
 859                            char** rbuf,
 860                            size_t* rsize)
 861 {
 862         int result;
 863
 864         ncp_init_request(server);
 865         ncp_add_byte(server, 20);
 866         ncp_add_byte(server, server->name_space[seq->volNumber]);
 867         ncp_add_byte(server, 0);                /* datastream */
 868         ncp_add_word(server, cpu_to_le16(0x8006));
 869         ncp_add_dword(server, RIM_ALL);
 870         ncp_add_word(server, cpu_to_le16(32767));       /* max returned items */
 871         ncp_add_mem(server, seq, 9);
 872 #ifdef CONFIG_NCPFS_NFS_NS
 873         if (server->name_space[seq->volNumber] == NW_NS_NFS) {
 874                 ncp_add_byte(server, 0);        /* 0 byte pattern */
 875         } else
 876 #endif
 877         {
 878                 ncp_add_byte(server, 2);        /* 2 byte pattern */
 879                 ncp_add_byte(server, 0xff);     /* following is a wildcard */
 880                 ncp_add_byte(server, '*');
 881         }
 882         result = ncp_request2(server, 87, buffer, bufsize);
 883         if (result) {
 884                 ncp_unlock_server(server);
 885                 return result;
 886         }
 887         if (server->ncp_reply_size < 12) {
 888                 ncp_unlock_server(server);
 889                 return 0xFF;
 890         }
 891         *rsize = server->ncp_reply_size - 12;
 892         ncp_unlock_server(server);
 893         buffer = buffer + sizeof(struct ncp_reply_header);
 894         *rbuf = buffer + 12;
 895         *cnt = WVAL_LH(buffer + 10);
 896         *more = BVAL(buffer + 9);
 897         memcpy(seq, buffer, 9);
 898         return 0;
 899 }
 900
 901 static int
 902 ncp_RenameNSEntry(struct ncp_server *server,
 903                   struct inode *old_dir, const char *old_name, __le16 old_type,
 904                   struct inode *new_dir, const char *new_name)
 905 {
 906         int result = -EINVAL;
 907
 908         if ((old_dir == NULL) || (old_name == NULL) ||
 909             (new_dir == NULL) || (new_name == NULL))
 910                 goto out;
 911
 912         ncp_init_request(server);
 913         ncp_add_byte(server, 4);        /* subfunction */
 914         ncp_add_byte(server, server->name_space[NCP_FINFO(old_dir)->volNumber]);
 915         ncp_add_byte(server, 1);        /* rename flag */
 916         ncp_add_word(server, old_type); /* search attributes */
 917
 918         /* source Handle Path */
 919         ncp_add_byte(server, NCP_FINFO(old_dir)->volNumber);
 920         ncp_add_dword(server, NCP_FINFO(old_dir)->dirEntNum);
 921         ncp_add_byte(server, 1);
 922         ncp_add_byte(server, 1);        /* 1 source component */
 923
 924         /* dest Handle Path */
 925         ncp_add_byte(server, NCP_FINFO(new_dir)->volNumber);
 926         ncp_add_dword(server, NCP_FINFO(new_dir)->dirEntNum);
 927         ncp_add_byte(server, 1);
 928         ncp_add_byte(server, 1);        /* 1 destination component */
 929
 930         /* source path string */
 931         ncp_add_pstring(server, old_name);
 932         /* dest path string */
 933         ncp_add_pstring(server, new_name);
 934
 935         result = ncp_request(server, 87);
 936         ncp_unlock_server(server);
 937 out:
 938         return result;
 939 }
 940
 941 int ncp_ren_or_mov_file_or_subdir(struct ncp_server *server,
 942                                 struct inode *old_dir, const char *old_name,
 943                                 struct inode *new_dir, const char *new_name)
 944 {
 945         int result;
 946         __le16 old_type = cpu_to_le16(0x06);
 947
 948 /* If somebody can do it atomic, call me... vandrove@vc.cvut.cz */
 949         result = ncp_RenameNSEntry(server, old_dir, old_name, old_type,
 950                                            new_dir, new_name);
 951         if (result == 0xFF)     /* File Not Found, try directory */
 952         {
 953                 old_type = cpu_to_le16(0x16);
 954                 result = ncp_RenameNSEntry(server, old_dir, old_name, old_type,
 955                                                    new_dir, new_name);
 956         }
 957         if (result != 0x92) return result;      /* All except NO_FILES_RENAMED */
 958         result = ncp_del_file_or_subdir(server, new_dir, new_name);
 959         if (result != 0) return -EACCES;
 960         result = ncp_RenameNSEntry(server, old_dir, old_name, old_type,
 961                                            new_dir, new_name);
 962         return result;
 963 }
 964
 965
 966 /* We have to transfer to/from user space */
 967 int
 968 ncp_read_kernel(struct ncp_server *server, const char *file_id,
 969              __u32 offset, __u16 to_read, char *target, int *bytes_read)
 970 {
 971         const char *source;
 972         int result;
 973
 974         ncp_init_request(server);
 975         ncp_add_byte(server, 0);
 976         ncp_add_mem(server, file_id, 6);
 977         ncp_add_be32(server, offset);
 978         ncp_add_be16(server, to_read);
 979
 980         if ((result = ncp_request(server, 72)) != 0) {
 981                 goto out;
 982         }
 983         *bytes_read = ncp_reply_be16(server, 0);
 984         if (*bytes_read > to_read) {
 985                 result = -EINVAL;
 986                 goto out;
 987         }
 988         source = ncp_reply_data(server, 2 + (offset & 1));
 989
 990         memcpy(target, source, *bytes_read);
 991 out:
 992         ncp_unlock_server(server);
 993         return result;
 994 }
 995
 996 /* There is a problem... egrep and some other silly tools do:
 997         x = mmap(NULL, MAP_PRIVATE, PROT_READ|PROT_WRITE, <ncpfs fd>, 32768);
 998         read(<ncpfs fd>, x, 32768);
 999    Now copying read result by copy_to_user causes pagefault. This pagefault
1000    could not be handled because of server was locked due to read. So we have
1001    to use temporary buffer. So ncp_unlock_server must be done before
1002    copy_to_user (and for write, copy_from_user must be done before
1003    ncp_init_request... same applies for send raw packet ioctl). Because of
1004    file is normally read in bigger chunks, caller provides kmalloced
1005    (vmalloced) chunk of memory with size >= to_read...
1006  */
1007 int
1008 ncp_read_bounce(struct ncp_server *server, const char *file_id,
1009          __u32 offset, __u16 to_read, struct iov_iter *to,
1010          int *bytes_read, void *bounce, __u32 bufsize)
1011 {
1012         int result;
1013
1014         ncp_init_request(server);
1015         ncp_add_byte(server, 0);
1016         ncp_add_mem(server, file_id, 6);
1017         ncp_add_be32(server, offset);
1018         ncp_add_be16(server, to_read);
1019         result = ncp_request2(server, 72, bounce, bufsize);
1020         ncp_unlock_server(server);
1021         if (!result) {
1022                 int len = get_unaligned_be16((char *)bounce +
1023                           sizeof(struct ncp_reply_header));
1024                 result = -EIO;
1025                 if (len <= to_read) {
1026                         char* source;
1027
1028                         source = (char*)bounce +
1029                                  sizeof(struct ncp_reply_header) + 2 +
1030                                  (offset & 1);
1031                         *bytes_read = len;
1032                         result = 0;
1033                         if (copy_to_iter(source, len, to) != len)
1034                                 result = -EFAULT;
1035                 }
1036         }
1037         return result;
1038 }
1039
1040 int
1041 ncp_write_kernel(struct ncp_server *server, const char *file_id,
1042                  __u32 offset, __u16 to_write,
1043                  const char *source, int *bytes_written)
1044 {
1045         int result;
1046
1047         ncp_init_request(server);
1048         ncp_add_byte(server, 0);
1049         ncp_add_mem(server, file_id, 6);
1050         ncp_add_be32(server, offset);
1051         ncp_add_be16(server, to_write);
1052         ncp_add_mem(server, source, to_write);
1053
1054         if ((result = ncp_request(server, 73)) == 0)
1055                 *bytes_written = to_write;
1056         ncp_unlock_server(server);
1057         return result;
1058 }
1059
1060 #ifdef CONFIG_NCPFS_IOCTL_LOCKING
1061 int
1062 ncp_LogPhysicalRecord(struct ncp_server *server, const char *file_id,
1063           __u8 locktype, __u32 offset, __u32 length, __u16 timeout)
1064 {
1065         int result;
1066
1067         ncp_init_request(server);
1068         ncp_add_byte(server, locktype);
1069         ncp_add_mem(server, file_id, 6);
1070         ncp_add_be32(server, offset);
1071         ncp_add_be32(server, length);
1072         ncp_add_be16(server, timeout);
1073
1074         if ((result = ncp_request(server, 0x1A)) != 0)
1075         {
1076                 ncp_unlock_server(server);
1077                 return result;
1078         }
1079         ncp_unlock_server(server);
1080         return 0;
1081 }
1082
1083 int
1084 ncp_ClearPhysicalRecord(struct ncp_server *server, const char *file_id,
1085           __u32 offset, __u32 length)
1086 {
1087         int result;
1088
1089         ncp_init_request(server);
1090         ncp_add_byte(server, 0);        /* who knows... lanalyzer says that */
1091         ncp_add_mem(server, file_id, 6);
1092         ncp_add_be32(server, offset);
1093         ncp_add_be32(server, length);
1094
1095         if ((result = ncp_request(server, 0x1E)) != 0)
1096         {
1097                 ncp_unlock_server(server);
1098                 return result;
1099         }
1100         ncp_unlock_server(server);
1101         return 0;
1102 }
1103 #endif  /* CONFIG_NCPFS_IOCTL_LOCKING */
1104
1105 #ifdef CONFIG_NCPFS_NLS
1106 /* This are the NLS conversion routines with inspirations and code parts
1107  * from the vfat file system and hints from Petr Vandrovec.
1108  */
1109
1110 int
1111 ncp__io2vol(struct ncp_server *server, unsigned char *vname, unsigned int *vlen,
1112                 const unsigned char *iname, unsigned int ilen, int cc)
1113 {
1114         struct nls_table *in = server->nls_io;
1115         struct nls_table *out = server->nls_vol;
1116         unsigned char *vname_start;
1117         unsigned char *vname_end;
1118         const unsigned char *iname_end;
1119
1120         iname_end = iname + ilen;
1121         vname_start = vname;
1122         vname_end = vname + *vlen - 1;
1123
1124         while (iname < iname_end) {
1125                 int chl;
1126                 wchar_t ec;
1127
1128                 if (NCP_IS_FLAG(server, NCP_FLAG_UTF8)) {
1129                         int k;
1130                         unicode_t u;
1131
1132                         k = utf8_to_utf32(iname, iname_end - iname, &u);
1133                         if (k < 0 || u > MAX_WCHAR_T)
1134                                 return -EINVAL;
1135                         iname += k;
1136                         ec = u;
1137                 } else {
1138                         if (*iname == NCP_ESC) {
1139                                 int k;
1140
1141                                 if (iname_end - iname < 5)
1142                                         goto nospec;
1143
1144                                 ec = 0;
1145                                 for (k = 1; k < 5; k++) {
1146                                         unsigned char nc;
1147
1148                                         nc = iname[k] - '0';
1149                                         if (nc >= 10) {
1150                                                 nc -= 'A' - '0' - 10;
1151                                                 if ((nc < 10) || (nc > 15)) {
1152                                                         goto nospec;
1153                                                 }
1154                                         }
1155                                         ec = (ec << 4) | nc;
1156                                 }
1157                                 iname += 5;
1158                         } else {
1159 nospec:;
1160                                 if ( (chl = in->char2uni(iname, iname_end - iname, &ec)) < 0)
1161                                         return chl;
1162                                 iname += chl;
1163                         }
1164                 }
1165
1166                 /* unitoupper should be here! */
1167
1168                 chl = out->uni2char(ec, vname, vname_end - vname);
1169                 if (chl < 0)
1170                         return chl;
1171
1172                 /* this is wrong... */
1173                 if (cc) {
1174                         int chi;
1175
1176                         for (chi = 0; chi < chl; chi++){
1177                                 vname[chi] = ncp_toupper(out, vname[chi]);
1178                         }
1179                 }
1180                 vname += chl;
1181         }
1182
1183         *vname = 0;
1184         *vlen = vname - vname_start;
1185         return 0;
1186 }
1187
1188 int
1189 ncp__vol2io(struct ncp_server *server, unsigned char *iname, unsigned int *ilen,
1190                 const unsigned char *vname, unsigned int vlen, int cc)
1191 {
1192         struct nls_table *in = server->nls_vol;
1193         struct nls_table *out = server->nls_io;
1194         const unsigned char *vname_end;
1195         unsigned char *iname_start;
1196         unsigned char *iname_end;
1197         unsigned char *vname_cc;
1198         int err;
1199
1200         vname_cc = NULL;
1201
1202         if (cc) {
1203                 int i;
1204
1205                 /* this is wrong! */
1206                 vname_cc = kmalloc(vlen, GFP_KERNEL);
1207                 if (!vname_cc)
1208                         return -ENOMEM;
1209                 for (i = 0; i < vlen; i++)
1210                         vname_cc[i] = ncp_tolower(in, vname[i]);
1211                 vname = vname_cc;
1212         }
1213
1214         iname_start = iname;
1215         iname_end = iname + *ilen - 1;
1216         vname_end = vname + vlen;
1217
1218         while (vname < vname_end) {
1219                 wchar_t ec;
1220                 int chl;
1221
1222                 if ( (chl = in->char2uni(vname, vname_end - vname, &ec)) < 0) {
1223                         err = chl;
1224                         goto quit;
1225                 }
1226                 vname += chl;
1227
1228                 /* unitolower should be here! */
1229
1230                 if (NCP_IS_FLAG(server, NCP_FLAG_UTF8)) {
1231                         int k;
1232
1233                         k = utf32_to_utf8(ec, iname, iname_end - iname);
1234                         if (k < 0) {
1235                                 err = -ENAMETOOLONG;
1236                                 goto quit;
1237                         }
1238                         iname += k;
1239                 } else {
1240                         if ( (chl = out->uni2char(ec, iname, iname_end - iname)) >= 0) {
1241                                 iname += chl;
1242                         } else {
1243                                 int k;
1244
1245                                 if (iname_end - iname < 5) {
1246                                         err = -ENAMETOOLONG;
1247                                         goto quit;
1248                                 }
1249                                 *iname = NCP_ESC;
1250                                 for (k = 4; k > 0; k--) {
1251                                         unsigned char v;
1252
1253                                         v = (ec & 0xF) + '0';
1254                                         if (v > '9') {
1255                                                 v += 'A' - '9' - 1;
1256                                         }
1257                                         iname[k] = v;
1258                                         ec >>= 4;
1259                                 }
1260                                 iname += 5;
1261                         }
1262                 }
1263         }
1264
1265         *iname = 0;
1266         *ilen = iname - iname_start;
1267         err = 0;
1268 quit:;
1269         if (cc)
1270                 kfree(vname_cc);
1271         return err;
1272 }
1273
1274 #else
1275
1276 int
1277 ncp__io2vol(unsigned char *vname, unsigned int *vlen,
1278                 const unsigned char *iname, unsigned int ilen, int cc)
1279 {
1280         int i;
1281
1282         if (*vlen <= ilen)
1283                 return -ENAMETOOLONG;
1284
1285         if (cc)
1286                 for (i = 0; i < ilen; i++) {
1287                         *vname = toupper(*iname);
1288                         vname++;
1289                         iname++;
1290                 }
1291         else {
1292                 memmove(vname, iname, ilen);
1293                 vname += ilen;
1294         }
1295
1296         *vlen = ilen;
1297         *vname = 0;
1298         return 0;
1299 }
1300
1301 int
1302 ncp__vol2io(unsigned char *iname, unsigned int *ilen,
1303                 const unsigned char *vname, unsigned int vlen, int cc)
1304 {
1305         int i;
1306
1307         if (*ilen <= vlen)
1308                 return -ENAMETOOLONG;
1309
1310         if (cc)
1311                 for (i = 0; i < vlen; i++) {
1312                         *iname = tolower(*vname);
1313                         iname++;
1314                         vname++;
1315                 }
1316         else {
1317                 memmove(iname, vname, vlen);
1318                 iname += vlen;
1319         }
1320
1321         *ilen = vlen;
1322         *iname = 0;
1323         return 0;
1324 }
1325
1326 #endif