linux/fs/ncpfs/ioctl.c
<<
>>
Prefs
   1/*
   2 *  ioctl.c
   3 *
   4 *  Copyright (C) 1995, 1996 by Volker Lendecke
   5 *  Modified 1997 Peter Waltenberg, Bill Hawes, David Woodhouse for 2.1 dcache
   6 *  Modified 1998, 1999 Wolfram Pienkoss for NLS
   7 *
   8 */
   9
  10#include <linux/capability.h>
  11#include <linux/compat.h>
  12#include <linux/errno.h>
  13#include <linux/fs.h>
  14#include <linux/ioctl.h>
  15#include <linux/time.h>
  16#include <linux/mm.h>
  17#include <linux/mount.h>
  18#include <linux/slab.h>
  19#include <linux/highuid.h>
  20#include <linux/vmalloc.h>
  21#include <linux/sched.h>
  22
  23#include <asm/uaccess.h>
  24
  25#include "ncp_fs.h"
  26
  27/* maximum limit for ncp_objectname_ioctl */
  28#define NCP_OBJECT_NAME_MAX_LEN 4096
  29/* maximum limit for ncp_privatedata_ioctl */
  30#define NCP_PRIVATE_DATA_MAX_LEN 8192
  31/* maximum negotiable packet size */
  32#define NCP_PACKET_SIZE_INTERNAL 65536
  33
  34static int
  35ncp_get_fs_info(struct ncp_server * server, struct inode *inode,
  36                struct ncp_fs_info __user *arg)
  37{
  38        struct ncp_fs_info info;
  39
  40        if (copy_from_user(&info, arg, sizeof(info)))
  41                return -EFAULT;
  42
  43        if (info.version != NCP_GET_FS_INFO_VERSION) {
  44                DPRINTK("info.version invalid: %d\n", info.version);
  45                return -EINVAL;
  46        }
  47        /* TODO: info.addr = server->m.serv_addr; */
  48        SET_UID(info.mounted_uid, server->m.mounted_uid);
  49        info.connection         = server->connection;
  50        info.buffer_size        = server->buffer_size;
  51        info.volume_number      = NCP_FINFO(inode)->volNumber;
  52        info.directory_id       = NCP_FINFO(inode)->DosDirNum;
  53
  54        if (copy_to_user(arg, &info, sizeof(info)))
  55                return -EFAULT;
  56        return 0;
  57}
  58
  59static int
  60ncp_get_fs_info_v2(struct ncp_server * server, struct inode *inode,
  61                   struct ncp_fs_info_v2 __user * arg)
  62{
  63        struct ncp_fs_info_v2 info2;
  64
  65        if (copy_from_user(&info2, arg, sizeof(info2)))
  66                return -EFAULT;
  67
  68        if (info2.version != NCP_GET_FS_INFO_VERSION_V2) {
  69                DPRINTK("info.version invalid: %d\n", info2.version);
  70                return -EINVAL;
  71        }
  72        info2.mounted_uid   = server->m.mounted_uid;
  73        info2.connection    = server->connection;
  74        info2.buffer_size   = server->buffer_size;
  75        info2.volume_number = NCP_FINFO(inode)->volNumber;
  76        info2.directory_id  = NCP_FINFO(inode)->DosDirNum;
  77        info2.dummy1 = info2.dummy2 = info2.dummy3 = 0;
  78
  79        if (copy_to_user(arg, &info2, sizeof(info2)))
  80                return -EFAULT;
  81        return 0;
  82}
  83
  84#ifdef CONFIG_COMPAT
  85struct compat_ncp_objectname_ioctl
  86{
  87        s32             auth_type;
  88        u32             object_name_len;
  89        compat_caddr_t  object_name;    /* a userspace data, in most cases user name */
  90};
  91
  92struct compat_ncp_fs_info_v2 {
  93        s32 version;
  94        u32 mounted_uid;
  95        u32 connection;
  96        u32 buffer_size;
  97
  98        u32 volume_number;
  99        u32 directory_id;
 100
 101        u32 dummy1;
 102        u32 dummy2;
 103        u32 dummy3;
 104};
 105
 106struct compat_ncp_ioctl_request {
 107        u32 function;
 108        u32 size;
 109        compat_caddr_t data;
 110};
 111
 112struct compat_ncp_privatedata_ioctl
 113{
 114        u32             len;
 115        compat_caddr_t  data;           /* ~1000 for NDS */
 116};
 117
 118#define NCP_IOC_GET_FS_INFO_V2_32       _IOWR('n', 4, struct compat_ncp_fs_info_v2)
 119#define NCP_IOC_NCPREQUEST_32           _IOR('n', 1, struct compat_ncp_ioctl_request)
 120#define NCP_IOC_GETOBJECTNAME_32        _IOWR('n', 9, struct compat_ncp_objectname_ioctl)
 121#define NCP_IOC_SETOBJECTNAME_32        _IOR('n', 9, struct compat_ncp_objectname_ioctl)
 122#define NCP_IOC_GETPRIVATEDATA_32       _IOWR('n', 10, struct compat_ncp_privatedata_ioctl)
 123#define NCP_IOC_SETPRIVATEDATA_32       _IOR('n', 10, struct compat_ncp_privatedata_ioctl)
 124
 125static int
 126ncp_get_compat_fs_info_v2(struct ncp_server * server, struct inode *inode,
 127                   struct compat_ncp_fs_info_v2 __user * arg)
 128{
 129        struct compat_ncp_fs_info_v2 info2;
 130
 131        if (copy_from_user(&info2, arg, sizeof(info2)))
 132                return -EFAULT;
 133
 134        if (info2.version != NCP_GET_FS_INFO_VERSION_V2) {
 135                DPRINTK("info.version invalid: %d\n", info2.version);
 136                return -EINVAL;
 137        }
 138        info2.mounted_uid   = server->m.mounted_uid;
 139        info2.connection    = server->connection;
 140        info2.buffer_size   = server->buffer_size;
 141        info2.volume_number = NCP_FINFO(inode)->volNumber;
 142        info2.directory_id  = NCP_FINFO(inode)->DosDirNum;
 143        info2.dummy1 = info2.dummy2 = info2.dummy3 = 0;
 144
 145        if (copy_to_user(arg, &info2, sizeof(info2)))
 146                return -EFAULT;
 147        return 0;
 148}
 149#endif
 150
 151#define NCP_IOC_GETMOUNTUID16           _IOW('n', 2, u16)
 152#define NCP_IOC_GETMOUNTUID32           _IOW('n', 2, u32)
 153#define NCP_IOC_GETMOUNTUID64           _IOW('n', 2, u64)
 154
 155#ifdef CONFIG_NCPFS_NLS
 156/* Here we are select the iocharset and the codepage for NLS.
 157 * Thanks Petr Vandrovec for idea and many hints.
 158 */
 159static int
 160ncp_set_charsets(struct ncp_server* server, struct ncp_nls_ioctl __user *arg)
 161{
 162        struct ncp_nls_ioctl user;
 163        struct nls_table *codepage;
 164        struct nls_table *iocharset;
 165        struct nls_table *oldset_io;
 166        struct nls_table *oldset_cp;
 167        int utf8;
 168        int err;
 169
 170        if (copy_from_user(&user, arg, sizeof(user)))
 171                return -EFAULT;
 172
 173        codepage = NULL;
 174        user.codepage[NCP_IOCSNAME_LEN] = 0;
 175        if (!user.codepage[0] || !strcmp(user.codepage, "default"))
 176                codepage = load_nls_default();
 177        else {
 178                codepage = load_nls(user.codepage);
 179                if (!codepage) {
 180                        return -EBADRQC;
 181                }
 182        }
 183
 184        iocharset = NULL;
 185        user.iocharset[NCP_IOCSNAME_LEN] = 0;
 186        if (!user.iocharset[0] || !strcmp(user.iocharset, "default")) {
 187                iocharset = load_nls_default();
 188                utf8 = 0;
 189        } else if (!strcmp(user.iocharset, "utf8")) {
 190                iocharset = load_nls_default();
 191                utf8 = 1;
 192        } else {
 193                iocharset = load_nls(user.iocharset);
 194                if (!iocharset) {
 195                        unload_nls(codepage);
 196                        return -EBADRQC;
 197                }
 198                utf8 = 0;
 199        }
 200
 201        mutex_lock(&server->root_setup_lock);
 202        if (server->root_setuped) {
 203                oldset_cp = codepage;
 204                oldset_io = iocharset;
 205                err = -EBUSY;
 206        } else {
 207                if (utf8)
 208                        NCP_SET_FLAG(server, NCP_FLAG_UTF8);
 209                else
 210                        NCP_CLR_FLAG(server, NCP_FLAG_UTF8);
 211                oldset_cp = server->nls_vol;
 212                server->nls_vol = codepage;
 213                oldset_io = server->nls_io;
 214                server->nls_io = iocharset;
 215                err = 0;
 216        }
 217        mutex_unlock(&server->root_setup_lock);
 218        unload_nls(oldset_cp);
 219        unload_nls(oldset_io);
 220
 221        return err;
 222}
 223
 224static int
 225ncp_get_charsets(struct ncp_server* server, struct ncp_nls_ioctl __user *arg)
 226{
 227        struct ncp_nls_ioctl user;
 228        int len;
 229
 230        memset(&user, 0, sizeof(user));
 231        mutex_lock(&server->root_setup_lock);
 232        if (server->nls_vol && server->nls_vol->charset) {
 233                len = strlen(server->nls_vol->charset);
 234                if (len > NCP_IOCSNAME_LEN)
 235                        len = NCP_IOCSNAME_LEN;
 236                strncpy(user.codepage, server->nls_vol->charset, len);
 237                user.codepage[len] = 0;
 238        }
 239
 240        if (NCP_IS_FLAG(server, NCP_FLAG_UTF8))
 241                strcpy(user.iocharset, "utf8");
 242        else if (server->nls_io && server->nls_io->charset) {
 243                len = strlen(server->nls_io->charset);
 244                if (len > NCP_IOCSNAME_LEN)
 245                        len = NCP_IOCSNAME_LEN;
 246                strncpy(user.iocharset, server->nls_io->charset, len);
 247                user.iocharset[len] = 0;
 248        }
 249        mutex_unlock(&server->root_setup_lock);
 250
 251        if (copy_to_user(arg, &user, sizeof(user)))
 252                return -EFAULT;
 253        return 0;
 254}
 255#endif /* CONFIG_NCPFS_NLS */
 256
 257static long __ncp_ioctl(struct inode *inode, unsigned int cmd, unsigned long arg)
 258{
 259        struct ncp_server *server = NCP_SERVER(inode);
 260        int result;
 261        struct ncp_ioctl_request request;
 262        char* bouncebuffer;
 263        void __user *argp = (void __user *)arg;
 264
 265        switch (cmd) {
 266#ifdef CONFIG_COMPAT
 267        case NCP_IOC_NCPREQUEST_32:
 268#endif
 269        case NCP_IOC_NCPREQUEST:
 270#ifdef CONFIG_COMPAT
 271                if (cmd == NCP_IOC_NCPREQUEST_32) {
 272                        struct compat_ncp_ioctl_request request32;
 273                        if (copy_from_user(&request32, argp, sizeof(request32)))
 274                                return -EFAULT;
 275                        request.function = request32.function;
 276                        request.size = request32.size;
 277                        request.data = compat_ptr(request32.data);
 278                } else
 279#endif
 280                if (copy_from_user(&request, argp, sizeof(request)))
 281                        return -EFAULT;
 282
 283                if ((request.function > 255)
 284                    || (request.size >
 285                  NCP_PACKET_SIZE - sizeof(struct ncp_request_header))) {
 286                        return -EINVAL;
 287                }
 288                bouncebuffer = vmalloc(NCP_PACKET_SIZE_INTERNAL);
 289                if (!bouncebuffer)
 290                        return -ENOMEM;
 291                if (copy_from_user(bouncebuffer, request.data, request.size)) {
 292                        vfree(bouncebuffer);
 293                        return -EFAULT;
 294                }
 295                ncp_lock_server(server);
 296
 297                /* FIXME: We hack around in the server's structures
 298                   here to be able to use ncp_request */
 299
 300                server->has_subfunction = 0;
 301                server->current_size = request.size;
 302                memcpy(server->packet, bouncebuffer, request.size);
 303
 304                result = ncp_request2(server, request.function,
 305                        bouncebuffer, NCP_PACKET_SIZE_INTERNAL);
 306                if (result < 0)
 307                        result = -EIO;
 308                else
 309                        result = server->reply_size;
 310                ncp_unlock_server(server);
 311                DPRINTK("ncp_ioctl: copy %d bytes\n",
 312                        result);
 313                if (result >= 0)
 314                        if (copy_to_user(request.data, bouncebuffer, result))
 315                                result = -EFAULT;
 316                vfree(bouncebuffer);
 317                return result;
 318
 319        case NCP_IOC_CONN_LOGGED_IN:
 320
 321                if (!(server->m.int_flags & NCP_IMOUNT_LOGGEDIN_POSSIBLE))
 322                        return -EINVAL;
 323                mutex_lock(&server->root_setup_lock);
 324                if (server->root_setuped)
 325                        result = -EBUSY;
 326                else {
 327                        result = ncp_conn_logged_in(inode->i_sb);
 328                        if (result == 0)
 329                                server->root_setuped = 1;
 330                }
 331                mutex_unlock(&server->root_setup_lock);
 332                return result;
 333
 334        case NCP_IOC_GET_FS_INFO:
 335                return ncp_get_fs_info(server, inode, argp);
 336
 337        case NCP_IOC_GET_FS_INFO_V2:
 338                return ncp_get_fs_info_v2(server, inode, argp);
 339
 340#ifdef CONFIG_COMPAT
 341        case NCP_IOC_GET_FS_INFO_V2_32:
 342                return ncp_get_compat_fs_info_v2(server, inode, argp);
 343#endif
 344        /* we have too many combinations of CONFIG_COMPAT,
 345         * CONFIG_64BIT and CONFIG_UID16, so just handle

        o mans in tpossie abfs/iosest */
        case NCP_IOC_P_IMOIG_UI_32:
             se {
                         250
                        server->m. 252                        if (__user *)argp                                return -EFAULT;
                        return 0;
                }
        case NCP_IOC_P_IMOIG_V2_32:
                if (server->m.                          /a>(__user *)argp                        return -EFAULT;
                return 0;
        case NCP_IOC_P_IMOIG_> 264:
                if (server->m.                          /a>(__user *)argp                        return -EFAULT;
                return 0;

 267        case NCP_IOC_ROOU264:
             se {
                        struct rocp_ioctl" class="srede=ncptf">rocp_io264;

 271                        result = - 272                        mutex_lock(&server->root_setup_lock);
 273                        if (server->m.m<[0]a>)) {
 274                                struct inode->i_sb->rver" class="sref_f">rfer;
 275;
 276                                if ( 277                                        struct inode* 
                                        if ( 280                                                NCFS_INFO" class="sref">NFFS_INFO 281                                                NCFS_INFO" class="sref">NFFS_INFO                                                 = server->[ 283                                                resultrn 0;
 284                                        } else
 285                                                DPRINTK("fs: f_f">r/a>-&d_de=in==NULLtes\n");
 286                                } else
 287                                        DPRINTK("fs: f_f">r==NULLtes\n");
 288                        } e>)) {
 289                                 290                                rn 0;
 291                                 292                                resultrn 0;
 293                        }
 294                        mutex_unlock(&server->root_setup_lock);
 295                        if (!result && copy_to_user(argp(&                                result = -EFAULT;
 297                        return result;
              a>;
 299
 300        case NCP_ISC_ROOU264:
 301             )) {
 302                        struct rocp_ioctl" class="srede=ncptf">rocp_io264;
                         304                         305                         306                        struct  307;
 308                        if (copy_from_user(&argp, sizeof( 309                                return -EFAULT;
 310                        mutex_lock(&server->root_setup_lock);
 311                        if (server->root_setuped)
 312                                result = -EBUSY;
 313                      } e>)) {
 314                                if ( 315                                        server->m.m<[0]/a>rn 0;
 316                                        NNUMBER_OF_VOLUMESULT" class="sref">NNUMBER_OF_VOLUMESUSY;
 317                                                                                                                        resultrn 0;
                                } e>   if (NNUMBER_OF_VOLUMESULT" class="sref">NNUMBER_OF_VOLUMESUSY<;>)) {
 321                                        resultrn -EINVAL;
 322                                } e>   if (nmounthas_dirNFOserver,  323             /a>                                        ,  324                                                     a>(& 325                                        resultrn - 326                                } else
 327                                        resultrn 0;

 329                                if (result ==>)) {
 330                                        inode->i_sb->rver" class="sref_f">rfer;
 331                                        if ( 332                                                struct inode*  333
                                                if ( 335                                                      = NCFS_INFO" class="sref">NFFS_INFO                                                      = NCFS_INFO" class="sref">NFFS_INFO                                                      = NCFS_INFO" class="sref">NFFS_INFO 338                                                      = server->root_setuped = 1;
                                                } e>)) {
                                                      = DPRINTK("fs: f_f">r/a>-&d_de=in==NULLtes\n");
                                                      = result = -EIO;
 342                                              a>;
             /a>                        } e>)) {
                                              = DPRINTK("fs: f_f">r==NULLtes\n");
                                                result = -EIO;

                                      a>;
                              a>;
                                resultrn 0;
                      a>;
                        mutex_unlock(&server->root_setup_lock);
);
 252                        return result;
              a>;
;
#ifdef FSNCP_PACKETGNINGult" class="srede=CONFf">FSNCP_PACKETGNING314;
        case NCP_ISTGN_INIU337:
             )) {
                        struct 
                        if (argp
                                if (copy_from_user(&argp, sizeof(                                        return -EFAULT;
                     ct ncp_lock_server(server);
                        mutex_lock(&server->muser" class="srefreq_f">muver);
                        if (argp                                if (server->                                        memcpy(server->rver" class="srefign_f">rrgprver" class="srefign_f">rrgp);
                                        memcpy(server->);
                                        server->                               1;
 271                                ignore when digna rees not wantedest */
 272                        } e>)) {
 273                                server-> 274                       1;
                        mutex_unlock(&server->muser" class="srefreq_f">muver);
 276                     ct ncp_unlock_server(server);
 277                        return 0;
              a>;

        case  281             )) {
                     inruct 
 284                     ct ncp_lock_server(server);
 285                     ct server-> 286                     ct ncp_unlock_server(server);
 287                        if (__user *)argp 288                                return -EFAULT;
 289                        return 0;
 290              a>;
);
 292        case  293             )) {
 294                     inruct ;
                        get only low 8 bits...est */
 297                        if (__user *)argp                                return -EFAULT;
                        resultrn 0;
                        ncp_lock_server(server);
 301                        if (server-> 302                                cannot  retudigna rees OFF when activnest */
                                if (! 304                                        resultrn -EINVAL;
 305                        } e>)) {
 306                                server->                      a>;
 308                     ct ncp_unlock_server(server);
 309                        return result;
 310              a>;
);
 312#en    de=CONFf">FSNCP_PACKETGNINGest */

 314#ifdef FSNCP_TL_LOCKINGult" class="srede=CONFf">FSNCP_TL_LOCKING333
 315        case  316             )) {
 317                        struct 
                        if (copy_from_user(&argp, sizeof(                                return -EFAULT;
 321                        if ( 322                                return -EINVAL;
 323             /a>        check for cmdest */
 324                     switch if ( 325                                case  326                                case  327                                                if (                                                      = EFA_TIMEOUUEST" class="sref">NLOCK_Df">EFA_TIMEOUUVAL;
 329                                              } e>   if (NLOCK_MAX_TIMEOUUULT<= 0)
 330                                                      = NLOCK_MAX_TIMEOUUULT;
 331                                             break/a>;
 332                                case                                                 EFA_TIMEOUUEST" class="sref">NLOCK_Df">EFA_TIMEOUUVALhas no effetrust */
                                case NLOCK_CLEAR337:
 335                                             break/a>;
                             default/a>:
                                                return -EINVAL;
 338                      a>;
                        _unling needs both   ad and write accessust */
                        iif (resultinode(                     )) {
 342                                return result;
             /a>      a>;
                        resultrn -                        if (!inode->
                             goto                            if (NLOCK_CLEAR337<= 0)
                     )) {
                                resultct NSERVEREST" class="sref">NSERVERver(inode<)an>,
                     /a>                                NCFS_INFO" class="sref">NFFS_INFOinode<)/a>->                                                      =  252                                                      =                                 if (result-&a0)    resultrn        no such>_unlust */
                       1;
                      } else
                     )) {
                              nruct 
                             switch if (                             )) {
                                        case                                         case                                      default/            =                                1;
                              = resultct NSERVEREST" class="sref">NSERVERver(inode<)an>,
                                                      = NCFS_INFO" class="sref">NFFS_INFOinode<)/a>->                                                      =                                                       =                                                       =                                                       =  271                                if (result-&a0)    resultrn - 272                      a>;
 273<    274                     ct in_closnode" class="srene=nf">in_closnNFOinode<)/a>;
                        return result;
 276              a>;
 277#en     de=CONFf">FSNCP_TL_LOCKINGust */

#ifdef         case  281             )) {
                        struct                      ct ;
 285                        if (copy_from_user(&argp, sizeof( 286                                return -EFAULT;
 287                     n -server-> 288                     of(server-> 289                     ct ;
 290                     of(ct server->;
                        if ()))
                              t ;
 293                      t resultrn 0;
 294                     i  if (                                if (cotorom_uNFO,
                                               t server->,
 297                                               t                                       t resultrn -EFAULT;
                      a>;
                        server-> 301                        if (!result(&aa>(&auct cotorom_uNFOargp(& 302                              t resultrn -EFAULT;
                        return result;
 304              a>;
 305#ena>;
 306;
        case  308             )) {
 309                        struct  310                      t );
                     i  if (copy_from_user(&argp, sizeof(                                return -EFAULT;
                     ct server->                     of(server-> 316                     of(;
 317                     of(ct server->;
                        if ()))
                             of(;
                      t resultrn 0;
 321                        if ( 322                                if (cotorom_uNFO,
 323             /a>                              of(server->,
 324                                              of( 325                                     of(resultrn -EFAULT;
 326                      a>;
 327                        server->                        if (!result(&aa>(&auct cotorom_uNFOargp(& 329                             of(resultrn -EFAULT;
 330                        return result;
 331              a>;
;
#ifdef         case #ena>;
        case              )) {
 338                        struct                      void*> = ;
                     void*> = ;
                      t ;
 342                     void*> =              /a>      t ;
#ifdef 
                        if (                                struct                                 if (copy_from_user(&argp, sizeof(                                        return -EFAULT;
                     /a>     of(                             of(ct ;
 252                             f (ct ;
                     }  } else
#ena>;
                     i  if (copy_from_user(&argp, sizeof(                                return -EFAULT;
;
                        if (-&ase                                 return -                        if (                              = ct ,
                                                    = ;
                                if ()))
                                        return ;
                        } e>)) {
                              = ct                       a>;
                     ct server->                      = ct server->;
                     ct ct server->;
 271                      = server-> 272                     ct server->             /a>      t server-> 274                     ct server->ct ;
                     ct server->ct ;
 276                     ct server->                        server->                     of(server->                      =                      ct ;
 281                        return 0;
              a>;
;
#ifdef  285        case  286#ena>;
        case  288             )) {
 289                        struct  290                     of();
#ifdef  293                        if ( 294                                struct                                 if (copy_from_user(&argp, sizeof(                                        return -EFAULT;
 297                             ct                              ct                         } else
#ena>;
 301                        if (copy_from_user(&argp, sizeof( 302                                return -EFAULT;
;
 304                     ct server->                     ct                      ct server->                        if ( 308                     ct resultrn 0;
 309                        if ( 310                                if (cotorom_uNFO                                                 server->                                                                                         resultrn -EFAULT;
                      a>;
                     of(server-> 316                        if (result<>)))
 317                                return result;
#ifdef                         if (                                struct  321                             of( 322                             f ( 323             /a>                if (cotorom_uNFOargp(& 324                                        return -EFAULT;
 325                        } else
#ena>;
 327                        if (cotorom_uNFOargp(&                                return -EFAULT;
 329;
 330                        return 0;
 331              a>;
;
#ifdef         case #ena>;
        case              )) {
 338                        struct                      void*> =                      void*> =                       t ;
#ifdef                      i  if (                                struct 
                             i  if (copy_from_user(&argp, sizeof(                                        return -EFAULT;
                             ct                                                         } else
#ena>;
 252                        if (copy_from_user(&argp, sizeof(                                return -EFAULT;
;
                     i  if (                                return -                        if (                              =                                 if (                                        retuf (                        } e>)) {
                              =                       a>;
                     a>.server->                      = server->                     ct server->                     of(server->                     ct server->                      = server->                     ct  271                        return 0;
 272              a>;
;
#ifdef         case  276                retuf (server(argp<)/a>;
;
        case                 retuf (server(argp<)/a>;
;
#en /* de=CONFde=FS_NLS */;
;
        case              )) {
                     of( 286;
                        if (copy_from_user(&argp, sizeof( 288             /a>                return -EFAULT;
 289                     /* 20 secs at most... */;
 290                        if (                                return -                     ct  293                     a>(server-> 294                        return 0;
              a>;
;
        case              )) {
                     of(server->                        if (cotorom_uNFOargp(& 301                                return -EFAULT;
 302                        return 0;
              a>;
;
      a>;
        return -;
 308;
 309rgp" class="sref">ser;
 310<)) {
        struct ct ;
        struct serverct ;
     of(     int>ct      longuf (;
 317     switch if (        case         case         case  321                i!f ( 322                     f ( 323             /a>     goto     324              a>;
 325             break/a>;
      a>;
 327        if (server->             switch if (             /*;
 330<         /a>     * Only mount owner   n issue the cafs/ios.  Information;
 331<         /a>     * necessary to authenticate to other NDS f">sers are;
         /a>     * stored here.;
         /a>     */;
                case                 case                 case                 case #ifdef                 case                 case                 case                 case #ena>;
                     f (                     goto    
             /*;
         /a>     * The carequire write access on the in"+c    om_u idsespan;
         /a>     * does not match.  Note that they do not write to thesespan;
         /a>     * file...  But old ="+c did mnt_want_write, so I keepsespan;
         /a>     * it as is.  Of ="ur canot for mountpoint owner, assespan;
         /a>     * that breaks   ad-only mounts altogether as fs/mountsespan;
         /a>     * needs working de=NCP_Ide=REQUEST andsespan;
         /a>     * de=NCP_IGET_FS_INFO.  Some of the ca="+cs (setdentryttl,sespan;
         /a>     * signinit, setsignwanted) should be probably restrictedsespan;
         /a>     * to owner only, or even more to CA=NSYS_ADMIN).;
         /a>     */;
                case                 case                 case                 case                 case                 case                 case #ifdef                 case                 case #ena>;
                     ct                         if (                             goto     271                     ct  272                     ct                         if (                             goto                         break/a>;
 276             /*;
         /a>     * Read access required.;
         /a>     */;
                case :
                case                 case                 case                 case                                              if (                             goto                         break/a>;
 288             /*;
         /a>     * Anybody   n   ad the c.;
         /a>     */;
                case                 case  293             default/a>:
 294             /* T                case                 case                 case                      break/a>;
              a>;
      a>;
 301     rgp" class="sref">ser;
 302<           if (             <>.        retu;
 308;
 309#ifdef  310rgp" class="sref">ser;
     longuf (;
     f (rgp" class="sref">ser(unsigned long)    rgp" class="sref">ser;
     rgp" class="sref">ser;
        retu;
#ena>;



The original LXR software by the >; LXR communityrgp; lxr@s="ux.norgp<.
lxr.s="ux.no kindly hosted by >; Redpill L="pro ASrgpsices fince 1995.