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