taglinefilesource code
server602arch/sparc/kernel/sys_sunos.cstruct sockaddr_in server;
server629arch/sparc/kernel/sys_sunos.cserver.sin_family = AF_INET;
server630arch/sparc/kernel/sys_sunos.cserver.sin_addr = addr->sin_addr;
server631arch/sparc/kernel/sys_sunos.cserver.sin_port = NFS_PORT;
server634arch/sparc/kernel/sys_sunos.cret = socket->ops->connect (socket, (struct sockaddr *) &server,
server635arch/sparc/kernel/sys_sunos.csizeof (server), file->f_flags);
server541drivers/net/sunlance.c*sin=server;
server33fs/ncpfs/dir.cncp_read_volume_list(struct ncp_server *server, int start_with,
server37fs/ncpfs/dir.cncp_do_readdir(struct ncp_server *server, struct inode *dir, int fpos,
server149fs/ncpfs/dir.cstruct ncp_server *server = NCP_SERVER(inode);
server214fs/ncpfs/dir.cif (inode->i_ino == (int)&(server->root))
server216fs/ncpfs/dir.cresult = ncp_read_volume_list(server, filp->f_pos,
server223fs/ncpfs/dir.cresult = ncp_do_readdir(server, inode, filp->f_pos,
server299fs/ncpfs/dir.cncp_read_volume_list(struct ncp_server *server, int fpos, int cache_size)
server318fs/ncpfs/dir.cif (ncp_get_volume_info_with_number(server, i, &info) != 0)
server339fs/ncpfs/dir.cif (ncp_do_lookup(server, NULL,
server358fs/ncpfs/dir.cncp_do_readdir(struct ncp_server *server, struct inode *dir, int fpos,
server388fs/ncpfs/dir.cif (ncp_initialize_search(server, NCP_ISTRUCT(dir), &seq)!=0)
server397fs/ncpfs/dir.cif (ncp_search_for_file_or_subdir(server, &seq,
server542fs/ncpfs/dir.cncp_init_root(struct ncp_server *server)
server544fs/ncpfs/dir.cstruct ncp_inode_info *root = &(server->root);
server548fs/ncpfs/dir.cDPRINTK("ncp_init_root: server %s\n", server->m.server_name);
server568fs/ncpfs/dir.cncp_free_all_inodes(struct ncp_server *server)
server574fs/ncpfs/dir.cstruct ncp_inode_info *root = &(server->root);
server599fs/ncpfs/dir.cstruct ncp_server *server = NCP_SERVER(dir);
server601fs/ncpfs/dir.cstruct ncp_inode_info *result = &(server->root);
server618fs/ncpfs/dir.cwhile (result != &(server->root));
server628fs/ncpfs/dir.cstruct ncp_server *server;
server643fs/ncpfs/dir.cserver = NCP_SERVER(dir);
server736fs/ncpfs/dir.cif (ncp_do_lookup(server,
server182fs/ncpfs/inode.cstruct ncp_server *server;
server221fs/ncpfs/inode.cserver = (struct ncp_server *)ncp_kmalloc(sizeof(struct ncp_server),
server224fs/ncpfs/inode.cif (server == NULL)
server235fs/ncpfs/inode.cNCP_SBP(sb) = server;
server243fs/ncpfs/inode.cserver->ncp_filp    = ncp_filp;
server244fs/ncpfs/inode.cserver->wdog_filp   = wdog_filp;
server245fs/ncpfs/inode.cserver->lock        = 0;
server246fs/ncpfs/inode.cserver->wait        = NULL;
server247fs/ncpfs/inode.cserver->packet      = NULL;
server248fs/ncpfs/inode.cserver->buffer_size = 0;
server250fs/ncpfs/inode.cserver->m = *data;
server251fs/ncpfs/inode.cserver->m.file_mode = (server->m.file_mode &
server253fs/ncpfs/inode.cserver->m.dir_mode  = (server->m.dir_mode &
server256fs/ncpfs/inode.cserver->packet_size = NCP_PACKET_SIZE;
server257fs/ncpfs/inode.cserver->packet      = ncp_kmalloc(NCP_PACKET_SIZE, GFP_KERNEL);
server259fs/ncpfs/inode.cif (server->packet == NULL)
server267fs/ncpfs/inode.cncp_init_root(server);
server273fs/ncpfs/inode.cif (ncp_catch_watchdog(server) != 0)
server281fs/ncpfs/inode.cncp_lock_server(server);
server282fs/ncpfs/inode.cerror = ncp_connect(server);
server283fs/ncpfs/inode.cncp_unlock_server(server);
server291fs/ncpfs/inode.cncp_kfree_s(server->packet, server->packet_size);
server292fs/ncpfs/inode.cncp_dont_catch_watchdog(server);
server298fs/ncpfs/inode.cif (!(sb->s_mounted = iget(sb, (int)&(server->root))))
server305fs/ncpfs/inode.cif (ncp_negotiate_buffersize(server, NCP_DEFAULT_BUFSIZE,
server306fs/ncpfs/inode.c&(server->buffer_size)) != 0)
server313fs/ncpfs/inode.cDPRINTK("ncpfs: bufsize = %d\n", server->buffer_size);
server319fs/ncpfs/inode.cncp_lock_server(server);
server320fs/ncpfs/inode.cncp_disconnect(server);
server321fs/ncpfs/inode.cncp_unlock_server(server);
server322fs/ncpfs/inode.cncp_kfree_s(server->packet, server->packet_size);
server323fs/ncpfs/inode.cncp_dont_catch_watchdog(server);
server334fs/ncpfs/inode.cstruct ncp_server *server = NCP_SBP(sb);
server338fs/ncpfs/inode.cncp_lock_server(server);
server339fs/ncpfs/inode.cncp_disconnect(server);
server340fs/ncpfs/inode.cncp_unlock_server(server);
server342fs/ncpfs/inode.cclose_fp(server->ncp_filp);
server344fs/ncpfs/inode.cncp_dont_catch_watchdog(server);
server345fs/ncpfs/inode.cclose_fp(server->wdog_filp);
server347fs/ncpfs/inode.cncp_free_all_inodes(server);
server349fs/ncpfs/inode.cncp_kfree_s(server->packet, server->packet_size);
server24fs/ncpfs/ioctl.cstruct ncp_server *server = NCP_SERVER(inode);
server30fs/ncpfs/ioctl.c&& (current->uid != server->m.mounted_uid))
server57fs/ncpfs/ioctl.cncp_lock_server(server);
server62fs/ncpfs/ioctl.cserver->has_subfunction = 0;
server63fs/ncpfs/ioctl.cserver->current_size = request.size;
server64fs/ncpfs/ioctl.cmemcpy_fromfs(server->packet, request.data, request.size);
server66fs/ncpfs/ioctl.cncp_request(server, request.function);
server69fs/ncpfs/ioctl.cserver->reply_size);
server70fs/ncpfs/ioctl.cmemcpy_tofs(request.data, server->packet, server->reply_size);
server72fs/ncpfs/ioctl.cncp_unlock_server(server);
server74fs/ncpfs/ioctl.creturn server->reply_size;
server79fs/ncpfs/ioctl.c&& (current->uid != server->m.mounted_uid))
server99fs/ncpfs/ioctl.cinfo.addr        = server->m.serv_addr;
server100fs/ncpfs/ioctl.cinfo.mounted_uid = server->m.mounted_uid;
server101fs/ncpfs/ioctl.cinfo.connection  = server->connection;
server102fs/ncpfs/ioctl.cinfo.buffer_size = server->buffer_size;
server110fs/ncpfs/ioctl.c&& (current->uid != server->m.mounted_uid))
server120fs/ncpfs/ioctl.cput_fs_word(server->m.mounted_uid, (uid_t*) arg);
server13fs/ncpfs/ncplib_kernel.cassert_server_locked(struct ncp_server *server)
server15fs/ncpfs/ncplib_kernel.cif (server->lock == 0)
server22fs/ncpfs/ncplib_kernel.cncp_add_byte(struct ncp_server *server, byte x)
server24fs/ncpfs/ncplib_kernel.cassert_server_locked(server);
server25fs/ncpfs/ncplib_kernel.c*(byte *)(&(server->packet[server->current_size])) = x;
server26fs/ncpfs/ncplib_kernel.cserver->current_size += 1;
server31fs/ncpfs/ncplib_kernel.cncp_add_word(struct ncp_server *server, word x)
server33fs/ncpfs/ncplib_kernel.cassert_server_locked(server);
server34fs/ncpfs/ncplib_kernel.c*(word *)(&(server->packet[server->current_size])) = x;
server35fs/ncpfs/ncplib_kernel.cserver->current_size += 2;
server40fs/ncpfs/ncplib_kernel.cncp_add_dword(struct ncp_server *server, dword x)
server42fs/ncpfs/ncplib_kernel.cassert_server_locked(server);
server43fs/ncpfs/ncplib_kernel.c*(dword *)(&(server->packet[server->current_size])) = x;
server44fs/ncpfs/ncplib_kernel.cserver->current_size += 4;
server49fs/ncpfs/ncplib_kernel.cncp_add_mem(struct ncp_server *server, const void *source, int size)
server51fs/ncpfs/ncplib_kernel.cassert_server_locked(server);
server52fs/ncpfs/ncplib_kernel.cmemcpy(&(server->packet[server->current_size]), source, size);
server53fs/ncpfs/ncplib_kernel.cserver->current_size += size;
server58fs/ncpfs/ncplib_kernel.cncp_add_mem_fromfs(struct ncp_server *server, const char *source, int size)
server60fs/ncpfs/ncplib_kernel.cassert_server_locked(server);
server61fs/ncpfs/ncplib_kernel.cmemcpy_fromfs(&(server->packet[server->current_size]), source, size);
server62fs/ncpfs/ncplib_kernel.cserver->current_size += size;
server67fs/ncpfs/ncplib_kernel.cncp_add_pstring(struct ncp_server *server, const char *s)
server70fs/ncpfs/ncplib_kernel.cassert_server_locked(server);
server76fs/ncpfs/ncplib_kernel.cncp_add_byte(server, len);
server77fs/ncpfs/ncplib_kernel.cncp_add_mem(server, s, len);
server82fs/ncpfs/ncplib_kernel.cncp_init_request(struct ncp_server *server)
server84fs/ncpfs/ncplib_kernel.cncp_lock_server(server);
server86fs/ncpfs/ncplib_kernel.cserver->current_size = sizeof(struct ncp_request_header);
server87fs/ncpfs/ncplib_kernel.cserver->has_subfunction = 0;
server91fs/ncpfs/ncplib_kernel.cncp_init_request_s(struct ncp_server *server, int subfunction)
server93fs/ncpfs/ncplib_kernel.cncp_init_request(server);
server94fs/ncpfs/ncplib_kernel.cncp_add_word(server, 0); /* preliminary size */
server96fs/ncpfs/ncplib_kernel.cncp_add_byte(server, subfunction);
server98fs/ncpfs/ncplib_kernel.cserver->has_subfunction = 1;
server102fs/ncpfs/ncplib_kernel.cncp_reply_data(struct ncp_server *server, int offset)
server104fs/ncpfs/ncplib_kernel.creturn &(server->packet[sizeof(struct ncp_reply_header) + offset]);
server108fs/ncpfs/ncplib_kernel.cncp_reply_byte(struct ncp_server *server, int offset)
server110fs/ncpfs/ncplib_kernel.creturn *(byte *)(ncp_reply_data(server, offset));
server114fs/ncpfs/ncplib_kernel.cncp_reply_word(struct ncp_server *server, int offset)
server116fs/ncpfs/ncplib_kernel.creturn *(word *)(ncp_reply_data(server, offset));
server120fs/ncpfs/ncplib_kernel.cncp_reply_dword(struct ncp_server *server, int offset)
server122fs/ncpfs/ncplib_kernel.creturn *(dword *)(ncp_reply_data(server, offset));
server126fs/ncpfs/ncplib_kernel.cncp_negotiate_buffersize(struct ncp_server *server,
server131fs/ncpfs/ncplib_kernel.cncp_init_request(server);
server132fs/ncpfs/ncplib_kernel.cncp_add_word(server, htons(size));
server134fs/ncpfs/ncplib_kernel.cif ((result = ncp_request(server, 33)) != 0)
server136fs/ncpfs/ncplib_kernel.cncp_unlock_server(server);
server140fs/ncpfs/ncplib_kernel.c*target =min(ntohs(ncp_reply_word(server, 0)), size);
server142fs/ncpfs/ncplib_kernel.cncp_unlock_server(server);
server147fs/ncpfs/ncplib_kernel.cncp_get_volume_info_with_number(struct ncp_server *server, int n,
server153fs/ncpfs/ncplib_kernel.cncp_init_request_s(server, 44);
server154fs/ncpfs/ncplib_kernel.cncp_add_byte(server, n);
server156fs/ncpfs/ncplib_kernel.cif ((result = ncp_request(server, 22)) != 0)
server158fs/ncpfs/ncplib_kernel.cncp_unlock_server(server);
server162fs/ncpfs/ncplib_kernel.ctarget->total_blocks = ncp_reply_dword(server, 0);
server163fs/ncpfs/ncplib_kernel.ctarget->free_blocks  = ncp_reply_dword(server, 4);
server164fs/ncpfs/ncplib_kernel.ctarget->purgeable_blocks = ncp_reply_dword(server, 8);
server165fs/ncpfs/ncplib_kernel.ctarget->not_yet_purgeable_blocks = ncp_reply_dword(server, 12);
server166fs/ncpfs/ncplib_kernel.ctarget->total_dir_entries = ncp_reply_dword(server, 16);
server167fs/ncpfs/ncplib_kernel.ctarget->available_dir_entries = ncp_reply_dword(server, 20);
server168fs/ncpfs/ncplib_kernel.ctarget->sectors_per_block = ncp_reply_byte(server, 28);
server172fs/ncpfs/ncplib_kernel.clen = ncp_reply_byte(server, 29);
server176fs/ncpfs/ncplib_kernel.cncp_unlock_server(server);
server180fs/ncpfs/ncplib_kernel.cmemcpy(&(target->volume_name), ncp_reply_data(server, 30), len);
server181fs/ncpfs/ncplib_kernel.cncp_unlock_server(server);
server186fs/ncpfs/ncplib_kernel.cncp_get_volume_number(struct ncp_server *server, const char *name, int *target)
server190fs/ncpfs/ncplib_kernel.cncp_init_request_s(server, 5);
server191fs/ncpfs/ncplib_kernel.cncp_add_pstring(server, name);
server193fs/ncpfs/ncplib_kernel.cif ((result = ncp_request(server, 22)) != 0)
server195fs/ncpfs/ncplib_kernel.cncp_unlock_server(server);
server199fs/ncpfs/ncplib_kernel.c*target = ncp_reply_byte(server, 0);
server200fs/ncpfs/ncplib_kernel.cncp_unlock_server(server);
server205fs/ncpfs/ncplib_kernel.cncp_close_file(struct ncp_server *server, const char *file_id)
server209fs/ncpfs/ncplib_kernel.cncp_init_request(server);
server210fs/ncpfs/ncplib_kernel.cncp_add_byte(server, 0);
server211fs/ncpfs/ncplib_kernel.cncp_add_mem(server, file_id, 6);
server213fs/ncpfs/ncplib_kernel.cif ((result = ncp_request(server, 66)) != 0)
server215fs/ncpfs/ncplib_kernel.cncp_unlock_server(server);
server219fs/ncpfs/ncplib_kernel.cncp_unlock_server(server);
server224fs/ncpfs/ncplib_kernel.cncp_add_handle_path(struct ncp_server *server,
server229fs/ncpfs/ncplib_kernel.cncp_add_byte(server, vol_num);
server230fs/ncpfs/ncplib_kernel.cncp_add_dword(server, dir_base);
server233fs/ncpfs/ncplib_kernel.cncp_add_byte(server, 1); /* dir_base */
server237fs/ncpfs/ncplib_kernel.cncp_add_byte(server, 0xff); /* no handle */
server241fs/ncpfs/ncplib_kernel.cncp_add_byte(server, 1); /* 1 component */
server242fs/ncpfs/ncplib_kernel.cncp_add_pstring(server, path);
server246fs/ncpfs/ncplib_kernel.cncp_add_byte(server, 0);
server266fs/ncpfs/ncplib_kernel.cncp_do_lookup(struct ncp_server *server,
server287fs/ncpfs/ncplib_kernel.cncp_init_request(server);
server288fs/ncpfs/ncplib_kernel.cncp_add_byte(server, 22); /* subfunction */
server289fs/ncpfs/ncplib_kernel.cncp_add_byte(server, 0); /* dos name space */
server290fs/ncpfs/ncplib_kernel.cncp_add_byte(server, 0); /* reserved */
server291fs/ncpfs/ncplib_kernel.cncp_add_byte(server, 0); /* reserved */
server292fs/ncpfs/ncplib_kernel.cncp_add_byte(server, 0); /* reserved */
server293fs/ncpfs/ncplib_kernel.cncp_add_handle_path(server, 0, 0, 0, /* no handle */
server296fs/ncpfs/ncplib_kernel.cif ((result = ncp_request(server, 87)) != 0)
server298fs/ncpfs/ncplib_kernel.cncp_unlock_server(server);
server302fs/ncpfs/ncplib_kernel.cdir_base = ncp_reply_dword(server, 4);
server303fs/ncpfs/ncplib_kernel.cvol_num  = ncp_reply_byte (server, 8);
server304fs/ncpfs/ncplib_kernel.cncp_unlock_server(server);
server314fs/ncpfs/ncplib_kernel.cncp_init_request(server);
server315fs/ncpfs/ncplib_kernel.cncp_add_byte(server, 6); /* subfunction */
server316fs/ncpfs/ncplib_kernel.cncp_add_byte(server, 0); /* dos name space */
server317fs/ncpfs/ncplib_kernel.cncp_add_byte(server, 0); /* dos name space as dest */
server318fs/ncpfs/ncplib_kernel.cncp_add_word(server, 0xff); /* get all */
server319fs/ncpfs/ncplib_kernel.cncp_add_dword(server, RIM_ALL);
server320fs/ncpfs/ncplib_kernel.cncp_add_handle_path(server, vol_num, dir_base, 1,
server323fs/ncpfs/ncplib_kernel.cif ((result = ncp_request(server, 87)) != 0)
server325fs/ncpfs/ncplib_kernel.cncp_unlock_server(server);
server329fs/ncpfs/ncplib_kernel.cncp_extract_file_info(ncp_reply_data(server, 0), target);
server337fs/ncpfs/ncplib_kernel.cncp_unlock_server(server);
server342fs/ncpfs/ncplib_kernel.cncp_modify_file_or_subdir_dos_info(struct ncp_server *server,
server349fs/ncpfs/ncplib_kernel.cncp_init_request(server);
server350fs/ncpfs/ncplib_kernel.cncp_add_byte(server, 7); /* subfunction */
server351fs/ncpfs/ncplib_kernel.cncp_add_byte(server, 0); /* dos name space */
server352fs/ncpfs/ncplib_kernel.cncp_add_byte(server, 0); /* reserved */
server353fs/ncpfs/ncplib_kernel.cncp_add_word(server, 0x8006); /* search attribs: all */
server355fs/ncpfs/ncplib_kernel.cncp_add_dword(server, info_mask);
server356fs/ncpfs/ncplib_kernel.cncp_add_mem(server, info, sizeof(*info));
server357fs/ncpfs/ncplib_kernel.cncp_add_handle_path(server, file->volNumber,
server360fs/ncpfs/ncplib_kernel.cif ((result = ncp_request(server, 87)) != 0)
server362fs/ncpfs/ncplib_kernel.cncp_unlock_server(server);
server366fs/ncpfs/ncplib_kernel.cncp_unlock_server(server);
server371fs/ncpfs/ncplib_kernel.cncp_del_file_or_subdir(struct ncp_server *server,
server376fs/ncpfs/ncplib_kernel.cncp_init_request(server);
server377fs/ncpfs/ncplib_kernel.cncp_add_byte(server, 8); /* subfunction */
server378fs/ncpfs/ncplib_kernel.cncp_add_byte(server, 0); /* dos name space */
server379fs/ncpfs/ncplib_kernel.cncp_add_byte(server, 0); /* reserved */
server380fs/ncpfs/ncplib_kernel.cncp_add_word(server, 0x8006); /* search attribs: all */
server381fs/ncpfs/ncplib_kernel.cncp_add_handle_path(server, dir->volNumber,
server384fs/ncpfs/ncplib_kernel.cif ((result = ncp_request(server, 87)) != 0)
server386fs/ncpfs/ncplib_kernel.cncp_unlock_server(server);
server390fs/ncpfs/ncplib_kernel.cncp_unlock_server(server);
server406fs/ncpfs/ncplib_kernel.cncp_open_create_file_or_subdir(struct ncp_server *server,
server415fs/ncpfs/ncplib_kernel.cncp_init_request(server);
server416fs/ncpfs/ncplib_kernel.cncp_add_byte(server, 1); /* subfunction */
server417fs/ncpfs/ncplib_kernel.cncp_add_byte(server, 0); /* dos name space */
server418fs/ncpfs/ncplib_kernel.cncp_add_byte(server, open_create_mode);
server419fs/ncpfs/ncplib_kernel.cncp_add_word(server, 0x8006);
server420fs/ncpfs/ncplib_kernel.cncp_add_dword(server, RIM_ALL);
server421fs/ncpfs/ncplib_kernel.cncp_add_dword(server, create_attributes);
server424fs/ncpfs/ncplib_kernel.cncp_add_word(server, desired_acc_rights);
server428fs/ncpfs/ncplib_kernel.cncp_add_handle_path(server, dir->volNumber,
server433fs/ncpfs/ncplib_kernel.cncp_add_handle_path(server,
server438fs/ncpfs/ncplib_kernel.cif ((result = ncp_request(server, 87)) != 0)
server440fs/ncpfs/ncplib_kernel.cncp_unlock_server(server);
server445fs/ncpfs/ncplib_kernel.ctarget->server_file_handle = ncp_reply_dword(server, 0);
server446fs/ncpfs/ncplib_kernel.ctarget->open_create_action = ncp_reply_byte(server, 4);
server451fs/ncpfs/ncplib_kernel.cncp_extract_file_info(ncp_reply_data(server, 5), &(target->i));
server456fs/ncpfs/ncplib_kernel.cncp_unlock_server(server);
server462fs/ncpfs/ncplib_kernel.cncp_initialize_search(struct ncp_server *server,
server468fs/ncpfs/ncplib_kernel.cncp_init_request(server);
server469fs/ncpfs/ncplib_kernel.cncp_add_byte(server, 2); /* subfunction */
server470fs/ncpfs/ncplib_kernel.cncp_add_byte(server, 0); /* dos name space */
server471fs/ncpfs/ncplib_kernel.cncp_add_byte(server, 0); /* reserved */
server472fs/ncpfs/ncplib_kernel.cncp_add_handle_path(server, dir->volNumber, dir->DosDirNum, 1, NULL);
server474fs/ncpfs/ncplib_kernel.cif ((result = ncp_request(server, 87)) != 0)
server476fs/ncpfs/ncplib_kernel.cncp_unlock_server(server);
server480fs/ncpfs/ncplib_kernel.cmemcpy(target, ncp_reply_data(server, 0), sizeof(*target));
server482fs/ncpfs/ncplib_kernel.cncp_unlock_server(server);
server488fs/ncpfs/ncplib_kernel.cncp_search_for_file_or_subdir(struct ncp_server *server,
server494fs/ncpfs/ncplib_kernel.cncp_init_request(server);
server495fs/ncpfs/ncplib_kernel.cncp_add_byte(server, 3); /* subfunction */
server496fs/ncpfs/ncplib_kernel.cncp_add_byte(server, 0); /* dos name space */
server497fs/ncpfs/ncplib_kernel.cncp_add_byte(server, 0); /* data stream (???) */
server498fs/ncpfs/ncplib_kernel.cncp_add_word(server, 0xffff); /* Search attribs */
server499fs/ncpfs/ncplib_kernel.cncp_add_dword(server, RIM_ALL);  /* return info mask */
server500fs/ncpfs/ncplib_kernel.cncp_add_mem(server, seq, 9);
server501fs/ncpfs/ncplib_kernel.cncp_add_byte(server, 2); /* 2 byte pattern */
server502fs/ncpfs/ncplib_kernel.cncp_add_byte(server, 0xff); /* following is a wildcard */
server503fs/ncpfs/ncplib_kernel.cncp_add_byte(server, '*');
server505fs/ncpfs/ncplib_kernel.cif ((result = ncp_request(server, 87)) != 0)
server507fs/ncpfs/ncplib_kernel.cncp_unlock_server(server);
server511fs/ncpfs/ncplib_kernel.cmemcpy(seq, ncp_reply_data(server, 0), sizeof(*seq));
server512fs/ncpfs/ncplib_kernel.cncp_extract_file_info(ncp_reply_data(server, 10), target);
server514fs/ncpfs/ncplib_kernel.cncp_unlock_server(server);
server519fs/ncpfs/ncplib_kernel.cncp_ren_or_mov_file_or_subdir(struct ncp_server *server,
server529fs/ncpfs/ncplib_kernel.cncp_init_request(server);
server530fs/ncpfs/ncplib_kernel.cncp_add_byte(server, 4); /* subfunction */
server531fs/ncpfs/ncplib_kernel.cncp_add_byte(server, 0); /* dos name space */
server532fs/ncpfs/ncplib_kernel.cncp_add_byte(server, 1); /* rename flag */
server533fs/ncpfs/ncplib_kernel.cncp_add_word(server, 0x8006); /* search attributes */
server536fs/ncpfs/ncplib_kernel.cncp_add_byte(server, old_dir->volNumber);
server537fs/ncpfs/ncplib_kernel.cncp_add_dword(server, old_dir->DosDirNum);
server538fs/ncpfs/ncplib_kernel.cncp_add_byte(server, 1);
server539fs/ncpfs/ncplib_kernel.cncp_add_byte(server, 1); /* 1 source component */
server542fs/ncpfs/ncplib_kernel.cncp_add_byte(server, new_dir->volNumber);
server543fs/ncpfs/ncplib_kernel.cncp_add_dword(server, new_dir->DosDirNum);
server544fs/ncpfs/ncplib_kernel.cncp_add_byte(server, 1);
server545fs/ncpfs/ncplib_kernel.cncp_add_byte(server, 1); /* 1 destination component */
server548fs/ncpfs/ncplib_kernel.cncp_add_pstring(server, old_name);
server550fs/ncpfs/ncplib_kernel.cncp_add_pstring(server, new_name);
server552fs/ncpfs/ncplib_kernel.cresult = ncp_request(server, 87);
server553fs/ncpfs/ncplib_kernel.cncp_unlock_server(server);
server560fs/ncpfs/ncplib_kernel.cncp_read(struct ncp_server *server, const char *file_id,
server566fs/ncpfs/ncplib_kernel.cncp_init_request(server);
server567fs/ncpfs/ncplib_kernel.cncp_add_byte(server, 0);
server568fs/ncpfs/ncplib_kernel.cncp_add_mem(server, file_id, 6);
server569fs/ncpfs/ncplib_kernel.cncp_add_dword(server, htonl(offset));
server570fs/ncpfs/ncplib_kernel.cncp_add_word(server, htons(to_read));
server572fs/ncpfs/ncplib_kernel.cif ((result = ncp_request(server, 72)) != 0)
server574fs/ncpfs/ncplib_kernel.cncp_unlock_server(server);
server578fs/ncpfs/ncplib_kernel.c*bytes_read = ntohs(ncp_reply_word(server, 0));
server580fs/ncpfs/ncplib_kernel.cmemcpy_tofs(target, ncp_reply_data(server, 2), *bytes_read);
server582fs/ncpfs/ncplib_kernel.cncp_unlock_server(server);
server587fs/ncpfs/ncplib_kernel.cncp_write(struct ncp_server *server, const char *file_id,
server593fs/ncpfs/ncplib_kernel.cncp_init_request(server);
server594fs/ncpfs/ncplib_kernel.cncp_add_byte(server, 0);
server595fs/ncpfs/ncplib_kernel.cncp_add_mem(server, file_id, 6);
server596fs/ncpfs/ncplib_kernel.cncp_add_dword(server, htonl(offset));
server597fs/ncpfs/ncplib_kernel.cncp_add_word(server, htons(to_write));
server598fs/ncpfs/ncplib_kernel.cncp_add_mem_fromfs(server, source, to_write);
server600fs/ncpfs/ncplib_kernel.cif ((result = ncp_request(server, 73)) != 0)
server602fs/ncpfs/ncplib_kernel.cncp_unlock_server(server);
server608fs/ncpfs/ncplib_kernel.cncp_unlock_server(server);
server19fs/ncpfs/ncplib_kernel.hncp_negotiate_buffersize(struct ncp_server *server, int size,
server22fs/ncpfs/ncplib_kernel.hncp_get_encryption_key(struct ncp_server *server,
server25fs/ncpfs/ncplib_kernel.hncp_get_bindery_object_id(struct ncp_server *server,
server29fs/ncpfs/ncplib_kernel.hncp_login_encrypted(struct ncp_server *server,
server34fs/ncpfs/ncplib_kernel.hncp_login_user(struct ncp_server *server,
server38fs/ncpfs/ncplib_kernel.hncp_get_volume_info_with_number(struct ncp_server *server, int n,
server42fs/ncpfs/ncplib_kernel.hncp_get_volume_number(struct ncp_server *server, const char *name,
server46fs/ncpfs/ncplib_kernel.hncp_file_search_init(struct ncp_server *server,
server51fs/ncpfs/ncplib_kernel.hncp_file_search_continue(struct ncp_server *server,
server57fs/ncpfs/ncplib_kernel.hncp_get_finfo(struct ncp_server *server,
server62fs/ncpfs/ncplib_kernel.hncp_open_file(struct ncp_server *server,
server67fs/ncpfs/ncplib_kernel.hncp_close_file(struct ncp_server *server, const char *file_id);
server70fs/ncpfs/ncplib_kernel.hncp_create_newfile(struct ncp_server *server,
server76fs/ncpfs/ncplib_kernel.hncp_create_file(struct ncp_server *server,
server82fs/ncpfs/ncplib_kernel.hncp_erase_file(struct ncp_server *server,
server87fs/ncpfs/ncplib_kernel.hncp_rename_file(struct ncp_server *server,
server93fs/ncpfs/ncplib_kernel.hncp_create_directory(struct ncp_server *server,
server98fs/ncpfs/ncplib_kernel.hncp_delete_directory(struct ncp_server *server,
server102fs/ncpfs/ncplib_kernel.hncp_rename_directory(struct ncp_server *server,
server107fs/ncpfs/ncplib_kernel.hncp_read(struct ncp_server *server, const char *file_id,
server112fs/ncpfs/ncplib_kernel.hncp_write(struct ncp_server *server, const char *file_id,
server117fs/ncpfs/ncplib_kernel.hncp_do_lookup(struct ncp_server *server,
server123fs/ncpfs/ncplib_kernel.hncp_modify_file_or_subdir_dos_info(struct ncp_server *server,
server129fs/ncpfs/ncplib_kernel.hncp_del_file_or_subdir(struct ncp_server *server,
server133fs/ncpfs/ncplib_kernel.hncp_open_create_file_or_subdir(struct ncp_server *server,
server141fs/ncpfs/ncplib_kernel.hncp_initialize_search(struct ncp_server *server,
server146fs/ncpfs/ncplib_kernel.hncp_search_for_file_or_subdir(struct ncp_server *server,
server151fs/ncpfs/ncplib_kernel.hncp_ren_or_mov_file_or_subdir(struct ncp_server *server,
server128fs/ncpfs/sock.cncp_catch_watchdog(struct ncp_server *server)
server135fs/ncpfs/sock.cif (   (server == NULL)
server136fs/ncpfs/sock.c|| ((file  = server->wdog_filp) == NULL)
server141fs/ncpfs/sock.cserver->data_ready = NULL;
server150fs/ncpfs/sock.cserver->data_ready = NULL;
server159fs/ncpfs/sock.cserver->data_ready = NULL;
server165fs/ncpfs/sock.c(unsigned int)(server->data_ready));
server173fs/ncpfs/sock.cserver->data_ready = sk->data_ready;
server180fs/ncpfs/sock.cncp_dont_catch_watchdog(struct ncp_server *server)
server187fs/ncpfs/sock.cif (   (server == NULL)
server188fs/ncpfs/sock.c|| ((file  = server->wdog_filp) == NULL)
server213fs/ncpfs/sock.cif (server->data_ready == NULL)
server229fs/ncpfs/sock.c(unsigned int)(server->data_ready));
server231fs/ncpfs/sock.csk->data_ready = server->data_ready;
server233fs/ncpfs/sock.cserver->data_ready = NULL;
server244fs/ncpfs/sock.cdo_ncp_rpc_call(struct ncp_server *server, int size)
server251fs/ncpfs/sock.cchar *start = server->packet;
server266fs/ncpfs/sock.c*((struct ncp_request_header *)(server->packet));
server271fs/ncpfs/sock.cfile = server->ncp_filp;
server280fs/ncpfs/sock.cinit_timeout = server->m.time_out;
server282fs/ncpfs/sock.cretrans = server->m.retry_count;
server284fs/ncpfs/sock.cserver_name = server->m.server_name;
server290fs/ncpfs/sock.c| ((server->m.flags & NCP_MOUNT_INTR)
server301fs/ncpfs/sock.chtonl(server->m.serv_addr.sipx_network),
server302fs/ncpfs/sock.cserver->m.serv_addr.sipx_node[0],
server303fs/ncpfs/sock.cserver->m.serv_addr.sipx_node[1],
server304fs/ncpfs/sock.cserver->m.serv_addr.sipx_node[2],
server305fs/ncpfs/sock.cserver->m.serv_addr.sipx_node[3],
server306fs/ncpfs/sock.cserver->m.serv_addr.sipx_node[4],
server307fs/ncpfs/sock.cserver->m.serv_addr.sipx_node[5],
server308fs/ncpfs/sock.cntohs(server->m.serv_addr.sipx_port));
server318fs/ncpfs/sock.c&(server->m.serv_addr),
server319fs/ncpfs/sock.csizeof(server->m.serv_addr));
server355fs/ncpfs/sock.cif (server->m.flags & NCP_MOUNT_SOFT)
server450fs/ncpfs/sock.cresult = _recvfrom(sock, (void *)start, server->packet_size,
server475fs/ncpfs/sock.cncp_do_request(struct ncp_server *server, int size)
server477fs/ncpfs/sock.cif (server->lock == 0)
server483fs/ncpfs/sock.creturn do_ncp_rpc_call(server, size);
server490fs/ncpfs/sock.cncp_request(struct ncp_server *server, int function)
server493fs/ncpfs/sock.c= (struct ncp_request_header *)(server->packet);
server495fs/ncpfs/sock.c= (struct ncp_reply_header *)(server->packet);
server497fs/ncpfs/sock.cint request_size = server->current_size
server502fs/ncpfs/sock.cif (server->has_subfunction != 0)
server509fs/ncpfs/sock.cserver->sequence += 1;
server510fs/ncpfs/sock.ch->sequence  = server->sequence;
server511fs/ncpfs/sock.ch->conn_low  = (server->connection) & 0xff;
server512fs/ncpfs/sock.ch->conn_high = ((server->connection) & 0xff00) >> 8;
server516fs/ncpfs/sock.cif ((result = ncp_do_request(server, request_size + sizeof(*h))) < 0)
server522fs/ncpfs/sock.cserver->completion  = reply->completion_code;
server523fs/ncpfs/sock.cserver->conn_status = reply->connection_state;
server524fs/ncpfs/sock.cserver->reply_size  = result;
server525fs/ncpfs/sock.cserver->ncp_reply_size = result - sizeof(struct ncp_reply_header);
server537fs/ncpfs/sock.cncp_connect(struct ncp_server *server)
server540fs/ncpfs/sock.c= (struct ncp_request_header *)(server->packet);
server545fs/ncpfs/sock.cserver->sequence = 0;
server546fs/ncpfs/sock.ch->sequence  = server->sequence;
server552fs/ncpfs/sock.cif ((result = ncp_do_request(server, sizeof(*h))) < 0)
server557fs/ncpfs/sock.cserver->sequence = 0;
server558fs/ncpfs/sock.cserver->connection = h->conn_low + (h->conn_high * 256);
server563fs/ncpfs/sock.cncp_disconnect(struct ncp_server *server)
server566fs/ncpfs/sock.c= (struct ncp_request_header *)(server->packet);
server570fs/ncpfs/sock.cserver->sequence += 1;
server571fs/ncpfs/sock.ch->sequence  = server->sequence;
server572fs/ncpfs/sock.ch->conn_low  = (server->connection) & 0xff;
server573fs/ncpfs/sock.ch->conn_high = ((server->connection) & 0xff00) >> 8;
server577fs/ncpfs/sock.creturn ncp_do_request(server, sizeof(*h));
server581fs/ncpfs/sock.cncp_lock_server(struct ncp_server *server)
server585fs/ncpfs/sock.cif (server->lock != 0)
server590fs/ncpfs/sock.cwhile (server->lock)
server591fs/ncpfs/sock.csleep_on(&server->wait);
server592fs/ncpfs/sock.cserver->lock = 1;
server596fs/ncpfs/sock.cncp_unlock_server(struct ncp_server *server)
server598fs/ncpfs/sock.cif (server->lock != 1)
server603fs/ncpfs/sock.cserver->lock = 0;
server604fs/ncpfs/sock.cwake_up(&server->wait);
server75fs/nfs/inode.cstruct nfs_server *server;
server113fs/nfs/inode.cserver = &sb->u.nfs_sb.s_server;
server114fs/nfs/inode.cserver->file = filp;
server115fs/nfs/inode.cserver->lock = 0;
server116fs/nfs/inode.cserver->wait = NULL;
server117fs/nfs/inode.cserver->flags = data->flags;
server118fs/nfs/inode.cserver->rsize = data->rsize;
server119fs/nfs/inode.cif (server->rsize <= 0)
server120fs/nfs/inode.cserver->rsize = NFS_DEF_FILE_IO_BUFFER_SIZE;
server121fs/nfs/inode.celse if (server->rsize >= NFS_MAX_FILE_IO_BUFFER_SIZE)
server122fs/nfs/inode.cserver->rsize = NFS_MAX_FILE_IO_BUFFER_SIZE;
server123fs/nfs/inode.cserver->wsize = data->wsize;
server124fs/nfs/inode.cif (server->wsize <= 0)
server125fs/nfs/inode.cserver->wsize = NFS_DEF_FILE_IO_BUFFER_SIZE;
server126fs/nfs/inode.celse if (server->wsize >= NFS_MAX_FILE_IO_BUFFER_SIZE)
server127fs/nfs/inode.cserver->wsize = NFS_MAX_FILE_IO_BUFFER_SIZE;
server128fs/nfs/inode.cserver->timeo = data->timeo*HZ/10;
server129fs/nfs/inode.cserver->retrans = data->retrans;
server130fs/nfs/inode.cserver->acregmin = data->acregmin*HZ;
server131fs/nfs/inode.cserver->acregmax = data->acregmax*HZ;
server132fs/nfs/inode.cserver->acdirmin = data->acdirmin*HZ;
server133fs/nfs/inode.cserver->acdirmax = data->acdirmax*HZ;
server134fs/nfs/inode.cstrcpy(server->hostname, data->hostname);
server139fs/nfs/inode.cif (((struct sockaddr_in *)(&server->toaddr))->sin_addr.s_addr == INADDR_ANY) {
server153fs/nfs/inode.csock->ops->getname(sock, &(server->toaddr), &dummylen, 1) ;
server157fs/nfs/inode.cmemcpy((char *)&(server->toaddr),(char *)(&data->addr),sizeof(server->toaddr));
server161fs/nfs/inode.cif ((server->rsock = rpc_makesock(filp)) == NULL) {
server73fs/nfs/nfsroot.cstatic struct sockaddr_in server;  /* Server IP address */
server250fs/nfs/nfsroot.cif (server.sin_addr.s_addr != INADDR_NONE &&
server251fs/nfs/nfsroot.cserver.sin_addr.s_addr != sip) {
server273fs/nfs/nfsroot.cif (server.sin_addr.s_addr == INADDR_NONE) {
server274fs/nfs/nfsroot.cserver.sin_family = dev->family;
server275fs/nfs/nfsroot.cserver.sin_addr.s_addr = sip;
server346fs/nfs/nfsroot.cprintk("Got RARP answer from %s, ", in_ntoa(server.sin_addr.s_addr));
server421fs/nfs/nfsroot.cserver.sin_addr.s_addr = in_aton(name);
server426fs/nfs/nfsroot.ccp = in_ntoa(server.sin_addr.s_addr);
server508fs/nfs/nfsroot.cmyaddr.sin_family = server.sin_family =
server510fs/nfs/nfsroot.cmyaddr.sin_addr.s_addr = server.sin_addr.s_addr =
server534fs/nfs/nfsroot.cserver.sin_addr.s_addr = in_aton(ip);
server594fs/nfs/nfsroot.cgateway.sin_addr.s_addr == server.sin_addr.s_addr ||
server595fs/nfs/nfsroot.c!((server.sin_addr.s_addr ^ root_dev->pa_addr) & root_dev->pa_mask)) {
server596fs/nfs/nfsroot.c*((struct sockaddr_in *) &(route.rt_dst)) = server;
server603fs/nfs/nfsroot.c*((struct sockaddr_in *) &(route.rt_dst)) = server;
server634fs/nfs/nfsroot.cserver.sin_addr.s_addr == INADDR_NONE ||
server807fs/nfs/nfsroot.c((struct sockaddr_in *) &s.toaddr)->sin_port   = server.sin_port;
server808fs/nfs/nfsroot.c((struct sockaddr_in *) &s.toaddr)->sin_family = server.sin_family;
server809fs/nfs/nfsroot.c((struct sockaddr_in *) &s.toaddr)->sin_addr.s_addr = server.sin_addr.s_addr;
server825fs/nfs/nfsroot.c(struct sockaddr *) &server,
server860fs/nfs/nfsroot.cserver.sin_port = htons(NFS_PMAP_PORT);
server900fs/nfs/nfsroot.cserver.sin_port = htons(port);
server958fs/nfs/nfsroot.cserver.sin_port = htons(nfs_port);
server959fs/nfs/nfsroot.cnfs_data.addr = server;
server962fs/nfs/nfsroot.c(struct sockaddr *) &server,
server225fs/nfs/proc.cint nfs_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle,
server233fs/nfs/proc.cif (!(p0 = nfs_rpc_alloc(server->rsize)))
server238fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p, server->rsize)) < 0) {
server261fs/nfs/proc.cint nfs_proc_setattr(struct nfs_server *server, struct nfs_fh *fhandle,
server269fs/nfs/proc.cif (!(p0 = nfs_rpc_alloc(server->wsize)))
server275fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p, server->wsize)) < 0) {
server298fs/nfs/proc.cint nfs_proc_lookup(struct nfs_server *server, struct nfs_fh *dir, const char *name,
server310fs/nfs/proc.cif (!(p0 = nfs_rpc_alloc(server->rsize)))
server316fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p, server->rsize)) < 0) {
server340fs/nfs/proc.cint nfs_proc_readlink(struct nfs_server *server, struct nfs_fh *fhandle,
server347fs/nfs/proc.cif (!(*p0 = nfs_rpc_alloc(server->rsize)))
server352fs/nfs/proc.cif ((status = nfs_rpc_call(server, *p0, p, server->rsize)) < 0)
server375fs/nfs/proc.cint nfs_proc_read(struct nfs_server *server, struct nfs_fh *fhandle,
server384fs/nfs/proc.cif (!(p0 = nfs_rpc_alloc(server->rsize)))
server392fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p, server->rsize)) < 0) {
server421fs/nfs/proc.cint nfs_proc_write(struct nfs_server *server, struct nfs_fh *fhandle,
server429fs/nfs/proc.cif (!(p0 = nfs_rpc_alloc(server->wsize)))
server438fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p, server->wsize)) < 0) {
server461fs/nfs/proc.cint nfs_proc_create(struct nfs_server *server, struct nfs_fh *dir,
server470fs/nfs/proc.cif (!(p0 = nfs_rpc_alloc(server->wsize)))
server477fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p, server->wsize)) < 0) {
server501fs/nfs/proc.cint nfs_proc_remove(struct nfs_server *server, struct nfs_fh *dir, const char *name)
server508fs/nfs/proc.cif (!(p0 = nfs_rpc_alloc(server->wsize)))
server514fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p, server->wsize)) < 0) {
server536fs/nfs/proc.cint nfs_proc_rename(struct nfs_server *server,
server545fs/nfs/proc.cif (!(p0 = nfs_rpc_alloc(server->wsize)))
server553fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p, server->wsize)) < 0) {
server575fs/nfs/proc.cint nfs_proc_link(struct nfs_server *server, struct nfs_fh *fhandle,
server583fs/nfs/proc.cif (!(p0 = nfs_rpc_alloc(server->wsize)))
server590fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p, server->wsize)) < 0) {
server612fs/nfs/proc.cint nfs_proc_symlink(struct nfs_server *server, struct nfs_fh *dir,
server620fs/nfs/proc.cif (!(p0 = nfs_rpc_alloc(server->wsize)))
server628fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p, server->wsize)) < 0) {
server650fs/nfs/proc.cint nfs_proc_mkdir(struct nfs_server *server, struct nfs_fh *dir,
server659fs/nfs/proc.cif (!(p0 = nfs_rpc_alloc(server->wsize)))
server666fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p, server->wsize)) < 0) {
server690fs/nfs/proc.cint nfs_proc_rmdir(struct nfs_server *server, struct nfs_fh *dir, const char *name)
server697fs/nfs/proc.cif (!(p0 = nfs_rpc_alloc(server->wsize)))
server703fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p, server->wsize)) < 0) {
server725fs/nfs/proc.cint nfs_proc_readdir(struct nfs_server *server, struct nfs_fh *fhandle,
server736fs/nfs/proc.csize = server->rsize;
server737fs/nfs/proc.cif (!(p0 = nfs_rpc_alloc(server->rsize)))
server744fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p, server->rsize)) < 0) {
server781fs/nfs/proc.cint nfs_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle,
server789fs/nfs/proc.cif (!(p0 = nfs_rpc_alloc(server->rsize)))
server794fs/nfs/proc.cif ((status = nfs_rpc_call(server, p0, p, server->rsize)) < 0) {
server51fs/nfs/sock.cnfs_rpc_call(struct nfs_server *server, int *start, int *end, int size)
server58fs/nfs/sock.ctimeout.init_timeout = server->timeo;
server60fs/nfs/sock.ctimeout.retries = server->retrans;
server65fs/nfs/sock.c| ((server->flags & NFS_MOUNT_INTR)
server74fs/nfs/sock.cresult = rpc_call(server->rsock, 
server75fs/nfs/sock.c&server->toaddr, sizeof(server->toaddr),
server82fs/nfs/sock.cif (server->flags & NFS_MOUNT_SOFT) {
server84fs/nfs/sock.c"still trying.\n", server->hostname);
server90fs/nfs/sock.c"timed out.\n", server->hostname);
server98fs/nfs/sock.c} while (result == -ETIMEDOUT && !(server->flags & NFS_MOUNT_SOFT));
server101fs/nfs/sock.cprintk("NFS server %s OK.\n", server->hostname);
server43fs/smbfs/dir.csmb_find_inode(struct smb_server *server, const char *path);
server164fs/smbfs/dir.cstruct smb_server *server = SMB_SERVER(inode);
server217fs/smbfs/dir.cresult = smb_proc_readdir(server, inode,
server235fs/smbfs/dir.cswitch (server->case_handling) 
server271fs/smbfs/dir.cino_info = smb_find_inode(server, complete_path);
server560fs/smbfs/dir.csmb_init_root(struct smb_server *server)
server562fs/smbfs/dir.cstruct smb_inode_info *root = &(server->root);
server564fs/smbfs/dir.croot->finfo.path = server->m.root_path;
server576fs/smbfs/dir.csmb_stat_root(struct smb_server *server)
server578fs/smbfs/dir.cstruct smb_inode_info *root = &(server->root);
server582fs/smbfs/dir.cresult = smb_proc_getattr(server, "\\", 1, &(root->finfo));
server586fs/smbfs/dir.cresult = smb_proc_getattr(server, 
server594fs/smbfs/dir.csmb_free_all_inodes(struct smb_server *server)
server600fs/smbfs/dir.cstruct smb_inode_info *root = &(server->root);
server621fs/smbfs/dir.csmb_invalidate_all_inodes(struct smb_server *server)
server623fs/smbfs/dir.cstruct smb_inode_info *ino = &(server->root);
server628fs/smbfs/dir.c} while (ino != &(server->root));
server639fs/smbfs/dir.csmb_find_inode(struct smb_server *server, const char *path)
server641fs/smbfs/dir.cstruct smb_inode_info *result = &(server->root);
server651fs/smbfs/dir.c} while (result != &(server->root));
server151fs/smbfs/inode.cstruct smb_server *server = &(SMB_SBP(sb)->s_server);
server153fs/smbfs/inode.csmb_proc_disconnect(server);
server154fs/smbfs/inode.cclose_fp(server->sock_file);
server158fs/smbfs/inode.csmb_free_all_inodes(server);
server160fs/smbfs/inode.csmb_kfree_s(server->packet, server->max_xmit);
server176fs/smbfs/inode.cstruct smb_server *server;
server226fs/smbfs/inode.cserver = &(SMB_SBP(sb)->s_server);
server227fs/smbfs/inode.cserver->sock_file = filp;
server228fs/smbfs/inode.cserver->lock = 0;
server229fs/smbfs/inode.cserver->wait = NULL;
server230fs/smbfs/inode.cserver->packet = NULL;
server231fs/smbfs/inode.cserver->max_xmit = data->max_xmit;
server232fs/smbfs/inode.cif (server->max_xmit <= 0)
server233fs/smbfs/inode.cserver->max_xmit = SMB_DEF_MAX_XMIT;
server235fs/smbfs/inode.cserver->tid = 0;
server236fs/smbfs/inode.cserver->pid = current->pid;
server237fs/smbfs/inode.cserver->mid = current->pid + 20;
server239fs/smbfs/inode.cserver->m = *data;
server240fs/smbfs/inode.cserver->m.file_mode = (server->m.file_mode &
server242fs/smbfs/inode.cserver->m.dir_mode  = (server->m.dir_mode &
server245fs/smbfs/inode.csmb_init_root(server);
server251fs/smbfs/inode.cerror = smb_proc_connect(server);
server262fs/smbfs/inode.cif (server->protocol >= PROTOCOL_LANMAN2)
server263fs/smbfs/inode.cserver->case_handling = CASE_DEFAULT;
server265fs/smbfs/inode.cserver->case_handling = CASE_LOWER;
server271fs/smbfs/inode.csmb_kfree_s(server->packet, server->max_xmit);
server275fs/smbfs/inode.cif ((error = smb_stat_root(server)) < 0) {
server278fs/smbfs/inode.csmb_kfree_s(server->packet, server->max_xmit);
server290fs/smbfs/inode.cif (!(sb->s_mounted = iget(sb, (int)&(server->root)))) {
server293fs/smbfs/inode.csmb_kfree_s(server->packet, server->max_xmit);
server388fs/smbfs/proc.csmb_lock_server(struct smb_server *server)
server390fs/smbfs/proc.cwhile (server->lock)
server391fs/smbfs/proc.csleep_on(&server->wait);
server392fs/smbfs/proc.cserver->lock = 1;
server396fs/smbfs/proc.csmb_unlock_server(struct smb_server *server)
server398fs/smbfs/proc.cif (server->lock != 1) {
server402fs/smbfs/proc.cserver->lock = 0;
server403fs/smbfs/proc.cwake_up(&server->wait);
server444fs/smbfs/proc.csmb_retry(struct smb_server *server)
server446fs/smbfs/proc.cif (server->state != CONN_INVALID) {
server450fs/smbfs/proc.cif (smb_release(server) < 0) {
server452fs/smbfs/proc.cserver->state = CONN_RETRIED;
server455fs/smbfs/proc.cif(smb_proc_reconnect(server) < 0) {
server457fs/smbfs/proc.cserver->state = CONN_RETRIED;
server461fs/smbfs/proc.cserver->state = CONN_VALID;
server479fs/smbfs/proc.csmb_setup_header(struct smb_server *server, byte command, word wct, word bcc)
server482fs/smbfs/proc.cbyte *p = server->packet;
server483fs/smbfs/proc.cbyte *buf = server->packet;
server498fs/smbfs/proc.cWSET(buf, smb_tid, server->tid);
server499fs/smbfs/proc.cWSET(buf, smb_pid, server->pid);
server500fs/smbfs/proc.cWSET(buf, smb_uid, server->server_uid);
server501fs/smbfs/proc.cWSET(buf, smb_mid, server->mid);
server503fs/smbfs/proc.cif (server->protocol > PROTOCOL_CORE) {
server519fs/smbfs/proc.csmb_setup_header_exclusive(struct smb_server *server,
server522fs/smbfs/proc.csmb_lock_server(server);
server523fs/smbfs/proc.creturn smb_setup_header(server, command, wct, bcc);
server534fs/smbfs/proc.csmb_proc_open(struct smb_server *server, const char *pathname, int len,
server539fs/smbfs/proc.cchar* buf = server->packet;
server544fs/smbfs/proc.csmb_lock_server(server);
server547fs/smbfs/proc.cp = smb_setup_header(server, SMBopen, 2, 2 + len);
server552fs/smbfs/proc.cif ((error = smb_request_ok(server, SMBopen, 7, 0)) != 0) {
server554fs/smbfs/proc.cif (smb_retry(server)) {
server559fs/smbfs/proc.csmb_unlock_server(server);
server563fs/smbfs/proc.cp = smb_setup_header(server, SMBopen, 2, 2 + len);
server568fs/smbfs/proc.cif ((error = smb_request_ok(server, SMBopen, 7, 0)) != 0) {
server569fs/smbfs/proc.cif (smb_retry(server)) {
server572fs/smbfs/proc.csmb_unlock_server(server);
server586fs/smbfs/proc.csmb_unlock_server(server);
server596fs/smbfs/proc.csmb_proc_close(struct smb_server *server, struct smb_dirent *finfo)
server598fs/smbfs/proc.cchar *buf = server->packet;
server600fs/smbfs/proc.csmb_setup_header_exclusive(server, SMBclose, 3, 0);
server604fs/smbfs/proc.creturn smb_request_ok_unlock(server, SMBclose, 0, 0);
server614fs/smbfs/proc.csmb_proc_read(struct smb_server *server, struct smb_dirent *finfo, 
server618fs/smbfs/proc.cchar *buf = server->packet;
server621fs/smbfs/proc.csmb_setup_header_exclusive(server, SMBread, 5, 0);
server628fs/smbfs/proc.cif ((error = smb_request_ok(server, SMBread, 5, -1)) < 0) {
server629fs/smbfs/proc.csmb_unlock_server(server);
server635fs/smbfs/proc.csmb_decode_data(SMB_BUF(server->packet), data, &data_len, fs);
server637fs/smbfs/proc.csmb_unlock_server(server);
server652fs/smbfs/proc.csmb_proc_read_raw(struct smb_server *server, struct smb_dirent *finfo, 
server655fs/smbfs/proc.cchar *buf = server->packet;
server662fs/smbfs/proc.csmb_setup_header_exclusive(server, SMBreadbraw, 8, 0);
server670fs/smbfs/proc.cresult = smb_request_read_raw(server, data, count);
server671fs/smbfs/proc.csmb_unlock_server(server);
server676fs/smbfs/proc.csmb_proc_write(struct smb_server *server, struct smb_dirent *finfo,
server680fs/smbfs/proc.cchar *buf = server->packet;
server683fs/smbfs/proc.cp = smb_setup_header_exclusive(server, SMBwrite, 5, count + 3);
server693fs/smbfs/proc.cif ((res = smb_request_ok(server, SMBwrite, 1, 0)) >= 0) {
server697fs/smbfs/proc.csmb_unlock_server(server);
server704fs/smbfs/proc.csmb_proc_write_raw(struct smb_server *server, struct smb_dirent *finfo, 
server707fs/smbfs/proc.cchar *buf = server->packet;
server714fs/smbfs/proc.csmb_setup_header_exclusive(server, SMBwritebraw, 11, 0);
server726fs/smbfs/proc.cresult = smb_request_ok(server, SMBwritebraw, 1, 0);
server731fs/smbfs/proc.csmb_unlock_server(server);
server735fs/smbfs/proc.cresult = smb_request_write_raw(server, data, count);
server741fs/smbfs/proc.cif (smb_valid_packet(server->packet) != 0) {
server744fs/smbfs/proc.c} else if (server->rcls != 0) {
server745fs/smbfs/proc.cresult = -smb_errno(server->rcls, server->err);
server746fs/smbfs/proc.c} else if (smb_verify(server->packet, SMBwritec,1,0) != 0) {
server752fs/smbfs/proc.csmb_unlock_server(server);
server760fs/smbfs/proc.csmb_proc_do_create(struct smb_server *server, const char *path, int len, 
server765fs/smbfs/proc.cchar *buf = server->packet;
server767fs/smbfs/proc.csmb_lock_server(server);
server769fs/smbfs/proc.cp = smb_setup_header(server, command, 3, len + 2);
server774fs/smbfs/proc.cif ((error = smb_request_ok(server, command, 1, 0)) < 0) {
server775fs/smbfs/proc.cif (smb_retry(server)) {
server778fs/smbfs/proc.csmb_unlock_server(server);
server784fs/smbfs/proc.csmb_unlock_server(server);
server786fs/smbfs/proc.csmb_proc_close(server, entry);
server792fs/smbfs/proc.csmb_proc_create(struct smb_server *server, const char *path, int len,
server795fs/smbfs/proc.creturn smb_proc_do_create(server, path, len, entry, SMBcreate);
server799fs/smbfs/proc.csmb_proc_mknew(struct smb_server *server, const char *path, int len,
server802fs/smbfs/proc.creturn smb_proc_do_create(server, path, len, entry, SMBmknew);
server806fs/smbfs/proc.csmb_proc_mv(struct smb_server *server, 
server811fs/smbfs/proc.cchar *buf = server->packet;
server814fs/smbfs/proc.csmb_lock_server(server);
server817fs/smbfs/proc.cp = smb_setup_header(server, SMBmv, 1, olen + nlen + 4);
server822fs/smbfs/proc.cif ((result = smb_request_ok(server, SMBmv, 0, 0)) < 0) {
server823fs/smbfs/proc.cif (smb_retry(server)) {
server827fs/smbfs/proc.csmb_unlock_server(server);
server832fs/smbfs/proc.csmb_proc_mkdir(struct smb_server *server, const char *path, const int len)
server837fs/smbfs/proc.csmb_lock_server(server);
server840fs/smbfs/proc.cp = smb_setup_header(server, SMBmkdir, 0, 2 + len);
server843fs/smbfs/proc.cif ((result = smb_request_ok(server, SMBmkdir, 0, 0)) < 0) {
server844fs/smbfs/proc.cif (smb_retry(server)) {
server848fs/smbfs/proc.csmb_unlock_server(server);
server853fs/smbfs/proc.csmb_proc_rmdir(struct smb_server *server, const char *path, const int len)
server858fs/smbfs/proc.csmb_lock_server(server);
server861fs/smbfs/proc.cp = smb_setup_header(server, SMBrmdir, 0, 2 + len);
server864fs/smbfs/proc.cif ((result = smb_request_ok(server, SMBrmdir, 0, 0)) < 0) {
server865fs/smbfs/proc.cif (smb_retry(server)) {
server869fs/smbfs/proc.csmb_unlock_server(server);
server874fs/smbfs/proc.csmb_proc_unlink(struct smb_server *server, const char *path, const int len)
server877fs/smbfs/proc.cchar *buf = server->packet;
server880fs/smbfs/proc.csmb_lock_server(server);
server883fs/smbfs/proc.cp = smb_setup_header(server, SMBunlink, 1, 2 + len);
server887fs/smbfs/proc.cif ((result = smb_request_ok(server, SMBunlink, 0, 0)) < 0) {
server888fs/smbfs/proc.cif (smb_retry(server)) {
server892fs/smbfs/proc.csmb_unlock_server(server);
server897fs/smbfs/proc.csmb_proc_trunc(struct smb_server *server, word fid, dword length)
server900fs/smbfs/proc.cchar *buf = server->packet;
server903fs/smbfs/proc.csmb_lock_server(server);
server906fs/smbfs/proc.cp = smb_setup_header(server, SMBwrite, 5, 3);
server913fs/smbfs/proc.cif ((result = smb_request_ok(server, SMBwrite, 1, 0)) < 0) {
server914fs/smbfs/proc.cif (smb_retry(server)) {
server918fs/smbfs/proc.csmb_unlock_server(server);
server940fs/smbfs/proc.csmb_proc_readdir_short(struct smb_server *server, struct inode *dir, int fpos,
server953fs/smbfs/proc.cint entries_asked = (server->max_xmit - 100) / SMB_DIRINFO_SIZE;
server963fs/smbfs/proc.cbuf = server->packet;
server965fs/smbfs/proc.csmb_lock_server(server);
server974fs/smbfs/proc.cp = smb_setup_header(server, SMBsearch, 2,
server982fs/smbfs/proc.cp = smb_setup_header(server, SMBsearch, 2,
server990fs/smbfs/proc.cif ((error = smb_request_ok(server, SMBsearch, 1, -1)) < 0) {
server991fs/smbfs/proc.cif (   (server->rcls == ERRDOS)
server992fs/smbfs/proc.c&& (server->err  == ERRnofiles)) {
server998fs/smbfs/proc.cif (smb_retry(server)) {
server1006fs/smbfs/proc.cp = SMB_VWV(server->packet);
server1025fs/smbfs/proc.cSMB_BUF(server->packet) + 3 +
server1054fs/smbfs/proc.csmb_unlock_server(server);
server1144fs/smbfs/proc.csmb_proc_readdir_long(struct smb_server *server, struct inode *dir, int fpos,
server1185fs/smbfs/proc.csmb_lock_server(server);
server1196fs/smbfs/proc.cunsigned char *outbuf = server->packet;
server1206fs/smbfs/proc.csmb_setup_header(server, SMBtrans2, 15,
server1257fs/smbfs/proc.cresult = smb_trans2_request(server,
server1262fs/smbfs/proc.cif (smb_retry(server)) {
server1270fs/smbfs/proc.cif (server->rcls != 0)
server1366fs/smbfs/proc.csmb_unlock_server(server);
server1372fs/smbfs/proc.csmb_proc_readdir(struct smb_server *server, struct inode *dir, int fpos,
server1375fs/smbfs/proc.cif (server->protocol >= PROTOCOL_LANMAN2)
server1376fs/smbfs/proc.creturn smb_proc_readdir_long(server, dir, fpos, cache_size,
server1379fs/smbfs/proc.creturn smb_proc_readdir_short(server, dir, fpos, cache_size,
server1384fs/smbfs/proc.csmb_proc_getattr_core(struct smb_server *server, const char *path, int len, 
server1389fs/smbfs/proc.cchar *buf = server->packet;
server1391fs/smbfs/proc.csmb_lock_server(server);
server1396fs/smbfs/proc.cp = smb_setup_header(server, SMBgetatr, 0, 2 + len);
server1399fs/smbfs/proc.cif ((result = smb_request_ok(server, SMBgetatr, 10, 0)) < 0) {
server1400fs/smbfs/proc.cif (smb_retry(server)) {
server1403fs/smbfs/proc.csmb_unlock_server(server);
server1412fs/smbfs/proc.csmb_unlock_server(server);
server1419fs/smbfs/proc.csmb_proc_getattrE(struct smb_server *server, struct smb_dirent *entry)
server1421fs/smbfs/proc.cchar* buf = server->packet;
server1424fs/smbfs/proc.csmb_setup_header_exclusive(server, SMBgetattrE, 1, 0);
server1427fs/smbfs/proc.cif ((result = smb_request_ok(server, SMBgetattrE, 11, 0)) != 0) {
server1428fs/smbfs/proc.csmb_unlock_server(server);
server1438fs/smbfs/proc.csmb_unlock_server(server);
server1443fs/smbfs/proc.csmb_proc_getattr(struct smb_server *server, const char *path, int len, 
server1446fs/smbfs/proc.cif (server->protocol >= PROTOCOL_LANMAN1) {
server1451fs/smbfs/proc.cif ((result=smb_proc_open(server,path,len,
server1455fs/smbfs/proc.creturn smb_proc_getattr_core(server,path,len,entry);
server1458fs/smbfs/proc.cif ((result=smb_proc_getattrE(server, &temp_entry)) >= 0) {
server1466fs/smbfs/proc.csmb_proc_close(server, &temp_entry);
server1470fs/smbfs/proc.creturn smb_proc_getattr_core(server, path, len, entry);
server1478fs/smbfs/proc.csmb_proc_setattr_core(struct smb_server *server,
server1483fs/smbfs/proc.cchar *buf = server->packet;
server1486fs/smbfs/proc.csmb_lock_server(server);
server1489fs/smbfs/proc.cp = smb_setup_header(server, SMBsetatr, 8, 4 + len);
server1495fs/smbfs/proc.cif ((result = smb_request_ok(server, SMBsetatr, 0, 0)) < 0) {
server1496fs/smbfs/proc.cif (smb_retry(server)) {
server1500fs/smbfs/proc.csmb_unlock_server(server);
server1507fs/smbfs/proc.csmb_proc_setattrE(struct smb_server *server, word fid,
server1510fs/smbfs/proc.cchar *buf = server->packet;
server1513fs/smbfs/proc.csmb_setup_header_exclusive(server, SMBsetattrE, 7, 0);
server1529fs/smbfs/proc.creturn smb_request_ok_unlock(server, SMBsetattrE, 0, 0);
server1535fs/smbfs/proc.csmb_proc_setattr(struct smb_server *server, struct inode *inode,
server1541fs/smbfs/proc.cif (server->protocol >= PROTOCOL_LANMAN1) {
server1544fs/smbfs/proc.creturn smb_proc_setattrE(server, finfo->fileid, new_finfo);
server1546fs/smbfs/proc.creturn smb_proc_setattr_core(server, finfo->path, finfo->len,
server1556fs/smbfs/proc.cstruct smb_server *server = &(SMB_SBP(super)->s_server);
server1558fs/smbfs/proc.csmb_lock_server(server);
server1561fs/smbfs/proc.csmb_setup_header(server, SMBdskattr, 0, 0);
server1563fs/smbfs/proc.cif ((error = smb_request_ok(server, SMBdskattr, 5, 0)) < 0) {
server1564fs/smbfs/proc.cif (smb_retry(server)) {
server1567fs/smbfs/proc.csmb_unlock_server(server);
server1571fs/smbfs/proc.cp = SMB_VWV(server->packet);
server1576fs/smbfs/proc.csmb_unlock_server(server);
server1597fs/smbfs/proc.csmb_proc_reconnect(struct smb_server *server)
server1617fs/smbfs/proc.cint given_max_xmit = server->m.max_xmit;
server1621fs/smbfs/proc.cif ((result = smb_connect(server)) < 0) {
server1627fs/smbfs/proc.cserver->state = CONN_VALID;
server1629fs/smbfs/proc.cif (server->packet != NULL) {
server1630fs/smbfs/proc.csmb_kfree_s(server->packet, server->max_xmit);
server1633fs/smbfs/proc.cserver->packet = smb_kmalloc(max_xmit, GFP_KERNEL);
server1635fs/smbfs/proc.cif (server->packet == NULL) {
server1641fs/smbfs/proc.cserver->max_xmit = max_xmit;
server1646fs/smbfs/proc.cp = server->packet + 4;
server1648fs/smbfs/proc.cp = smb_name_mangle(p, server->m.server_name);
server1649fs/smbfs/proc.cp = smb_name_mangle(p, server->m.client_name);
server1651fs/smbfs/proc.csmb_encode_smb_length(server->packet,
server1652fs/smbfs/proc.c(void *)p - (void *)(server->packet));
server1654fs/smbfs/proc.cserver->packet[0] = 0x81; /* SESSION REQUEST */
server1656fs/smbfs/proc.cif (smb_catch_keepalive(server) < 0) {
server1660fs/smbfs/proc.cif ((result = smb_request(server)) < 0) {
server1662fs/smbfs/proc.csmb_dont_catch_keepalive(server);
server1666fs/smbfs/proc.cif (server->packet[0] != 0x82) {
server1669fs/smbfs/proc.cserver->packet[0]);
server1670fs/smbfs/proc.csmb_dont_catch_keepalive(server);
server1672fs/smbfs/proc.csmb_dump_packet(server->packet);
server1681fs/smbfs/proc.cmemset(server->packet, 0, SMB_HEADER_LEN);
server1688fs/smbfs/proc.csmb_setup_header(server, SMBnegprot, 0, plength);
server1690fs/smbfs/proc.cp = SMB_BUF(server->packet);
server1696fs/smbfs/proc.cif ((result = smb_request_ok(server, SMBnegprot, 1, -1)) < 0) {
server1698fs/smbfs/proc.csmb_dont_catch_keepalive(server);
server1706fs/smbfs/proc.cp = SMB_VWV(server->packet);
server1708fs/smbfs/proc.cserver->protocol = prots[i].prot;
server1713fs/smbfs/proc.cif (server->protocol > PROTOCOL_LANMAN1) {
server1715fs/smbfs/proc.cword passlen = strlen(server->m.password);
server1716fs/smbfs/proc.cword userlen = strlen(server->m.username);
server1719fs/smbfs/proc.cserver->m.password);
server1721fs/smbfs/proc.cserver->m.username);
server1723fs/smbfs/proc.cWVAL(server->packet, smb_vwv5));
server1725fs/smbfs/proc.cif (server->protocol >= PROTOCOL_NT1) {
server1726fs/smbfs/proc.cserver->maxxmt = DVAL(server->packet,smb_vwv3+1);
server1727fs/smbfs/proc.cserver->maxmux = WVAL(server->packet, smb_vwv1+1);
server1728fs/smbfs/proc.cserver->maxvcs = WVAL(server->packet, smb_vwv2+1);
server1729fs/smbfs/proc.cserver->blkmode= DVAL(server->packet, smb_vwv9+1);
server1730fs/smbfs/proc.cserver->sesskey= DVAL(server->packet, smb_vwv7+1);
server1732fs/smbfs/proc.cserver->maxxmt = WVAL(server->packet, smb_vwv2);
server1733fs/smbfs/proc.cserver->maxmux = WVAL(server->packet, smb_vwv3);
server1734fs/smbfs/proc.cserver->maxvcs = WVAL(server->packet, smb_vwv4);
server1735fs/smbfs/proc.cserver->blkmode= WVAL(server->packet, smb_vwv5);
server1736fs/smbfs/proc.cserver->sesskey= DVAL(server->packet, smb_vwv6);
server1740fs/smbfs/proc.cif (server->protocol >= PROTOCOL_NT1) {
server1745fs/smbfs/proc.csmb_setup_header(server, SMBsesssetupX, 13,
server1750fs/smbfs/proc.cWSET(server->packet, smb_vwv0, 0x00ff);
server1751fs/smbfs/proc.cWSET(server->packet, smb_vwv1, 0);
server1752fs/smbfs/proc.cWSET(server->packet, smb_vwv2, given_max_xmit);
server1753fs/smbfs/proc.cWSET(server->packet, smb_vwv3, 2);
server1754fs/smbfs/proc.cWSET(server->packet, smb_vwv4, server->pid);
server1755fs/smbfs/proc.cDSET(server->packet, smb_vwv5, server->sesskey);
server1756fs/smbfs/proc.cWSET(server->packet, smb_vwv7, passlen + 1);
server1757fs/smbfs/proc.cWSET(server->packet, smb_vwv8, 0);
server1758fs/smbfs/proc.cWSET(server->packet, smb_vwv9, 0);
server1760fs/smbfs/proc.cp = SMB_BUF(server->packet);
server1761fs/smbfs/proc.cstrcpy(p, server->m.password);
server1763fs/smbfs/proc.cstrcpy(p, server->m.username);
server1771fs/smbfs/proc.csmb_setup_header(server, SMBsesssetupX, 10,
server1774fs/smbfs/proc.cWSET(server->packet, smb_vwv0, 0x00ff);
server1775fs/smbfs/proc.cWSET(server->packet, smb_vwv1, 0);
server1776fs/smbfs/proc.cWSET(server->packet, smb_vwv2, given_max_xmit);
server1777fs/smbfs/proc.cWSET(server->packet, smb_vwv3, 2);
server1778fs/smbfs/proc.cWSET(server->packet, smb_vwv4, server->pid);
server1779fs/smbfs/proc.cDSET(server->packet, smb_vwv5, server->sesskey);
server1780fs/smbfs/proc.cWSET(server->packet, smb_vwv7, passlen + 1);
server1781fs/smbfs/proc.cWSET(server->packet, smb_vwv8, 0);
server1782fs/smbfs/proc.cWSET(server->packet, smb_vwv9, 0);
server1784fs/smbfs/proc.cp = SMB_BUF(server->packet);
server1785fs/smbfs/proc.cstrcpy(p, server->m.password);
server1787fs/smbfs/proc.cstrcpy(p, server->m.username);
server1790fs/smbfs/proc.cif ((result = smb_request_ok(server,SMBsesssetupX,3,0)) < 0) {
server1792fs/smbfs/proc.csmb_dont_catch_keepalive(server);
server1795fs/smbfs/proc.csmb_decode_word(server->packet+32, &(server->server_uid));
server1800fs/smbfs/proc.cserver->maxxmt = 0;
server1801fs/smbfs/proc.cserver->maxmux = 0;
server1802fs/smbfs/proc.cserver->maxvcs = 0;
server1803fs/smbfs/proc.cserver->blkmode = 0;
server1804fs/smbfs/proc.cserver->sesskey = 0;
server1809fs/smbfs/proc.csmb_setup_header(server, SMBtcon, 0,
server1810fs/smbfs/proc.c6 + strlen(server->m.service) +
server1811fs/smbfs/proc.cstrlen(server->m.password) + strlen(dev));
server1812fs/smbfs/proc.cp = SMB_BUF(server->packet);
server1813fs/smbfs/proc.cp = smb_encode_ascii(p, server->m.service, strlen(server->m.service));
server1814fs/smbfs/proc.cp = smb_encode_ascii(p,server->m.password, strlen(server->m.password));
server1817fs/smbfs/proc.cif ((result = smb_request_ok(server, SMBtcon, 2, 0)) < 0) {
server1819fs/smbfs/proc.csmb_dont_catch_keepalive(server);
server1825fs/smbfs/proc.cp = SMB_VWV(server->packet);
server1826fs/smbfs/proc.cp = smb_decode_word(p, &server->max_xmit);
server1828fs/smbfs/proc.cif (server->max_xmit > given_max_xmit)
server1829fs/smbfs/proc.cserver->max_xmit = given_max_xmit;
server1831fs/smbfs/proc.cp = smb_decode_word(p, &server->tid);
server1835fs/smbfs/proc.cserver->max_xmit += 4;
server1837fs/smbfs/proc.cDPRINTK("max_xmit = %d, tid = %d\n", server->max_xmit, server->tid);
server1840fs/smbfs/proc.csmb_kfree_s(server->packet, max_xmit); 
server1842fs/smbfs/proc.cserver->packet = smb_kmalloc(server->max_xmit, GFP_KERNEL);
server1843fs/smbfs/proc.cif (server->packet == NULL) {
server1846fs/smbfs/proc.csmb_dont_catch_keepalive(server);
server1854fs/smbfs/proc.cserver->state = CONN_INVALID;
server1861fs/smbfs/proc.csmb_proc_connect(struct smb_server *server)
server1864fs/smbfs/proc.csmb_lock_server(server);
server1865fs/smbfs/proc.cresult = smb_proc_reconnect(server);
server1866fs/smbfs/proc.cif ((result < 0) && (server->packet != NULL)) {
server1867fs/smbfs/proc.csmb_kfree_s(server->packet, server->max_xmit);
server1868fs/smbfs/proc.cserver->packet = NULL;
server1870fs/smbfs/proc.csmb_unlock_server(server);
server1875fs/smbfs/proc.csmb_proc_disconnect(struct smb_server *server)
server1877fs/smbfs/proc.csmb_setup_header_exclusive(server, SMBtdis, 0, 0);
server1878fs/smbfs/proc.creturn smb_request_ok_unlock(server, SMBtdis, 0, 0);
server107fs/smbfs/sock.csmb_catch_keepalive(struct smb_server *server)
server114fs/smbfs/sock.cif (   (server == NULL)
server115fs/smbfs/sock.c|| ((file  = server->sock_file) == NULL)
server120fs/smbfs/sock.cserver->data_ready = NULL;
server128fs/smbfs/sock.cserver->data_ready = NULL;
server136fs/smbfs/sock.cserver->data_ready = NULL;
server142fs/smbfs/sock.c(unsigned int)(server->data_ready));
server149fs/smbfs/sock.cserver->data_ready = sk->data_ready;
server155fs/smbfs/sock.csmb_dont_catch_keepalive(struct smb_server *server)
server162fs/smbfs/sock.cif (   (server == NULL)
server163fs/smbfs/sock.c|| ((file  = server->sock_file) == NULL)
server186fs/smbfs/sock.cif (server->data_ready == NULL) {
server200fs/smbfs/sock.c(unsigned int)(server->data_ready));
server202fs/smbfs/sock.csk->data_ready = server->data_ready;
server203fs/smbfs/sock.cserver->data_ready = NULL;
server294fs/smbfs/sock.csmb_receive(struct smb_server *server, struct socket *sock)
server298fs/smbfs/sock.cresult = smb_receive_raw(sock, server->packet,
server299fs/smbfs/sock.cserver->max_xmit - 4, /* max_xmit in server
server308fs/smbfs/sock.cserver->rcls = *((unsigned char *)(server->packet+9));
server309fs/smbfs/sock.cserver->err  = *((unsigned short *)(server->packet+11));
server311fs/smbfs/sock.cif (server->rcls != 0) {
server313fs/smbfs/sock.cserver->rcls, server->err);
server324fs/smbfs/sock.csmb_receive_trans2(struct smb_server *server, struct socket *sock,
server331fs/smbfs/sock.cunsigned char *inbuf = server->packet;
server337fs/smbfs/sock.cif ((result = smb_receive(server, sock)) < 0) {
server341fs/smbfs/sock.cif (server->rcls != 0) {
server412fs/smbfs/sock.cif ((result = smb_receive(server, sock)) < 0) {
server415fs/smbfs/sock.cif (server->rcls != 0) {
server434fs/smbfs/sock.cserver_sock(struct smb_server *server)
server439fs/smbfs/sock.cif (server == NULL)
server441fs/smbfs/sock.cif ((file = server->sock_file) == NULL)
server449fs/smbfs/sock.csmb_release(struct smb_server *server)
server451fs/smbfs/sock.cstruct socket *sock = server_sock(server);
server471fs/smbfs/sock.csmb_connect(struct smb_server *server)
server473fs/smbfs/sock.cstruct socket *sock = server_sock(server);
server480fs/smbfs/sock.creturn sock->ops->connect(sock, (struct sockaddr *)&(server->m.addr),
server491fs/smbfs/sock.csmb_request(struct smb_server *server)
server498fs/smbfs/sock.cstruct socket *sock = server_sock(server);
server499fs/smbfs/sock.cunsigned char *buffer = (server == NULL) ? NULL : server->packet;
server506fs/smbfs/sock.cif (server->state != CONN_VALID)
server509fs/smbfs/sock.cif ((result = smb_dont_catch_keepalive(server)) != 0) {
server510fs/smbfs/sock.cserver->state = CONN_INVALID;
server511fs/smbfs/sock.csmb_invalidate_all_inodes(server);
server529fs/smbfs/sock.cresult = smb_receive(server, sock);
server538fs/smbfs/sock.cif ((result2 = smb_catch_keepalive(server)) < 0) {
server543fs/smbfs/sock.cserver->state = CONN_INVALID;
server544fs/smbfs/sock.csmb_invalidate_all_inodes(server);
server557fs/smbfs/sock.csmb_trans2_request(struct smb_server *server,
server566fs/smbfs/sock.cstruct socket *sock = server_sock(server);
server567fs/smbfs/sock.cunsigned char *buffer = (server == NULL) ? NULL : server->packet;
server574fs/smbfs/sock.cif (server->state != CONN_VALID)
server577fs/smbfs/sock.cif ((result = smb_dont_catch_keepalive(server)) != 0) {
server578fs/smbfs/sock.cserver->state = CONN_INVALID;
server579fs/smbfs/sock.csmb_invalidate_all_inodes(server);
server597fs/smbfs/sock.cresult = smb_receive_trans2(server, sock,
server608fs/smbfs/sock.cif ((result2 = smb_catch_keepalive(server)) < 0) {
server613fs/smbfs/sock.cserver->state = CONN_INVALID;
server614fs/smbfs/sock.csmb_invalidate_all_inodes(server);
server624fs/smbfs/sock.csmb_request_read_raw(struct smb_server *server,
server632fs/smbfs/sock.cstruct socket *sock = server_sock(server);
server633fs/smbfs/sock.cunsigned char *buffer = (server == NULL) ? NULL : server->packet;
server640fs/smbfs/sock.cif (server->state != CONN_VALID)
server643fs/smbfs/sock.cif ((result = smb_dont_catch_keepalive(server)) != 0) {
server644fs/smbfs/sock.cserver->state = CONN_INVALID;
server645fs/smbfs/sock.csmb_invalidate_all_inodes(server);
server680fs/smbfs/sock.cif ((result2 = smb_catch_keepalive(server)) < 0) {
server685fs/smbfs/sock.cserver->state = CONN_INVALID;
server686fs/smbfs/sock.csmb_invalidate_all_inodes(server);
server698fs/smbfs/sock.csmb_request_write_raw(struct smb_server *server,
server707fs/smbfs/sock.cstruct socket *sock = server_sock(server);
server708fs/smbfs/sock.cunsigned char *buffer = (server == NULL) ? NULL : server->packet;
server715fs/smbfs/sock.cif (server->state != CONN_VALID)
server718fs/smbfs/sock.cif ((result = smb_dont_catch_keepalive(server)) != 0) {
server719fs/smbfs/sock.cserver->state = CONN_INVALID;
server720fs/smbfs/sock.csmb_invalidate_all_inodes(server);
server744fs/smbfs/sock.cresult = smb_receive(server, sock);
server754fs/smbfs/sock.cif ((result2 = smb_catch_keepalive(server)) < 0) {
server759fs/smbfs/sock.cserver->state = CONN_INVALID;
server760fs/smbfs/sock.csmb_invalidate_all_inodes(server);
server127include/linux/ncp_fs.hvoid ncp_free_all_inodes(struct ncp_server *server);
server128include/linux/ncp_fs.hvoid ncp_init_root(struct ncp_server *server);
server129include/linux/ncp_fs.hint  ncp_stat_root(struct ncp_server *server);
server132include/linux/ncp_fs.hvoid ncp_invalidate_all_inodes(struct ncp_server *server);
server145include/linux/ncp_fs.hvoid ncp_invalidate_connection(struct ncp_server *server);
server146include/linux/ncp_fs.hint ncp_conn_is_valid(struct ncp_server *server);
server149include/linux/ncp_fs.hint ncp_request(struct ncp_server *server, int function);
server150include/linux/ncp_fs.hint ncp_connect(struct ncp_server *server);
server151include/linux/ncp_fs.hint ncp_disconnect(struct ncp_server *server);
server152include/linux/ncp_fs.hint ncp_catch_watchdog(struct ncp_server *server);
server153include/linux/ncp_fs.hint ncp_dont_catch_watchdog(struct ncp_server *server);
server154include/linux/ncp_fs.hvoid ncp_lock_server(struct ncp_server *server);
server155include/linux/ncp_fs.hvoid ncp_unlock_server(struct ncp_server *server);
server52include/linux/nfs_fs.hextern int nfs_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle,
server54include/linux/nfs_fs.hextern int nfs_proc_setattr(struct nfs_server *server, struct nfs_fh *fhandle,
server56include/linux/nfs_fs.hextern int nfs_proc_lookup(struct nfs_server *server, struct nfs_fh *dir,
server59include/linux/nfs_fs.hextern int nfs_proc_readlink(struct nfs_server *server, struct nfs_fh *fhandle,
server62include/linux/nfs_fs.hextern int nfs_proc_read(struct nfs_server *server, struct nfs_fh *fhandle,
server65include/linux/nfs_fs.hextern int nfs_proc_write(struct nfs_server *server, struct nfs_fh *fhandle,
server68include/linux/nfs_fs.hextern int nfs_proc_create(struct nfs_server *server, struct nfs_fh *dir,
server71include/linux/nfs_fs.hextern int nfs_proc_remove(struct nfs_server *server, struct nfs_fh *dir,
server73include/linux/nfs_fs.hextern int nfs_proc_rename(struct nfs_server *server,
server76include/linux/nfs_fs.hextern int nfs_proc_link(struct nfs_server *server, struct nfs_fh *fhandle,
server78include/linux/nfs_fs.hextern int nfs_proc_symlink(struct nfs_server *server, struct nfs_fh *dir,
server80include/linux/nfs_fs.hextern int nfs_proc_mkdir(struct nfs_server *server, struct nfs_fh *dir,
server83include/linux/nfs_fs.hextern int nfs_proc_rmdir(struct nfs_server *server, struct nfs_fh *dir,
server85include/linux/nfs_fs.hextern int nfs_proc_readdir(struct nfs_server *server, struct nfs_fh *fhandle,
server87include/linux/nfs_fs.hextern int nfs_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle,
server95include/linux/nfs_fs.hextern int nfs_rpc_call(struct nfs_server *server, int *start, int *end, int size);
server102include/linux/smb_fs.hvoid smb_free_all_inodes(struct smb_server *server);
server103include/linux/smb_fs.hvoid smb_init_root(struct smb_server *server);
server104include/linux/smb_fs.hint  smb_stat_root(struct smb_server *server);
server107include/linux/smb_fs.hvoid smb_invalidate_all_inodes(struct smb_server *server);
server118include/linux/smb_fs.hvoid smb_invalidate_connection(struct smb_server *server);
server119include/linux/smb_fs.hint smb_conn_is_valid(struct smb_server *server);
server124include/linux/smb_fs.hint smb_proc_open(struct smb_server *server, const char *pathname,
server126include/linux/smb_fs.hint smb_proc_close(struct smb_server *server, struct smb_dirent *finfo);
server127include/linux/smb_fs.hint smb_proc_read(struct smb_server *server, struct smb_dirent *finfo, 
server129include/linux/smb_fs.hint smb_proc_read_raw(struct smb_server *server, struct smb_dirent *finfo, 
server131include/linux/smb_fs.hint smb_proc_write(struct smb_server *server, struct smb_dirent *finfo,
server133include/linux/smb_fs.hint smb_proc_write_raw(struct smb_server *server, struct smb_dirent *finfo, 
server135include/linux/smb_fs.hint smb_proc_create(struct smb_server *server, const char *path,
server137include/linux/smb_fs.hint smb_proc_mknew(struct smb_server *server, const char *path, int len,
server139include/linux/smb_fs.hint smb_proc_mv(struct smb_server *server, const char *opath, const int olen, 
server141include/linux/smb_fs.hint smb_proc_mkdir(struct smb_server *server, const char *path, const int len);
server142include/linux/smb_fs.hint smb_proc_rmdir(struct smb_server *server, const char *path, const int len);
server143include/linux/smb_fs.hint smb_proc_unlink(struct smb_server *server, const char *path,
server145include/linux/smb_fs.hint smb_proc_readdir(struct smb_server *server, struct inode *dir,
server148include/linux/smb_fs.hint smb_proc_getattr(struct smb_server *server, const char *path,
server150include/linux/smb_fs.hint smb_proc_setattr(struct smb_server *server,
server153include/linux/smb_fs.hint smb_proc_chkpath(struct smb_server *server, char *path, int len,
server156include/linux/smb_fs.hint smb_proc_reconnect(struct smb_server *server);
server157include/linux/smb_fs.hint smb_proc_connect(struct smb_server *server);
server158include/linux/smb_fs.hint smb_proc_disconnect(struct smb_server *server);
server159include/linux/smb_fs.hint smb_proc_trunc(struct smb_server *server, word fid, dword length);
server162include/linux/smb_fs.hint smb_release(struct smb_server *server);
server163include/linux/smb_fs.hint smb_connect(struct smb_server *server);
server164include/linux/smb_fs.hint smb_request(struct smb_server *server);
server165include/linux/smb_fs.hint smb_request_read_raw(struct smb_server *server,
server167include/linux/smb_fs.hint smb_request_write_raw(struct smb_server *server,
server169include/linux/smb_fs.hint smb_catch_keepalive(struct smb_server *server);
server170include/linux/smb_fs.hint smb_dont_catch_keepalive(struct smb_server *server);
server171include/linux/smb_fs.hint smb_trans2_request(struct smb_server *server,