linux/fs/ncpfs/ncplib_kernel.c
<<
>>
Prefs
   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
  16static 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
  23static 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
  31static 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
  39static 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
  46static 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
  54static 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
  61static inline void ncp_add_dword_lh(struct ncp_server *server, __u32 x) {
  62        ncp_add_dword(server, cpu_to_le32(x));
  63}
  64
  65static 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
  73static 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
  86static 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
  94static 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
 104static inline char *
 105ncp_reply_data(struct ncp_server *server, int offset)
 106{
 107        return &(server->packet[sizeof(struct ncp_reply_header) + offset]);
 108}
 109
 110static inline u8 BVAL(const void *data)
 111{
 112        return *(const u8 *)data;
 113}
 114
 115static u8 ncp_reply_byte(struct ncp_server *server, int offset)
 116{
 117        return *(const u8 *)ncp_reply_data(server, offset);
 118}
 119
 120static inline u16 WVAL_LH(const void *data)
 121{
 122        return get_unaligned_le16(data);
 123}
 124
 125static u16
 126ncp_reply_le16(struct ncp_server *server, int offset)
 127{
 128        return get_unaligned_le16(ncp_reply_data(server, offset));
 129}
 130
 131static u16
 132ncp_reply_be16(struct ncp_server *server, int offset)
 133{
 134        return get_unaligned_be16(ncp_reply_data(server, offset));
 135}
 136
 137static inline u32 DVAL_LH(const void *data)
 138{
 139        return get_unaligned_le32(data);
 140}
 141
 142static __le32
 143ncp_reply_dword(struct ncp_server *server, int offset)
 144{
 145        return get_unaligned((__le32 *)ncp_reply_data(server, offset));
 146}
 147
 148static inline __u32 ncp_reply_dword_lh(struct ncp_server* server, int offset) {
 149        return le32_to_cpu(ncp_reply_dword(server, offset));
 150}
 151
 152int
 153ncp_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 */
 175int
 176ncp_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
 204int 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;
 233out:
 234        ncp_unlock_server(server);
 235        return result;
 236}
 237
 238int 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;
 267out:
 268        ncp_unlock_server(server);
 269        return result;
 270}
 271
 272int
 273ncp_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
 286int
 287ncp_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
 306static 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
 325int 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
 342int 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
 352void 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
 367static 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
 375int 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 */
 419int 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
 446out:
 447        ncp_unlock_server(server);
 448        return result;
 449}
 450
 451#ifdef CONFIG_NCPFS_NFS_NS
 452static int
 453ncp_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
 477static inline int
 478ncp_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
 525int
 526ncp_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
 541static int
 542ncp_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
 571int
 572ncp_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
 591int 
 592ncp_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
 622int
 623ncp_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
 645int 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
 670int 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
 680int 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
 707static int
 708ncp_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
 726int
 727ncp_del_file_or_subdir2(struct ncp_server *server,
 728                        struct dentry *dentry)
 729{
 730        struct inode *inode = dentry->d_inode;
 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
 742int
 743ncp_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
 765static 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. */
 776int 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
 823out:
 824        ncp_unlock_server(server);
 825        return result;
 826}
 827
 828int
 829ncp_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
 847out:
 848        ncp_unlock_server(server);
 849        return result;
 850}
 851
 852int 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
 900static int
 901ncp_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);
 936out:
 937        return result;
 938}
 939
 940int 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 */
 966int
 967ncp_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        source = ncp_reply_data(server, 2 + (offset & 1));
 984
 985        memcpy(target, source, *bytes_read);
 986out:
 987        ncp_unlock_server(server);
 988        return result;
 989}
 990
 991/* There is a problem... egrep and some other silly tools do:
 992        x = mmap(NULL, MAP_PRIVATE, PROT_READ|PROT_WRITE, <ncpfs fd>, 32768);
 993        read(<ncpfs fd>, x, 32768);
 994   Now copying read result by copy_to_user causes pagefault. This pagefault
 995   could not be handled because of server was locked due to read. So we have
 996   to use temporary buffer. So ncp_unlock_server must be done before
 997   copy_to_user (and for write, copy_from_user must be done before 
 998   ncp_init_request... same applies for send raw packet ioctl). Because of
 999   file is normally read in bigger chunks, caller provides kmalloced 
1000   (vmalloced) chunk of memory with size >= to_read...
1001 */
1002int
1003ncp_read_bounce(struct ncp_server *server, const char *file_id,
1004         __u32 offset, __u16 to_read, char __user *target, int *bytes_read,
1005         void* bounce, __u32 bufsize)
1006{
1007        int result;
1008
1009        ncp_init_request(server);
1010        ncp_add_byte(server, 0);
1011        ncp_add_mem(server, file_id, 6);
1012        ncp_add_be32(server, offset);
1013        ncp_add_be16(server, to_read);
1014        result = ncp_request2(server, 72, bounce, bufsize);
1015        ncp_unlock_server(server);
1016        if (!result) {
1017                int len = get_unaligned_be16((char *)bounce +
1018                          sizeof(struct ncp_reply_header));
1019                result = -EIO;
1020                if (len <= to_read) {
1021                        char* source;
1022
1023                        source = (char*)bounce + 
1024                                 sizeof(struct ncp_reply_header) + 2 + 
1025                                 (offset & 1);
1026                        *bytes_read = len;
1027                        result = 0;
1028                        if (copy_to_user(target, source, len))
1029                                result = -EFAULT;
1030                }
1031        }
1032        return result;
1033}
1034
1035int
1036ncp_write_kernel(struct ncp_server *server, const char *file_id,
1037                 __u32 offset, __u16 to_write,
1038                 const char *source, int *bytes_written)
1039{
1040        int result;
1041
1042        ncp_init_request(server);
1043        ncp_add_byte(server, 0);
1044        ncp_add_mem(server, file_id, 6);
1045        ncp_add_be32(server, offset);
1046        ncp_add_be16(server, to_write);
1047        ncp_add_mem(server, source, to_write);
1048        
1049        if ((result = ncp_request(server, 73)) == 0)
1050                *bytes_written = to_write;
1051        ncp_unlock_server(server);
1052        return result;
1053}
1054
1055#ifdef CONFIG_NCPFS_IOCTL_LOCKING
1056int
1057ncp_LogPhysicalRecord(struct ncp_server *server, const char *file_id,
1058          __u8 locktype, __u32 offset, __u32 length, __u16 timeout)
1059{
1060        int result;
1061
1062        ncp_init_request(server);
1063        ncp_add_byte(server, locktype);
1064        ncp_add_mem(server, file_id, 6);
1065        ncp_add_be32(server, offset);
1066        ncp_add_be32(server, length);
1067        ncp_add_be16(server, timeout);
1068
1069        if ((result = ncp_request(server, 0x1A)) != 0)
1070        {
1071                ncp_unlock_server(server);
1072                return result;
1073        }
1074        ncp_unlock_server(server);
1075        return 0;
1076}
1077
1078int
1079ncp_ClearPhysicalRecord(struct ncp_server *server, const char *file_id,
1080          __u32 offset, __u32 length)
1081{
1082        int result;
1083
1084        ncp_init_request(server);
1085        ncp_add_byte(server, 0);        /* who knows... lanalyzer says that */
1086        ncp_add_mem(server, file_id, 6);
1087        ncp_add_be32(server, offset);
1088        ncp_add_be32(server, length);
1089
1090        if ((result = ncp_request(server, 0x1E)) != 0)
1091        {
1092                ncp_unlock_server(server);
1093                return result;
1094        }
1095        ncp_unlock_server(server);
1096        return 0;
1097}
1098#endif  /* CONFIG_NCPFS_IOCTL_LOCKING */
1099
1100#ifdef CONFIG_NCPFS_NLS
1101/* This are the NLS conversion routines with inspirations and code parts
1102 * from the vfat file system and hints from Petr Vandrovec.
1103 */
1104
1105int
1106ncp__io2vol(struct ncp_server *server, unsigned char *vname, unsigned int *vlen,
1107                const unsigned char *iname, unsigned int ilen, int cc)
1108{
1109        struct nls_table *in = server->nls_io;
1110        struct nls_table *out = server->nls_vol;
1111        unsigned char *vname_start;
1112        unsigned char *vname_end;
1113        const unsigned char *iname_end;
1114
1115        iname_end = iname + ilen;
1116        vname_start = vname;
1117        vname_end = vname + *vlen - 1;
1118
1119        while (iname < iname_end) {
1120                int chl;
1121                wchar_t ec;
1122
1123                if (NCP_IS_FLAG(server, NCP_FLAG_UTF8)) {
1124                        int k;
1125                        unicode_t u;
1126
1127                        k = utf8_to_utf32(iname, iname_end - iname, &u);
1128                        if (k < 0 || u > MAX_WCHAR_T)
1129                                return -EINVAL;
1130                        iname += k;
1131                        ec = u;
1132                } else {
1133                        if (*iname == NCP_ESC) {
1134                                int k;
1135
1136                                if (iname_end - iname < 5)
1137                                        goto nospec;
1138
1139                                ec = 0;
1140                                for (k = 1; k < 5; k++) {
1141                                        unsigned char nc;
1142
1143                                        nc = iname[k] - '0';
1144                                        if (nc >= 10) {
1145                                                nc -= 'A' - '0' - 10;
1146                                                if ((nc < 10) || (nc > 15)) {
1147                                                        goto nospec;
1148                                                }
1149                                        }
1150                                        ec = (ec << 4) | nc;
1151                                }
1152                                iname += 5;
1153                        } else {
1154nospec:;                        
1155                                if ( (chl = in->char2uni(iname, iname_end - iname, &ec)) < 0)
1156                                        return chl;
1157                                iname += chl;
1158                        }
1159                }
1160
1161                /* unitoupper should be here! */
1162
1163                chl = out->uni2char(ec, vname, vname_end - vname);
1164                if (chl < 0)
1165                        return chl;
1166
1167                /* this is wrong... */
1168                if (cc) {
1169                        int chi;
1170
1171                        for (chi = 0; chi < chl; chi++){
1172                                vname[chi] = ncp_toupper(out, vname[chi]);
1173                        }
1174                }
1175                vname += chl;
1176        }
1177
1178        *vname = 0;
1179        *vlen = vname - vname_start;
1180        return 0;
1181}
1182
1183int
1184ncp__vol2io(struct ncp_server *server, unsigned char *iname, unsigned int *ilen,
1185                const unsigned char *vname, unsigned int vlen, int cc)
1186{
1187        struct nls_table *in = server->nls_vol;
1188        struct nls_table *out = server->nls_io;
1189        const unsigned char *vname_end;
1190        unsigned char *iname_start;
1191        unsigned char *iname_end;
1192        unsigned char *vname_cc;
1193        int err;
1194
1195        vname_cc = NULL;
1196
1197        if (cc) {
1198                int i;
1199
1200                /* this is wrong! */
1201                vname_cc = kmalloc(vlen, GFP_KERNEL);
1202                if (!vname_cc)
1203                        return -ENOMEM;
1204                for (i = 0; i < vlen; i++)
1205                        vname_cc[i] = ncp_tolower(in, vname[i]);
1206                vname = vname_cc;
1207        }
1208
1209        iname_start = iname;
1210        iname_end = iname + *ilen - 1;
1211        vname_end = vname + vlen;
1212
1213        while (vname < vname_end) {
1214                wchar_t ec;
1215                int chl;
1216
1217                if ( (chl = in->char2uni(vname, vname_end - vname, &ec)) < 0) {
1218                        err = chl;
1219                        goto quit;
1220                }
1221                vname += chl;
1222
1223                /* unitolower should be here! */
1224
1225                if (NCP_IS_FLAG(server, NCP_FLAG_UTF8)) {
1226                        int k;
1227
1228                        k = utf32_to_utf8(ec, iname, iname_end - iname);
1229                        if (k < 0) {
1230                                err = -ENAMETOOLONG;
1231                                goto quit;
1232                        }
1233                        iname += k;
1234                } else {
1235                        if ( (chl = out->uni2char(ec, iname, iname_end - iname)) >= 0) {
1236                                iname += chl;
1237                        } else {
1238                                int k;
1239
1240                                if (iname_end - iname < 5) {
1241                                        err = -ENAMETOOLONG;
1242                                        goto quit;
1243                                }
1244                                *iname = NCP_ESC;
1245                                for (k = 4; k > 0; k--) {
1246                                        unsigned char v;
1247                                        
1248                                        v = (ec & 0xF) + '0';
1249                                        if (v > '9') {
1250                                                v += 'A' - '9' - 1;
1251                                        }
1252                                        iname[k] = v;
1253                                        ec >>= 4;
1254                                }
1255                                iname += 5;
1256                        }
1257                }
1258        }
1259
1260        *iname = 0;
1261        *ilen = iname - iname_start;
1262        err = 0;
1263quit:;
1264        if (cc)
1265                kfree(vname_cc);
1266        return err;
1267}
1268
1269#else
1270
1271int
1272ncp__io2vol(unsigned char *vname, unsigned int *vlen,
1273                const unsigned char *iname, unsigned int ilen, int cc)
1274{
1275        int i;
1276
1277        if (*vlen <= ilen)
1278                return -ENAMETOOLONG;
1279
1280        if (cc)
1281                for (i = 0; i < ilen; i++) {
1282                        *vname = toupper(*iname);
1283                        vname++;
1284                        iname++;
1285                }
1286        else {
1287                memmove(vname, iname, ilen);
1288                vname += ilen;
1289        }
1290
1291        *vlen = ilen;
1292        *vname = 0;
1293        return 0;
1294}
1295
1296int
1297ncp__vol2io(unsigned char *iname, unsigned int *ilen,
1298                const unsigned char *vname, unsigned int vlen, int cc)
1299{
1300        int i;
1301
1302        if (*ilen <= vlen)
1303                return -ENAMETOOLONG;
1304
1305        if (cc)
1306                for (i = 0; i < vlen; i++) {
1307                        *iname = tolower(*vname);
1308                        iname++;
1309                        vname++;
1310                }
1311        else {
1312                memmove(iname, vname, vlen);
1313                iname += vlen;
1314        }
1315
1316        *ilen = vlen;
1317        *iname = 0;
1318        return 0;
1319}
1320
1321#endif
1322