fs/ncpfs/ncplib_kernel.c

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