ncplib_kernel.c

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

FreeBSD/Linux Kernel Cross Reference
sys/fs/ncpfs/ncplib_kernel.c
