diff -urN 2.1.29/fs/ncpfs/dir.c 2.1.29-patched/fs/ncpfs/dir.c --- 2.1.29/fs/ncpfs/dir.c Sun Jan 26 11:07:44 1997 +++ 2.1.29-patched/fs/ncpfs/dir.c Sun Mar 23 09:38:45 1997 @@ -23,95 +23,88 @@ struct ncp_dirent { struct nw_info_struct i; - struct nw_search_sequence s; /* given back for i */ + struct nw_search_sequence s; /* given back for i */ unsigned long f_pos; }; static long -ncp_dir_read(struct inode *inode, struct file *filp, char *buf, unsigned long count); + ncp_dir_read(struct inode *inode, struct file *filp, char *buf, unsigned long count); -static int -ncp_readdir(struct inode *inode, struct file *filp, - void *dirent, filldir_t filldir); +static int + ncp_readdir(struct inode *inode, struct file *filp, + void *dirent, filldir_t filldir); static int -ncp_read_volume_list(struct ncp_server *server, int start_with, - int cache_size); + ncp_read_volume_list(struct ncp_server *server, int start_with, + int cache_size); static int -ncp_do_readdir(struct ncp_server *server, struct inode *dir, int fpos, - int cache_size, struct ncp_dirent *entry); + ncp_do_readdir(struct ncp_server *server, struct inode *dir, int fpos, + int cache_size, struct ncp_dirent *entry); static struct inode * -ncp_iget(struct inode *dir, struct nw_file_info *finfo); + ncp_iget(struct inode *dir, struct nw_file_info *finfo); static struct ncp_inode_info * -ncp_find_dir_inode(struct inode *dir, const char *name); + ncp_find_dir_inode(struct inode *dir, const char *name); static int -ncp_lookup(struct inode *dir, const char *__name, - int len, struct inode **result); + ncp_lookup(struct inode *dir, const char *__name, + int len, struct inode **result); -static int -ncp_create(struct inode *dir, const char *name, int len, int mode, - struct inode **result); +static int + ncp_create(struct inode *dir, const char *name, int len, int mode, + struct inode **result); -static int -ncp_mkdir(struct inode *dir, const char *name, int len, int mode); +static int + ncp_mkdir(struct inode *dir, const char *name, int len, int mode); -static int -ncp_rmdir(struct inode *dir, const char *name, int len); +static int + ncp_rmdir(struct inode *dir, const char *name, int len); static int -ncp_unlink(struct inode *dir, const char *name, int len); + ncp_unlink(struct inode *dir, const char *name, int len); static int -ncp_rename(struct inode *old_dir, const char *old_name, int old_len, - struct inode *new_dir, const char *new_name, int new_len, - int must_be_dir); - -static inline void -str_upper(char *name) -{ - while (*name) - { - if (*name >= 'a' && *name <= 'z') - { + ncp_rename(struct inode *old_dir, const char *old_name, int old_len, + struct inode *new_dir, const char *new_name, int new_len, + int must_be_dir); + +static inline void str_upper(char *name) +{ + while (*name) { + if (*name >= 'a' && *name <= 'z') { *name -= ('a' - 'A'); } name++; } } -static inline void -str_lower(char *name) +static inline void str_lower(char *name) { - while (*name) - { - if (*name >= 'A' && *name <= 'Z') - { + while (*name) { + if (*name >= 'A' && *name <= 'Z') { *name += ('a' - 'A'); } - name ++; + name++; } } -static inline int -ncp_namespace(struct inode *i) +static inline int ncp_namespace(struct inode *i) { - struct ncp_server *server = NCP_SERVER(i); + struct ncp_server *server = NCP_SERVER(i); struct nw_info_struct *info = NCP_ISTRUCT(i); return server->name_space[info->volNumber]; } -static inline int -ncp_preserve_case(struct inode *i) +static inline int ncp_preserve_case(struct inode *i) { return (ncp_namespace(i) == NW_NS_OS2); } -static struct file_operations ncp_dir_operations = { - NULL, /* lseek - default */ +static struct file_operations ncp_dir_operations = +{ + NULL, /* lseek - default */ ncp_dir_read, /* read - bad */ NULL, /* write - bad */ ncp_readdir, /* readdir */ @@ -123,23 +116,24 @@ NULL /* fsync */ }; -struct inode_operations ncp_dir_inode_operations = { +struct inode_operations ncp_dir_inode_operations = +{ &ncp_dir_operations, /* default directory file ops */ ncp_create, /* create */ - ncp_lookup, /* lookup */ + ncp_lookup, /* lookup */ NULL, /* link */ - ncp_unlink, /* unlink */ + ncp_unlink, /* unlink */ NULL, /* symlink */ - ncp_mkdir, /* mkdir */ - ncp_rmdir, /* rmdir */ + ncp_mkdir, /* mkdir */ + ncp_rmdir, /* rmdir */ NULL, /* mknod */ - ncp_rename, /* rename */ + ncp_rename, /* rename */ NULL, /* readlink */ NULL, /* follow_link */ NULL, /* bmap */ NULL, /* truncate */ NULL, /* permission */ - NULL /* smap */ + NULL /* smap */ }; @@ -151,223 +145,181 @@ * enable the NFS exportability of a ncpfs-mounted volume. */ -static inline int -ncp_single_volume(struct ncp_server *server) +static inline int ncp_single_volume(struct ncp_server *server) { return (server->m.mounted_vol[0] != '\0'); } inline ino_t -ncp_info_ino(struct ncp_server *server, struct ncp_inode_info *info) + ncp_info_ino(struct ncp_server * server, struct ncp_inode_info * info) { return ncp_single_volume(server) - ? info->finfo.i.dirEntNum : (ino_t)info; + ? info->finfo.i.dirEntNum : (ino_t) info; } -static inline int -ncp_is_server_root(struct inode *inode) +static inline int ncp_is_server_root(struct inode *inode) { struct ncp_server *s = NCP_SERVER(inode); - return ( (!ncp_single_volume(s)) + return ((!ncp_single_volume(s)) && (inode->i_ino == ncp_info_ino(s, &(s->root)))); } struct ncp_inode_info * -ncp_find_inode(struct inode *inode) + ncp_find_inode(struct inode *inode) { struct ncp_server *server = NCP_SERVER(inode); - struct ncp_inode_info *root = &(server->root); - struct ncp_inode_info *this = root; + struct ncp_inode_info *root = &(server->root); + struct ncp_inode_info *this = root; ino_t ino = inode->i_ino; - do - { - if (ino == ncp_info_ino(server, this)) - { + do { + if (ino == ncp_info_ino(server, this)) { return this; } this = this->next; - } + } while (this != root); return NULL; } - -static long -ncp_dir_read(struct inode *inode, struct file *filp, char *buf, unsigned long count) + +static long ncp_dir_read(struct inode *inode, struct file *filp, char *buf, unsigned long count) { return -EISDIR; } -static kdev_t c_dev = 0; -static unsigned long c_ino = 0; -static int c_size; -static int c_seen_eof; -static int c_last_returned_index; -static struct ncp_dirent* c_entry = NULL; -static int c_lock = 0; +static kdev_t c_dev = 0; +static unsigned long c_ino = 0; +static int c_size; +static int c_seen_eof; +static int c_last_returned_index; +static struct ncp_dirent *c_entry = NULL; +static int c_lock = 0; static struct wait_queue *c_wait = NULL; -static inline void -ncp_lock_dircache(void) +static inline void ncp_lock_dircache(void) { while (c_lock) sleep_on(&c_wait); c_lock = 1; } -static inline void -ncp_unlock_dircache(void) +static inline void ncp_unlock_dircache(void) { c_lock = 0; wake_up(&c_wait); } -static int -ncp_readdir(struct inode *inode, struct file *filp, - void *dirent, filldir_t filldir) +static int ncp_readdir(struct inode *inode, struct file *filp, + void *dirent, filldir_t filldir) { int result = 0; int i = 0; - int index = 0; + int index = 0; struct ncp_dirent *entry = NULL; - struct ncp_server *server = NCP_SERVER(inode); + struct ncp_server *server = NCP_SERVER(inode); struct ncp_inode_info *dir = NCP_INOP(inode); - DDPRINTK("ncp_readdir: filp->f_pos = %d\n", (int)filp->f_pos); + DDPRINTK("ncp_readdir: filp->f_pos = %d\n", (int) filp->f_pos); DDPRINTK("ncp_readdir: inode->i_ino = %ld, c_ino = %ld\n", inode->i_ino, c_ino); - if (!inode || !S_ISDIR(inode->i_mode)) - { + if (!inode || !S_ISDIR(inode->i_mode)) { printk("ncp_readdir: inode is NULL or not a directory\n"); return -EBADF; } - - if (!ncp_conn_valid(server)) - { + if (!ncp_conn_valid(server)) { return -EIO; } - ncp_lock_dircache(); - if (c_entry == NULL) - { - i = sizeof (struct ncp_dirent) * NCP_READDIR_CACHE_SIZE; + if (c_entry == NULL) { + i = sizeof(struct ncp_dirent) * NCP_READDIR_CACHE_SIZE; c_entry = (struct ncp_dirent *) vmalloc(i); - if (c_entry == NULL) - { + if (c_entry == NULL) { printk("ncp_readdir: no MEMORY for cache\n"); result = -ENOMEM; goto finished; } } - - if (filp->f_pos == 0) - { - ncp_invalid_dir_cache(inode); - if (filldir(dirent,".",1, filp->f_pos, - ncp_info_ino(server, dir)) < 0) - { + if (filp->f_pos == 0) { + ncp_invalid_dir_cache(inode); + if (filldir(dirent, ".", 1, filp->f_pos, + ncp_info_ino(server, dir)) < 0) { goto finished; } filp->f_pos += 1; - } - - if (filp->f_pos == 1) - { - if (filldir(dirent,"..",2, filp->f_pos, - ncp_info_ino(server, dir->dir)) < 0) - { + } + if (filp->f_pos == 1) { + if (filldir(dirent, "..", 2, filp->f_pos, + ncp_info_ino(server, dir->dir)) < 0) { goto finished; } filp->f_pos += 1; } - - if ((inode->i_dev == c_dev) && (inode->i_ino == c_ino)) - { - for (i = 0; i < c_size; i++) - { - if (filp->f_pos == c_entry[i].f_pos) - { - entry = &c_entry[i]; - c_last_returned_index = i; - index = i; - break; + if ((inode->i_dev == c_dev) && (inode->i_ino == c_ino)) { + for (i = 0; i < c_size; i++) { + if (filp->f_pos == c_entry[i].f_pos) { + entry = &c_entry[i]; + c_last_returned_index = i; + index = i; + break; } } - if ((entry == NULL) && c_seen_eof) - { + if ((entry == NULL) && c_seen_eof) { goto finished; } } - - if (entry == NULL) - { + if (entry == NULL) { int entries; DDPRINTK("ncp_readdir: Not found in cache.\n"); - if (ncp_is_server_root(inode)) - { + if (ncp_is_server_root(inode)) { entries = ncp_read_volume_list(server, filp->f_pos, - NCP_READDIR_CACHE_SIZE); + NCP_READDIR_CACHE_SIZE); DPRINTK("ncp_read_volume_list returned %d\n", entries); - } - else - { + } else { entries = ncp_do_readdir(server, inode, filp->f_pos, NCP_READDIR_CACHE_SIZE, c_entry); DPRINTK("ncp_readdir returned %d\n", entries); } - if (entries < 0) - { + if (entries < 0) { c_dev = 0; c_ino = 0; result = entries; goto finished; } - - if (entries > 0) - { - c_seen_eof = (entries < NCP_READDIR_CACHE_SIZE); - c_dev = inode->i_dev; - c_ino = inode->i_ino; + if (entries > 0) { + c_seen_eof = (entries < NCP_READDIR_CACHE_SIZE); + c_dev = inode->i_dev; + c_ino = inode->i_ino; c_size = entries; entry = c_entry; - c_last_returned_index = 0; - index = 0; + c_last_returned_index = 0; + index = 0; - if (!ncp_preserve_case(inode)) - { - for (i = 0; i < c_size; i++) - { + if (!ncp_preserve_case(inode)) { + for (i = 0; i < c_size; i++) { str_lower(c_entry[i].i.entryName); } } } } - - if (entry == NULL) - { - /* Nothing found, even from a ncp call */ + if (entry == NULL) { + /* Nothing found, even from a ncp call */ goto finished; - } - - while (index < c_size) - { + } + while (index < c_size) { ino_t ino; - if (ncp_single_volume(server)) - { - ino = (ino_t)(entry->i.dirEntNum); - } - else - { + if (ncp_single_volume(server)) { + ino = (ino_t) (entry->i.dirEntNum); + } else { /* For getwd() we have to return the correct * inode in d_ino if the inode is currently in * use. Otherwise the inode number does not @@ -379,41 +331,36 @@ /* Some programs seem to be confused about a * zero inode number, so we set it to one. * Thanks to Gordon Chaffee for this one. */ - if (ino_info == NULL) - { + if (ino_info == NULL) { ino_info = (struct ncp_inode_info *) 1; } - ino = (ino_t)(ino_info); + ino = (ino_t) (ino_info); } DDPRINTK("ncp_readdir: entry->path= %s\n", entry->i.entryName); DDPRINTK("ncp_readdir: entry->f_pos = %ld\n", entry->f_pos); - if (filldir(dirent, entry->i.entryName, entry->i.nameLen, - entry->f_pos, ino) < 0) - { + if (filldir(dirent, entry->i.entryName, entry->i.nameLen, + entry->f_pos, ino) < 0) { break; - } - - if ( (inode->i_dev != c_dev) + } + if ((inode->i_dev != c_dev) || (inode->i_ino != c_ino) - || (entry->f_pos != filp->f_pos)) - { + || (entry->f_pos != filp->f_pos)) { /* Someone has destroyed the cache while we slept in filldir */ break; } - filp->f_pos += 1; - index += 1; - entry += 1; + filp->f_pos += 1; + index += 1; + entry += 1; } - finished: + finished: ncp_unlock_dircache(); return result; } -static int -ncp_read_volume_list(struct ncp_server *server, int fpos, int cache_size) +static int ncp_read_volume_list(struct ncp_server *server, int fpos, int cache_size) { struct ncp_dirent *entry = c_entry; @@ -421,47 +368,35 @@ int i; #if 1 - if (fpos < 2) - { + if (fpos < 2) { printk("OOPS, we expect fpos >= 2"); fpos = 2; } #endif - for (i=0; i 0) - { - if (total_count < fpos) - { + if (strlen(info.volume_name) > 0) { + if (total_count < fpos) { DPRINTK("ncp_read_volumes: skipped vol: %s\n", info.volume_name); - } - else if (total_count >= fpos + cache_size) - { + } else if (total_count >= fpos + cache_size) { return (total_count - fpos); - } - else - { + } else { DPRINTK("ncp_read_volumes: found vol: %s\n", info.volume_name); if (ncp_lookup_volume(server, info.volume_name, - &(entry->i)) != 0) - { + &(entry->i)) != 0) { DPRINTK("ncpfs: could not lookup vol " "%s\n", info.volume_name); continue; } - entry->f_pos = total_count; entry += 1; } @@ -471,59 +406,46 @@ return (total_count - fpos); } -static int -ncp_do_readdir(struct ncp_server *server, struct inode *dir, int fpos, - int cache_size, struct ncp_dirent *entry) +static int ncp_do_readdir(struct ncp_server *server, struct inode *dir, int fpos, + int cache_size, struct ncp_dirent *entry) { static struct nw_search_sequence seq; static struct inode *last_dir; static int total_count; #if 1 - if (fpos < 2) - { + if (fpos < 2) { printk("OOPS, we expect fpos >= 2"); fpos = 2; } #endif DPRINTK("ncp_do_readdir: fpos = %d\n", fpos); - if (fpos == 2) - { + if (fpos == 2) { last_dir = NULL; total_count = 2; } - - if ((fpos != total_count) || (dir != last_dir)) - { + if ((fpos != total_count) || (dir != last_dir)) { total_count = 2; last_dir = dir; DPRINTK("ncp_do_readdir: re-used seq for %s\n", NCP_ISTRUCT(dir)->entryName); - if (ncp_initialize_search(server, NCP_ISTRUCT(dir), &seq)!=0) - { + if (ncp_initialize_search(server, NCP_ISTRUCT(dir), &seq) != 0) { DPRINTK("ncp_init_search failed\n"); return total_count - fpos; } } - - while (total_count < fpos + cache_size) - { + while (total_count < fpos + cache_size) { if (ncp_search_for_file_or_subdir(server, &seq, - &(entry->i)) != 0) - { + &(entry->i)) != 0) { return total_count - fpos; } - - if (total_count < fpos) - { + if (total_count < fpos) { DPRINTK("ncp_do_readdir: skipped file: %s\n", entry->i.entryName); - } - else - { + } else { DDPRINTK("ncp_do_r: file: %s, f_pos=%d,total_count=%d", entry->i.entryName, fpos, total_count); entry->s = seq; @@ -535,143 +457,124 @@ return (total_count - fpos); } -void -ncp_init_dir_cache(void) +void ncp_init_dir_cache(void) { - c_dev = 0; - c_ino = 0; - c_entry = NULL; + c_dev = 0; + c_ino = 0; + c_entry = NULL; } -void -ncp_invalid_dir_cache(struct inode *ino) +void ncp_invalid_dir_cache(struct inode *ino) { - if ((ino->i_dev == c_dev) && (ino->i_ino == c_ino)) - { + if ((ino->i_dev == c_dev) && (ino->i_ino == c_ino)) { c_dev = 0; - c_ino = 0; - c_seen_eof = 0; - } + c_ino = 0; + c_seen_eof = 0; + } } -void -ncp_free_dir_cache(void) -{ - DPRINTK("ncp_free_dir_cache: enter\n"); - - if (c_entry == NULL) - { - return; - } +void ncp_free_dir_cache(void) +{ + DPRINTK("ncp_free_dir_cache: enter\n"); + if (c_entry == NULL) { + return; + } vfree(c_entry); c_entry = NULL; - DPRINTK("ncp_free_dir_cache: exit\n"); + DPRINTK("ncp_free_dir_cache: exit\n"); } static struct inode * -ncp_iget(struct inode *dir, struct nw_file_info *finfo) + ncp_iget(struct inode *dir, struct nw_file_info *finfo) { struct inode *inode; - struct ncp_inode_info *new_inode_info; - struct ncp_inode_info *root; + struct ncp_inode_info *new_inode_info; + struct ncp_inode_info *root; - if (dir == NULL) - { + if (dir == NULL) { printk("ncp_iget: dir is NULL\n"); return NULL; } - - if (finfo == NULL) - { + if (finfo == NULL) { printk("ncp_iget: finfo is NULL\n"); return NULL; } + new_inode_info = ncp_kmalloc(sizeof(struct ncp_inode_info), + GFP_KERNEL); - new_inode_info = ncp_kmalloc(sizeof(struct ncp_inode_info), - GFP_KERNEL); - - if (new_inode_info == NULL) - { - printk("ncp_iget: could not alloc mem for %s\n", + if (new_inode_info == NULL) { + printk("ncp_iget: could not alloc mem for %s\n", finfo->i.entryName); - return NULL; - } + return NULL; + } + new_inode_info->state = NCP_INODE_LOOKED_UP; + new_inode_info->nused = 0; + new_inode_info->dir = NCP_INOP(dir); + new_inode_info->finfo = *finfo; + + NCP_INOP(dir)->nused += 1; + + /* We have to link the new inode_info into the doubly linked + list of inode_infos to make a complete linear search + possible. */ + + root = &(NCP_SERVER(dir)->root); + + new_inode_info->prev = root; + new_inode_info->next = root->next; + root->next->prev = new_inode_info; + root->next = new_inode_info; - new_inode_info->state = NCP_INODE_LOOKED_UP; - new_inode_info->nused = 0; - new_inode_info->dir = NCP_INOP(dir); - new_inode_info->finfo = *finfo; - - NCP_INOP(dir)->nused += 1; - - /* We have to link the new inode_info into the doubly linked - list of inode_infos to make a complete linear search - possible. */ - - root = &(NCP_SERVER(dir)->root); - - new_inode_info->prev = root; - new_inode_info->next = root->next; - root->next->prev = new_inode_info; - root->next = new_inode_info; - if (!(inode = iget(dir->i_sb, ncp_info_ino(NCP_SERVER(dir), - new_inode_info)))) - { + new_inode_info)))) { printk("ncp_iget: iget failed!"); return NULL; } - return inode; } -void -ncp_free_inode_info(struct ncp_inode_info *i) +void ncp_free_inode_info(struct ncp_inode_info *i) { - if (i == NULL) - { - printk("ncp_free_inode: i == NULL\n"); - return; - } - - i->state = NCP_INODE_CACHED; - while ((i->nused == 0) && (i->state == NCP_INODE_CACHED)) - { - struct ncp_inode_info *dir = i->dir; + if (i == NULL) { + printk("ncp_free_inode: i == NULL\n"); + return; + } + i->state = NCP_INODE_CACHED; + while ((i->nused == 0) && (i->state == NCP_INODE_CACHED)) { + struct ncp_inode_info *dir = i->dir; - i->next->prev = i->prev; - i->prev->next = i->next; + i->next->prev = i->prev; + i->prev->next = i->next; DDPRINTK("ncp_free_inode_info: freeing %s\n", i->finfo.i.entryName); - ncp_kfree_s(i, sizeof(struct ncp_inode_info)); + ncp_kfree_s(i, sizeof(struct ncp_inode_info)); - if (dir == i) return; + if (dir == i) + return; - (dir->nused)--; - i = dir; - } + (dir->nused)--; + i = dir; + } } - -void -ncp_init_root(struct ncp_server *server) + +void ncp_init_root(struct ncp_server *server) { - struct ncp_inode_info *root = &(server->root); + struct ncp_inode_info *root = &(server->root); struct nw_info_struct *i = &(root->finfo.i); unsigned short dummy; - DPRINTK("ncp_init_root: server %s\n", server->m.server_name); - DPRINTK("ncp_init_root: i = %x\n", (int)i); + DPRINTK("ncp_init_root: i = %x\n", (int) i); - root->finfo.opened = 0; - i->attributes = aDIR; + root->finfo.opened = 0; + i->attributes = aDIR; i->dataStreamSize = 1024; i->dirEntNum = i->DosDirNum = 0; - i->volNumber = NCP_NUMBER_OF_VOLUMES+1; /* illegal volnum */ + i->volNumber = NCP_NUMBER_OF_VOLUMES + 1; /* illegal volnum */ ncp_date_unix2dos(0, &(i->creationTime), &(i->creationDate)); ncp_date_unix2dos(0, &(i->modifyTime), &(i->modifyDate)); ncp_date_unix2dos(0, &dummy, &(i->lastAccessDate)); @@ -683,25 +586,21 @@ i->nameLen = 0; i->entryName[0] = '\0'; - root->state = NCP_INODE_LOOKED_UP; - root->nused = 1; - root->dir = root; - root->next = root->prev = root; - return; + root->state = NCP_INODE_LOOKED_UP; + root->nused = 1; + root->dir = root; + root->next = root->prev = root; + return; } -int -ncp_conn_logged_in(struct ncp_server *server) +int ncp_conn_logged_in(struct ncp_server *server) { - if (server->m.mounted_vol[0] == '\0') - { + if (server->m.mounted_vol[0] == '\0') { return 0; } - str_upper(server->m.mounted_vol); if (ncp_lookup_volume(server, server->m.mounted_vol, - &(server->root.finfo.i)) != 0) - { + &(server->root.finfo.i)) != 0) { return -ENOENT; } str_lower(server->root.finfo.i.entryName); @@ -709,202 +608,166 @@ return 0; } -void -ncp_free_all_inodes(struct ncp_server *server) +void ncp_free_all_inodes(struct ncp_server *server) { - /* Here nothing should be to do. I do not know whether it's - better to leave some memory allocated or be stuck in an - endless loop */ + /* Here nothing should be to do. I do not know whether it's + better to leave some memory allocated or be stuck in an + endless loop */ #if 1 - struct ncp_inode_info *root = &(server->root); + struct ncp_inode_info *root = &(server->root); - if (root->next != root) - { - printk("ncp_free_all_inodes: INODES LEFT!!!\n"); - } - - while (root->next != root) - { - printk("ncp_free_all_inodes: freeing inode\n"); - ncp_free_inode_info(root->next); - /* In case we have an endless loop.. */ - schedule(); - } -#endif - - return; + if (root->next != root) { + printk("ncp_free_all_inodes: INODES LEFT!!!\n"); + } + while (root->next != root) { + printk("ncp_free_all_inodes: freeing inode\n"); + ncp_free_inode_info(root->next); + /* In case we have an endless loop.. */ + schedule(); + } +#endif + + return; } /* We will search the inode that belongs to this name, currently by a complete linear search through the inodes belonging to this filesystem. This has to be fixed. */ static struct ncp_inode_info * -ncp_find_dir_inode(struct inode *dir, const char *name) + ncp_find_dir_inode(struct inode *dir, const char *name) { struct ncp_server *server = NCP_SERVER(dir); struct nw_info_struct *dir_info = NCP_ISTRUCT(dir); - struct ncp_inode_info *result = &(server->root); + struct ncp_inode_info *result = &(server->root); - if (name == NULL) - { - return NULL; + if (name == NULL) { + return NULL; } - - do - { - if ( (result->dir->finfo.i.dirEntNum == dir_info->dirEntNum) - && (result->dir->finfo.i.volNumber == dir_info->volNumber) + do { + if ((result->dir->finfo.i.dirEntNum == dir_info->dirEntNum) + && (result->dir->finfo.i.volNumber == dir_info->volNumber) && (strcmp(result->finfo.i.entryName, name) == 0) - /* The root dir is never looked up using this - * routine. Without the following test a root - * directory 'sys' in a volume named 'sys' could - * never be looked up, because - * server->root->dir==server->root. */ - && (result != &(server->root))) - { - return result; + /* The root dir is never looked up using this + * routine. Without the following test a root + * directory 'sys' in a volume named 'sys' could + * never be looked up, because + * server->root->dir==server->root. */ + && (result != &(server->root))) { + return result; } - result = result->next; + result = result->next; - } + } while (result != &(server->root)); - return NULL; + return NULL; } -static int -ncp_lookup(struct inode *dir, const char *__name, int len, - struct inode **result) +static int ncp_lookup(struct inode *dir, const char *__name, int len, + struct inode **result) { struct nw_file_info finfo; struct ncp_server *server; struct ncp_inode_info *result_info; int found_in_cache; int down_case = 0; - char name[len+1]; + char name[len + 1]; *result = NULL; - if (!dir || !S_ISDIR(dir->i_mode)) - { + if (!dir || !S_ISDIR(dir->i_mode)) { printk("ncp_lookup: inode is NULL or not a directory.\n"); iput(dir); return -ENOENT; } - server = NCP_SERVER(dir); - if (!ncp_conn_valid(server)) - { + if (!ncp_conn_valid(server)) { iput(dir); return -EIO; } - DPRINTK("ncp_lookup: %s, len %d\n", __name, len); /* Fast cheat for . */ - if (len == 0 || (len == 1 && __name[0] == '.')) - { + if (len == 0 || (len == 1 && __name[0] == '.')) { *result = dir; return 0; } - /* ..and for .. */ - if (len == 2 && __name[0] == '.' && __name[1] == '.') - { + if (len == 2 && __name[0] == '.' && __name[1] == '.') { struct ncp_inode_info *parent = NCP_INOP(dir)->dir; - if (parent->state == NCP_INODE_CACHED) - { + if (parent->state == NCP_INODE_CACHED) { parent->state = NCP_INODE_LOOKED_UP; } - *result = iget(dir->i_sb, ncp_info_ino(server, parent)); iput(dir); - if (*result == 0) - { + if (*result == 0) { return -EACCES; - } - else - { + } else { return 0; } } - memcpy(name, __name, len); name[len] = 0; lock_super(dir->i_sb); result_info = ncp_find_dir_inode(dir, name); - if (result_info != 0) - { - if (result_info->state == NCP_INODE_CACHED) - { - result_info->state = NCP_INODE_LOOKED_UP; + if (result_info != 0) { + if (result_info->state == NCP_INODE_CACHED) { + result_info->state = NCP_INODE_LOOKED_UP; } + /* Here we convert the inode_info address into an + inode number */ - /* Here we convert the inode_info address into an - inode number */ - - *result = iget(dir->i_sb, ncp_info_ino(server, result_info)); + *result = iget(dir->i_sb, ncp_info_ino(server, result_info)); unlock_super(dir->i_sb); - iput(dir); - - if (*result == NULL) - { - return -EACCES; - } + iput(dir); + if (*result == NULL) { + return -EACCES; + } return 0; - } - - /* If the file is in the dir cache, we do not have to ask the - server. */ + } + /* If the file is in the dir cache, we do not have to ask the + server. */ - found_in_cache = 0; + found_in_cache = 0; ncp_lock_dircache(); - if ((dir->i_dev == c_dev) && (dir->i_ino == c_ino)) - { - int first = c_last_returned_index; - int i; - - i = first; - do - { - DDPRINTK("ncp_lookup: trying index: %d, name: %s\n", + if ((dir->i_dev == c_dev) && (dir->i_ino == c_ino)) { + int first = c_last_returned_index; + int i; + + i = first; + do { + DDPRINTK("ncp_lookup: trying index: %d, name: %s\n", i, c_entry[i].i.entryName); - if (strcmp(c_entry[i].i.entryName, name) == 0) - { - DPRINTK("ncp_lookup: found in cache!\n"); + if (strcmp(c_entry[i].i.entryName, name) == 0) { + DPRINTK("ncp_lookup: found in cache!\n"); finfo.i = c_entry[i].i; found_in_cache = 1; break; - } - i = (i + 1) % c_size; - } + } + i = (i + 1) % c_size; + } while (i != first); - } + } ncp_unlock_dircache(); - if (found_in_cache == 0) - { + if (found_in_cache == 0) { int res; DDPRINTK("ncp_lookup: do_lookup on %s/%s\n", NCP_ISTRUCT(dir)->entryName, name); - if (ncp_is_server_root(dir)) - { + if (ncp_is_server_root(dir)) { str_upper(name); down_case = 1; res = ncp_lookup_volume(server, name, &(finfo.i)); - } - else - { - if (!ncp_preserve_case(dir)) - { + } else { + if (!ncp_preserve_case(dir)) { str_upper(name); down_case = 1; } @@ -913,313 +776,246 @@ NCP_ISTRUCT(dir)->dirEntNum, name, &(finfo.i)); } - if (res != 0) - { + if (res != 0) { unlock_super(dir->i_sb); - iput(dir); - return -ENOENT; - } - } - + iput(dir); + return -ENOENT; + } + } finfo.opened = 0; - if (down_case != 0) - { + if (down_case != 0) { str_lower(finfo.i.entryName); } - - if (!(*result = ncp_iget(dir, &finfo))) - { + if (!(*result = ncp_iget(dir, &finfo))) { unlock_super(dir->i_sb); iput(dir); return -EACCES; } - unlock_super(dir->i_sb); iput(dir); return 0; } -static int -ncp_create(struct inode *dir, const char *name, int len, int mode, - struct inode **result) +static int ncp_create(struct inode *dir, const char *name, int len, int mode, + struct inode **result) { struct nw_file_info finfo; - __u8 _name[len+1]; + __u8 _name[len + 1]; *result = NULL; - if (!dir || !S_ISDIR(dir->i_mode)) - { + if (!dir || !S_ISDIR(dir->i_mode)) { printk("ncp_create: inode is NULL or not a directory\n"); iput(dir); return -ENOENT; } - if (!ncp_conn_valid(NCP_SERVER(dir))) - { + if (!ncp_conn_valid(NCP_SERVER(dir))) { iput(dir); return -EIO; } - strncpy(_name, name, len); _name[len] = '\0'; - if (!ncp_preserve_case(dir)) - { + if (!ncp_preserve_case(dir)) { str_upper(_name); } - lock_super(dir->i_sb); if (ncp_open_create_file_or_subdir(NCP_SERVER(dir), NCP_ISTRUCT(dir), _name, - OC_MODE_CREATE|OC_MODE_OPEN| + OC_MODE_CREATE | OC_MODE_OPEN | OC_MODE_REPLACE, - 0, AR_READ|AR_WRITE, - &finfo) != 0) - { + 0, AR_READ | AR_WRITE, + &finfo) != 0) { unlock_super(dir->i_sb); iput(dir); return -EACCES; } - ncp_invalid_dir_cache(dir); - if (!ncp_preserve_case(dir)) - { + if (!ncp_preserve_case(dir)) { str_lower(finfo.i.entryName); } - finfo.access = O_RDWR; - if (!(*result = ncp_iget(dir, &finfo)) < 0) - { + if (!(*result = ncp_iget(dir, &finfo)) < 0) { ncp_close_file(NCP_SERVER(dir), finfo.file_handle); unlock_super(dir->i_sb); iput(dir); return -EINVAL; } - unlock_super(dir->i_sb); iput(dir); - return 0; + return 0; } -static int -ncp_mkdir(struct inode *dir, const char *name, int len, int mode) +static int ncp_mkdir(struct inode *dir, const char *name, int len, int mode) { int error; struct nw_file_info new_dir; - __u8 _name[len+1]; + __u8 _name[len + 1]; - if ( (name[0] == '.') - && ( (len == 1) - || ( (len == 2) - && (name[1] == '.')))) - { + if ((name[0] == '.') + && ((len == 1) + || ((len == 2) + && (name[1] == '.')))) { iput(dir); return -EEXIST; } - strncpy(_name, name, len); _name[len] = '\0'; - if (!ncp_preserve_case(dir)) - { + if (!ncp_preserve_case(dir)) { str_upper(_name); } - - if (!dir || !S_ISDIR(dir->i_mode)) - { + if (!dir || !S_ISDIR(dir->i_mode)) { printk("ncp_mkdir: inode is NULL or not a directory\n"); iput(dir); return -ENOENT; } - if (!ncp_conn_valid(NCP_SERVER(dir))) - { + if (!ncp_conn_valid(NCP_SERVER(dir))) { iput(dir); return -EIO; } - if (ncp_open_create_file_or_subdir(NCP_SERVER(dir), NCP_ISTRUCT(dir), _name, OC_MODE_CREATE, aDIR, 0xffff, - &new_dir) != 0) - { + &new_dir) != 0) { error = -EACCES; - } - else - { + } else { error = 0; - ncp_invalid_dir_cache(dir); - } + ncp_invalid_dir_cache(dir); + } iput(dir); return error; } -static int -ncp_rmdir(struct inode *dir, const char *name, int len) +static int ncp_rmdir(struct inode *dir, const char *name, int len) { int error; - __u8 _name[len+1]; + __u8 _name[len + 1]; - if (!dir || !S_ISDIR(dir->i_mode)) - { + if (!dir || !S_ISDIR(dir->i_mode)) { printk("ncp_rmdir: inode is NULL or not a directory\n"); iput(dir); return -ENOENT; } - if (!ncp_conn_valid(NCP_SERVER(dir))) - { + if (!ncp_conn_valid(NCP_SERVER(dir))) { iput(dir); return -EIO; } - if (ncp_find_dir_inode(dir, name) != NULL) - { + if (ncp_find_dir_inode(dir, name) != NULL) { iput(dir); - error = -EBUSY; - } - else - { + error = -EBUSY; + } else { strncpy(_name, name, len); _name[len] = '\0'; - if (!ncp_preserve_case(dir)) - { + if (!ncp_preserve_case(dir)) { str_upper(_name); } - - if ((error = ncp_del_file_or_subdir(NCP_SERVER(dir), + if ((error = ncp_del_file_or_subdir(NCP_SERVER(dir), NCP_ISTRUCT(dir), - _name)) == 0) - { - ncp_invalid_dir_cache(dir); - } - else - { + _name)) == 0) { + ncp_invalid_dir_cache(dir); + } else { error = -EACCES; } - } + } iput(dir); return error; } -static int -ncp_unlink(struct inode *dir, const char *name, int len) +static int ncp_unlink(struct inode *dir, const char *name, int len) { int error; - __u8 _name[len+1]; + __u8 _name[len + 1]; - if (!dir || !S_ISDIR(dir->i_mode)) - { + if (!dir || !S_ISDIR(dir->i_mode)) { printk("ncp_unlink: inode is NULL or not a directory\n"); iput(dir); return -ENOENT; } - if (!ncp_conn_valid(NCP_SERVER(dir))) - { + if (!ncp_conn_valid(NCP_SERVER(dir))) { iput(dir); return -EIO; } - if (ncp_find_dir_inode(dir, name) != NULL) - { + if (ncp_find_dir_inode(dir, name) != NULL) { iput(dir); - error = -EBUSY; - } - else - { + error = -EBUSY; + } else { strncpy(_name, name, len); _name[len] = '\0'; - if (!ncp_preserve_case(dir)) - { + if (!ncp_preserve_case(dir)) { str_upper(_name); } - - if ((error = ncp_del_file_or_subdir(NCP_SERVER(dir), + if ((error = ncp_del_file_or_subdir(NCP_SERVER(dir), NCP_ISTRUCT(dir), - _name)) == 0) - { - ncp_invalid_dir_cache(dir); - } - else - { + _name)) == 0) { + ncp_invalid_dir_cache(dir); + } else { error = -EACCES; } - } + } iput(dir); return error; } -static int -ncp_rename(struct inode *old_dir, const char *old_name, int old_len, - struct inode *new_dir, const char *new_name, int new_len, - int must_be_dir) +static int ncp_rename(struct inode *old_dir, const char *old_name, int old_len, + struct inode *new_dir, const char *new_name, int new_len, + int must_be_dir) { int res; - char _old_name[old_len+1]; - char _new_name[new_len+1]; + char _old_name[old_len + 1]; + char _new_name[new_len + 1]; - if (!old_dir || !S_ISDIR(old_dir->i_mode)) - { + if (!old_dir || !S_ISDIR(old_dir->i_mode)) { printk("ncp_rename: old inode is NULL or not a directory\n"); - res = -ENOENT; - goto finished; + res = -ENOENT; + goto finished; } - - if (!ncp_conn_valid(NCP_SERVER(old_dir))) - { + if (!ncp_conn_valid(NCP_SERVER(old_dir))) { res = -EIO; goto finished; } - - if (!new_dir || !S_ISDIR(new_dir->i_mode)) - { + if (!new_dir || !S_ISDIR(new_dir->i_mode)) { printk("ncp_rename: new inode is NULL or not a directory\n"); - res = -ENOENT; - goto finished; + res = -ENOENT; + goto finished; + } + if ((ncp_find_dir_inode(old_dir, old_name) != NULL) + || (ncp_find_dir_inode(new_dir, new_name) != NULL)) { + res = -EBUSY; + goto finished; } - - if ( (ncp_find_dir_inode(old_dir, old_name) != NULL) - || (ncp_find_dir_inode(new_dir, new_name) != NULL)) - { - res = -EBUSY; - goto finished; - } - strncpy(_old_name, old_name, old_len); _old_name[old_len] = '\0'; - if (!ncp_preserve_case(old_dir)) - { + if (!ncp_preserve_case(old_dir)) { str_upper(_old_name); } - strncpy(_new_name, new_name, new_len); _new_name[new_len] = '\0'; - if (!ncp_preserve_case(new_dir)) - { + if (!ncp_preserve_case(new_dir)) { str_upper(_new_name); } - res = ncp_ren_or_mov_file_or_subdir(NCP_SERVER(old_dir), - NCP_ISTRUCT(old_dir), _old_name, - NCP_ISTRUCT(new_dir), _new_name); + NCP_ISTRUCT(old_dir), _old_name, + NCP_ISTRUCT(new_dir), _new_name); - if (res == 0) - { - ncp_invalid_dir_cache(old_dir); - ncp_invalid_dir_cache(new_dir); - } - else - { + if (res == 0) { + ncp_invalid_dir_cache(old_dir); + ncp_invalid_dir_cache(new_dir); + } else { res = -EACCES; } - - finished: - iput(old_dir); + + finished: + iput(old_dir); iput(new_dir); return res; } @@ -1228,64 +1024,62 @@ /* Linear day numbers of the respective 1sts in non-leap years. */ -static int day_n[] = { 0,31,59,90,120,151,181,212,243,273,304,334,0,0,0,0 }; +static int day_n[] = +{0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 0, 0, 0, 0}; /* JanFebMarApr May Jun Jul Aug Sep Oct Nov Dec */ extern struct timezone sys_tz; -static int -utc2local(int time) +static int utc2local(int time) { - return time - sys_tz.tz_minuteswest*60 + + return time - sys_tz.tz_minuteswest * 60 + (sys_tz.tz_dsttime ? 3600 : 0); } -static int -local2utc(int time) +static int local2utc(int time) { - return time + sys_tz.tz_minuteswest*60 - + return time + sys_tz.tz_minuteswest * 60 - (sys_tz.tz_dsttime ? 3600 : 0); } /* Convert a MS-DOS time/date pair to a UNIX date (seconds since 1 1 70). */ -int -ncp_date_dos2unix(unsigned short time,unsigned short date) +int ncp_date_dos2unix(unsigned short time, unsigned short date) { - int month,year,secs; + int month, year, secs; - month = ((date >> 5) & 15)-1; + month = ((date >> 5) & 15) - 1; year = date >> 9; - secs = (time & 31)*2+60*((time >> 5) & 63)+(time >> 11)*3600+86400* - ((date & 31)-1+day_n[month]+(year/4)+year*365-((year & 3) == 0 && - month < 2 ? 1 : 0)+3653); - /* days since 1.1.70 plus 80's leap day */ + secs = (time & 31) * 2 + 60 * ((time >> 5) & 63) + (time >> 11) * 3600 + 86400 * + ((date & 31) - 1 + day_n[month] + (year / 4) + year * 365 - ((year & 3) == 0 && + month < 2 ? 1 : 0) + 3653); + /* days since 1.1.70 plus 80's leap day */ return local2utc(secs); } /* Convert linear UNIX date to a MS-DOS time/date pair. */ -void -ncp_date_unix2dos(int unix_date,unsigned short *time, unsigned short *date) +void ncp_date_unix2dos(int unix_date, unsigned short *time, unsigned short *date) { - int day,year,nl_day,month; + int day, year, nl_day, month; unix_date = utc2local(unix_date); - *time = (unix_date % 60)/2+(((unix_date/60) % 60) << 5)+ - (((unix_date/3600) % 24) << 11); - day = unix_date/86400-3652; - year = day/365; - if ((year+3)/4+365*year > day) year--; - day -= (year+3)/4+365*year; + *time = (unix_date % 60) / 2 + (((unix_date / 60) % 60) << 5) + + (((unix_date / 3600) % 24) << 11); + day = unix_date / 86400 - 3652; + year = day / 365; + if ((year + 3) / 4 + 365 * year > day) + year--; + day -= (year + 3) / 4 + 365 * year; if (day == 59 && !(year & 3)) { nl_day = day; month = 2; - } - else { - nl_day = (year & 3) || day <= 59 ? day : day-1; + } else { + nl_day = (year & 3) || day <= 59 ? day : day - 1; for (month = 0; month < 12; month++) - if (day_n[month] > nl_day) break; + if (day_n[month] > nl_day) + break; } - *date = nl_day-day_n[month-1]+1+(month << 5)+(year << 9); + *date = nl_day - day_n[month - 1] + 1 + (month << 5) + (year << 9); } diff -urN 2.1.29/fs/ncpfs/file.c 2.1.29-patched/fs/ncpfs/file.c --- 2.1.29/fs/ncpfs/file.c Sun Jan 26 11:07:44 1997 +++ 2.1.29-patched/fs/ncpfs/file.c Sat Mar 22 19:13:11 1997 @@ -21,215 +21,172 @@ static inline int min(int a, int b) { - return aopened = %d\n", finfo->opened); + DPRINTK("ncp_make_open: dirent->opened = %d\n", finfo->opened); lock_super(i->i_sb); - if (finfo->opened == 0) - { + if (finfo->opened == 0) { finfo->access = -1; - /* tries max. rights */ + /* tries max. rights */ if (ncp_open_create_file_or_subdir(NCP_SERVER(i), NULL, NULL, OC_MODE_OPEN, 0, AR_READ | AR_WRITE, - finfo) == 0) - { + finfo) == 0) { finfo->access = O_RDWR; - } - else if (ncp_open_create_file_or_subdir(NCP_SERVER(i), - NULL, NULL, - OC_MODE_OPEN, 0, - AR_READ, - finfo) == 0) - { + } else if (ncp_open_create_file_or_subdir(NCP_SERVER(i), + NULL, NULL, + OC_MODE_OPEN, 0, + AR_READ, + finfo) == 0) { finfo->access = O_RDONLY; } - } - + } unlock_super(i->i_sb); - if ( ((right == O_RDONLY) && ( (finfo->access == O_RDONLY) - || (finfo->access == O_RDWR))) - || ((right == O_WRONLY) && ( (finfo->access == O_WRONLY) - || (finfo->access == O_RDWR))) - || ((right == O_RDWR) && (finfo->access == O_RDWR))) - return 0; + if (((right == O_RDONLY) && ((finfo->access == O_RDONLY) + || (finfo->access == O_RDWR))) + || ((right == O_WRONLY) && ((finfo->access == O_WRONLY) + || (finfo->access == O_RDWR))) + || ((right == O_RDWR) && (finfo->access == O_RDWR))) + return 0; - return -EACCES; + return -EACCES; } -static long -ncp_file_read(struct inode *inode, struct file *file, char *buf, unsigned long count) +static long ncp_file_read(struct inode *inode, struct file *file, char *buf, unsigned long count) { int bufsize, already_read; off_t pos; - int errno; + int errno; - DPRINTK("ncp_file_read: enter %s\n", NCP_ISTRUCT(inode)->entryName); - - if (inode == NULL) - { + DPRINTK("ncp_file_read: enter %s\n", NCP_ISTRUCT(inode)->entryName); + + if (inode == NULL) { DPRINTK("ncp_file_read: inode = NULL\n"); return -EINVAL; } - if (!ncp_conn_valid(NCP_SERVER(inode))) - { + if (!ncp_conn_valid(NCP_SERVER(inode))) { return -EIO; } - - if (!S_ISREG(inode->i_mode)) - { + if (!S_ISREG(inode->i_mode)) { DPRINTK("ncp_file_read: read from non-file, mode %07o\n", - inode->i_mode); + inode->i_mode); return -EINVAL; } - pos = file->f_pos; - if (pos + count > inode->i_size) - { + if (pos + count > inode->i_size) { count = inode->i_size - pos; } - - if (count <= 0) - { + if (count <= 0) { return 0; } - - if ((errno = ncp_make_open(inode, O_RDONLY)) != 0) - { - return errno; + if ((errno = ncp_make_open(inode, O_RDONLY)) != 0) { + return errno; } - bufsize = NCP_SERVER(inode)->buffer_size; - already_read = 0; + already_read = 0; /* First read in as much as possible for each bufsize. */ - while (already_read < count) - { + while (already_read < count) { int read_this_time; int to_read = min(bufsize - (pos % bufsize), count - already_read); if (ncp_read(NCP_SERVER(inode), NCP_FINFO(inode)->file_handle, - pos, to_read, buf, &read_this_time) != 0) - { - return -EIO; /* This is not exact, i know.. */ + pos, to_read, buf, &read_this_time) != 0) { + return -EIO; /* This is not exact, i know.. */ } - pos += read_this_time; buf += read_this_time; - already_read += read_this_time; + already_read += read_this_time; - if (read_this_time < to_read) - { - break; + if (read_this_time < to_read) { + break; } } - file->f_pos = pos; + file->f_pos = pos; - if (!IS_RDONLY(inode)) - { + if (!IS_RDONLY(inode)) { inode->i_atime = CURRENT_TIME; } - inode->i_dirt = 1; - DPRINTK("ncp_file_read: exit %s\n", NCP_ISTRUCT(inode)->entryName); + DPRINTK("ncp_file_read: exit %s\n", NCP_ISTRUCT(inode)->entryName); - return already_read; + return already_read; } -static long -ncp_file_write(struct inode *inode, struct file *file, const char *buf, - unsigned long count) +static long ncp_file_write(struct inode *inode, struct file *file, const char *buf, + unsigned long count) { int bufsize, already_written; - off_t pos; - int errno; - - if (inode == NULL) - { + off_t pos; + int errno; + + if (inode == NULL) { DPRINTK("ncp_file_write: inode = NULL\n"); return -EINVAL; } - if (!ncp_conn_valid(NCP_SERVER(inode))) - { + if (!ncp_conn_valid(NCP_SERVER(inode))) { return -EIO; } - - if (!S_ISREG(inode->i_mode)) - { + if (!S_ISREG(inode->i_mode)) { DPRINTK("ncp_file_write: write to non-file, mode %07o\n", - inode->i_mode); + inode->i_mode); return -EINVAL; } + DPRINTK("ncp_file_write: enter %s\n", NCP_ISTRUCT(inode)->entryName); - DPRINTK("ncp_file_write: enter %s\n", NCP_ISTRUCT(inode)->entryName); - - if (count <= 0) - { + if (count <= 0) { return 0; } - - if ((errno = ncp_make_open(inode, O_RDWR)) != 0) - { - return errno; + if ((errno = ncp_make_open(inode, O_RDWR)) != 0) { + return errno; } - pos = file->f_pos; - if (file->f_flags & O_APPEND) - { + if (file->f_flags & O_APPEND) { pos = inode->i_size; } - bufsize = NCP_SERVER(inode)->buffer_size; - already_written = 0; + already_written = 0; - while (already_written < count) - { + while (already_written < count) { int written_this_time; int to_write = min(bufsize - (pos % bufsize), count - already_written); if (ncp_write(NCP_SERVER(inode), NCP_FINFO(inode)->file_handle, - pos, to_write, buf, &written_this_time) != 0) - { + pos, to_write, buf, &written_this_time) != 0) { return -EIO; - } - + } pos += written_this_time; buf += written_this_time; already_written += written_this_time; - if (written_this_time < to_write) - { + if (written_this_time < to_write) { break; } } @@ -239,18 +196,17 @@ file->f_pos = pos; - if (pos > inode->i_size) - { - inode->i_size = pos; + if (pos > inode->i_size) { + inode->i_size = pos; ncp_invalid_dir_cache(NCP_INOP(inode)->dir->inode); - } - - DPRINTK("ncp_file_write: exit %s\n", NCP_ISTRUCT(inode)->entryName); + } + DPRINTK("ncp_file_write: exit %s\n", NCP_ISTRUCT(inode)->entryName); return already_written; } -static struct file_operations ncp_file_operations = { +static struct file_operations ncp_file_operations = +{ NULL, /* lseek - default */ ncp_file_read, /* read */ ncp_file_write, /* write */ @@ -258,12 +214,13 @@ NULL, /* poll - default */ ncp_ioctl, /* ioctl */ ncp_mmap, /* mmap */ - NULL, /* open */ - NULL, /* release */ + NULL, /* open */ + NULL, /* release */ ncp_fsync, /* fsync */ }; -struct inode_operations ncp_file_inode_operations = { +struct inode_operations ncp_file_inode_operations = +{ &ncp_file_operations, /* default file operations */ NULL, /* create */ NULL, /* lookup */ diff -urN 2.1.29/fs/ncpfs/inode.c 2.1.29-patched/fs/ncpfs/inode.c --- 2.1.29/fs/ncpfs/inode.c Sun Jan 19 14:47:26 1997 +++ 2.1.29-patched/fs/ncpfs/inode.c Sun Mar 23 11:38:08 1997 @@ -36,8 +36,9 @@ static void ncp_statfs(struct super_block *sb, struct statfs *buf, int bufsiz); static int ncp_notify_change(struct inode *inode, struct iattr *attr); -static struct super_operations ncp_sops = { - ncp_read_inode, /* read inode */ +static struct super_operations ncp_sops = +{ + ncp_read_inode, /* read inode */ ncp_notify_change, /* notify change */ NULL, /* write inode */ ncp_put_inode, /* put inode */ @@ -51,202 +52,150 @@ ncp_inode_info's and initializes the inode from the data found there. It does not allocate or deallocate anything. */ -static void -ncp_read_inode(struct inode *inode) +static void ncp_read_inode(struct inode *inode) { - /* Our task should be extremely simple here. We only have to - look up the information somebody else (ncp_iget) put into - the inode tree. The address of this information is the - inode->i_ino. Just to make sure everything went well, we - check it's there. */ + /* Our task should be extremely simple here. We only have to + look up the information somebody else (ncp_iget) put into + the inode tree. The address of this information is the + inode->i_ino. Just to make sure everything went well, we + check it's there. */ - struct ncp_inode_info *inode_info = ncp_find_inode(inode); + struct ncp_inode_info *inode_info = ncp_find_inode(inode); - if (inode_info == NULL) - { + if (inode_info == NULL) { /* Ok, now we're in trouble. The inode info is not there. What should we do now??? */ printk("ncp_read_inode: inode info not found\n"); return; } + inode_info->state = NCP_INODE_VALID; - inode_info->state = NCP_INODE_VALID; - - NCP_INOP(inode) = inode_info; + NCP_INOP(inode) = inode_info; inode_info->inode = inode; - if (NCP_ISTRUCT(inode)->attributes & aDIR) - { - inode->i_mode = NCP_SERVER(inode)->m.dir_mode; + if (NCP_ISTRUCT(inode)->attributes & aDIR) { + inode->i_mode = NCP_SERVER(inode)->m.dir_mode; /* for directories dataStreamSize seems to be some Object ID ??? */ inode->i_size = 512; - } - else - { - inode->i_mode = NCP_SERVER(inode)->m.file_mode; + } else { + inode->i_mode = NCP_SERVER(inode)->m.file_mode; inode->i_size = le32_to_cpu(NCP_ISTRUCT(inode)->dataStreamSize); } - DDPRINTK("ncp_read_inode: inode->i_mode = %u\n", inode->i_mode); + DDPRINTK("ncp_read_inode: inode->i_mode = %u\n", inode->i_mode); - inode->i_nlink = 1; - inode->i_uid = NCP_SERVER(inode)->m.uid; - inode->i_gid = NCP_SERVER(inode)->m.gid; - inode->i_blksize = 512; - inode->i_rdev = 0; - - if ((inode->i_blksize != 0) && (inode->i_size != 0)) - { - inode->i_blocks = - (inode->i_size - 1) / inode->i_blksize + 1; - } - else - { - inode->i_blocks = 0; + inode->i_nlink = 1; + inode->i_uid = NCP_SERVER(inode)->m.uid; + inode->i_gid = NCP_SERVER(inode)->m.gid; + inode->i_blksize = 512; + inode->i_rdev = 0; + + if ((inode->i_blksize != 0) && (inode->i_size != 0)) { + inode->i_blocks = + (inode->i_size - 1) / inode->i_blksize + 1; + } else { + inode->i_blocks = 0; } inode->i_mtime = ncp_date_dos2unix(le16_to_cpu(NCP_ISTRUCT(inode)->modifyTime), - le16_to_cpu(NCP_ISTRUCT(inode)->modifyDate)); + le16_to_cpu(NCP_ISTRUCT(inode)->modifyDate)); inode->i_ctime = ncp_date_dos2unix(le16_to_cpu(NCP_ISTRUCT(inode)->creationTime), - le16_to_cpu(NCP_ISTRUCT(inode)->creationDate)); + le16_to_cpu(NCP_ISTRUCT(inode)->creationDate)); inode->i_atime = ncp_date_dos2unix(0, - le16_to_cpu(NCP_ISTRUCT(inode)->lastAccessDate)); + le16_to_cpu(NCP_ISTRUCT(inode)->lastAccessDate)); - if (S_ISREG(inode->i_mode)) - { - inode->i_op = &ncp_file_inode_operations; - } - else if (S_ISDIR(inode->i_mode)) - { - inode->i_op = &ncp_dir_inode_operations; - } - else - { - inode->i_op = NULL; + if (S_ISREG(inode->i_mode)) { + inode->i_op = &ncp_file_inode_operations; + } else if (S_ISDIR(inode->i_mode)) { + inode->i_op = &ncp_dir_inode_operations; + } else { + inode->i_op = NULL; } } -static void -ncp_put_inode(struct inode *inode) +static void ncp_put_inode(struct inode *inode) { - struct nw_file_info *finfo = NCP_FINFO(inode); + struct nw_file_info *finfo = NCP_FINFO(inode); struct super_block *sb = inode->i_sb; lock_super(sb); - if (finfo->opened != 0) - { - if (ncp_close_file(NCP_SERVER(inode), finfo->file_handle)!=0) - { - /* We can't do anything but complain. */ - printk("ncp_put_inode: could not close\n"); - } - } - + if (finfo->opened != 0) { + if (ncp_close_file(NCP_SERVER(inode), finfo->file_handle) != 0) { + /* We can't do anything but complain. */ + printk("ncp_put_inode: could not close\n"); + } + } DDPRINTK("ncp_put_inode: put %s\n", - finfo->i.entryName); + finfo->i.entryName); - ncp_free_inode_info(NCP_INOP(inode)); + ncp_free_inode_info(NCP_INOP(inode)); - if (S_ISDIR(inode->i_mode)) - { - DDPRINTK("ncp_put_inode: put directory %ld\n", + if (S_ISDIR(inode->i_mode)) { + DDPRINTK("ncp_put_inode: put directory %ld\n", inode->i_ino); - ncp_invalid_dir_cache(inode); - } - + ncp_invalid_dir_cache(inode); + } clear_inode(inode); unlock_super(sb); } struct super_block * -ncp_read_super(struct super_block *sb, void *raw_data, int silent) + ncp_read_super(struct super_block *sb, void *raw_data, int silent) { struct ncp_mount_data *data = (struct ncp_mount_data *) raw_data; - struct ncp_server *server; + struct ncp_server *server; struct file *ncp_filp; - struct file *wdog_filp; - struct file *msg_filp; kdev_t dev = sb->s_dev; int error; - if (data == NULL) - { + if (data == NULL) { printk("ncp_read_super: missing data argument\n"); sb->s_dev = 0; return NULL; } - - if (data->version != NCP_MOUNT_VERSION) - { + if (data->version != NCP_MOUNT_VERSION) { printk("ncp warning: mount version %s than kernel\n", (data->version < NCP_MOUNT_VERSION) ? - "older" : "newer"); + "older" : "newer"); sb->s_dev = 0; return NULL; } - - if ( (data->ncp_fd >= NR_OPEN) + if ((data->ncp_fd >= NR_OPEN) || ((ncp_filp = current->files->fd[data->ncp_fd]) == NULL) - || (!S_ISSOCK(ncp_filp->f_inode->i_mode))) - { + || (!S_ISSOCK(ncp_filp->f_inode->i_mode))) { printk("ncp_read_super: invalid ncp socket\n"); sb->s_dev = 0; return NULL; } + /* We must malloc our own super-block info */ + server = (struct ncp_server *) ncp_kmalloc(sizeof(struct ncp_server), + GFP_KERNEL); - if ( (data->wdog_fd >= NR_OPEN) - || ((wdog_filp = current->files->fd[data->wdog_fd]) == NULL) - || (!S_ISSOCK(wdog_filp->f_inode->i_mode))) - { - printk("ncp_read_super: invalid wdog socket\n"); - sb->s_dev = 0; + if (server == NULL) { + printk("ncp_read_super: could not alloc ncp_server\n"); return NULL; } - - if ( (data->message_fd >= NR_OPEN) - || ((msg_filp = current->files->fd[data->message_fd]) == NULL) - || (!S_ISSOCK(msg_filp->f_inode->i_mode))) - { - printk("ncp_read_super: invalid wdog socket\n"); - sb->s_dev = 0; - return NULL; - } - - /* We must malloc our own super-block info */ - server = (struct ncp_server *)ncp_kmalloc(sizeof(struct ncp_server), - GFP_KERNEL); - - if (server == NULL) - { - printk("ncp_read_super: could not alloc ncp_server\n"); - return NULL; - } - ncp_filp->f_count += 1; - wdog_filp->f_count += 1; - msg_filp->f_count += 1; lock_super(sb); - NCP_SBP(sb) = server; + NCP_SBP(sb) = server; - sb->s_blocksize = 1024; /* Eh... Is this correct? */ + sb->s_blocksize = 1024; /* Eh... Is this correct? */ sb->s_blocksize_bits = 10; sb->s_magic = NCP_SUPER_MAGIC; sb->s_dev = dev; sb->s_op = &ncp_sops; - server->ncp_filp = ncp_filp; - server->wdog_filp = wdog_filp; - server->msg_filp = msg_filp; - server->lock = 0; - server->wait = NULL; - server->packet = NULL; + server->ncp_filp = ncp_filp; + server->lock = 0; + server->wait = NULL; + server->packet = NULL; server->buffer_size = 0; server->conn_status = 0; - server->m = *data; + server->m = *data; /* Althought anything producing this is buggy, it happens now because of PATH_MAX changes.. */ if (server->m.time_out < 10) { @@ -254,166 +203,98 @@ printk("You need to recompile your ncpfs utils..\n"); } server->m.file_mode = (server->m.file_mode & - (S_IRWXU|S_IRWXG|S_IRWXO)) | S_IFREG; - server->m.dir_mode = (server->m.dir_mode & - (S_IRWXU|S_IRWXG|S_IRWXO)) | S_IFDIR; - - /* protect against invalid mount points */ - server->m.mount_point[sizeof(server->m.mount_point)-1] = '\0'; + (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG; + server->m.dir_mode = (server->m.dir_mode & + (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFDIR; server->packet_size = NCP_PACKET_SIZE; - server->packet = ncp_kmalloc(NCP_PACKET_SIZE, GFP_KERNEL); + server->packet = ncp_kmalloc(NCP_PACKET_SIZE, GFP_KERNEL); - if (server->packet == NULL) - { + if (server->packet == NULL) { printk("ncpfs: could not alloc packet\n"); error = -ENOMEM; unlock_super(sb); goto fail; } - - /* - * Make the connection to the server - */ - - if (ncp_catch_watchdog(server) != 0) - { - printk("ncp_read_super: Could not catch watchdog\n"); - error = -EINVAL; - unlock_super(sb); - goto fail; - } - - if (ncp_catch_message(server) != 0) - { - printk("ncp_read_super: Could not catch messages\n"); - ncp_dont_catch_watchdog(server); - error = -EINVAL; - unlock_super(sb); - goto fail; - } - ncp_lock_server(server); error = ncp_connect(server); ncp_unlock_server(server); unlock_super(sb); - if (error < 0) - { + if (error < 0) { sb->s_dev = 0; printk("ncp_read_super: Failed connection, bailing out " - "(error = %d).\n", -error); - ncp_kfree_s(server->packet, server->packet_size); - ncp_dont_catch_watchdog(server); - goto fail; + "(error = %d).\n", -error); + ncp_kfree_s(server->packet, server->packet_size); + goto fail; } - - DPRINTK("ncp_read_super: NCP_SBP(sb) = %x\n", (int)NCP_SBP(sb)); + DPRINTK("ncp_read_super: NCP_SBP(sb) = %x\n", (int) NCP_SBP(sb)); ncp_init_root(server); - if (!(sb->s_mounted = iget(sb, ncp_info_ino(server, &(server->root))))) - { + if (!(sb->s_mounted = iget(sb, ncp_info_ino(server, + &(server->root))))) { sb->s_dev = 0; printk("ncp_read_super: get root inode failed\n"); - goto disconnect; + goto disconnect; } - if (ncp_negotiate_buffersize(server, NCP_DEFAULT_BUFSIZE, - &(server->buffer_size)) != 0) - { + &(server->buffer_size)) != 0) { sb->s_dev = 0; printk("ncp_read_super: could not get bufsize\n"); goto disconnect; } - DPRINTK("ncpfs: bufsize = %d\n", server->buffer_size); - MOD_INC_USE_COUNT; + MOD_INC_USE_COUNT; return sb; - disconnect: + disconnect: ncp_lock_server(server); ncp_disconnect(server); ncp_unlock_server(server); ncp_kfree_s(server->packet, server->packet_size); - ncp_dont_catch_watchdog(server); - fail: + fail: ncp_filp->f_count -= 1; - wdog_filp->f_count -= 1; - msg_filp->f_count -= 1; - ncp_kfree_s(NCP_SBP(sb), sizeof(struct ncp_server)); - return NULL; + ncp_kfree_s(NCP_SBP(sb), sizeof(struct ncp_server)); + return NULL; } -static void -ncp_put_super(struct super_block *sb) +static void ncp_put_super(struct super_block *sb) { - struct ncp_server *server = NCP_SBP(sb); + struct ncp_server *server = NCP_SBP(sb); lock_super(sb); ncp_lock_server(server); - ncp_disconnect(server); + ncp_disconnect(server); ncp_unlock_server(server); close_fp(server->ncp_filp); + kill_proc(server->m.wdog_pid, SIGTERM, 0); - ncp_dont_catch_watchdog(server); - close_fp(server->wdog_filp); - close_fp(server->msg_filp); - - ncp_free_all_inodes(server); + ncp_free_all_inodes(server); - ncp_kfree_s(server->packet, server->packet_size); + ncp_kfree_s(server->packet, server->packet_size); sb->s_dev = 0; - ncp_kfree_s(NCP_SBP(sb), sizeof(struct ncp_server)); + ncp_kfree_s(NCP_SBP(sb), sizeof(struct ncp_server)); NCP_SBP(sb) = NULL; unlock_super(sb); - MOD_DEC_USE_COUNT; + MOD_DEC_USE_COUNT; } -/* This routine is called from an interrupt in ncp_msg_data_ready. So - * we have to be careful NOT to sleep here! */ -void -ncp_trigger_message(struct ncp_server *server) -{ -#ifdef CONFIG_KERNELD - char command[ sizeof(server->m.mount_point) - + sizeof(NCP_MSG_COMMAND) + 2]; -#endif - - if (server == NULL) - { - printk("ncp_trigger_message: invalid server!\n"); - return; - } - - DPRINTK("ncp_trigger_message: on %s\n", - server->m.mount_point); - -#ifdef CONFIG_KERNELD - strcpy(command, NCP_MSG_COMMAND); - strcat(command, " "); - strcat(command, server->m.mount_point); - DPRINTK("ksystem: %s\n", command); - ksystem(command, KERNELD_NOWAIT); -#endif -} - -static void -ncp_statfs(struct super_block *sb, struct statfs *buf, int bufsiz) +static void ncp_statfs(struct super_block *sb, struct statfs *buf, int bufsiz) { struct statfs tmp; /* We cannot say how much disk space is left on a mounted - NetWare Server, because free space is distributed over - volumes, and the current user might have disk quotas. So - free space is not that simple to determine. Our decision - here is to err conservatively. */ + NetWare Server, because free space is distributed over + volumes, and the current user might have disk quotas. So + free space is not that simple to determine. Our decision + here is to err conservatively. */ tmp.f_type = NCP_SUPER_MAGIC; tmp.f_bsize = 512; @@ -426,18 +307,15 @@ copy_to_user(buf, &tmp, bufsiz); } -static int -ncp_notify_change(struct inode *inode, struct iattr *attr) +static int ncp_notify_change(struct inode *inode, struct iattr *attr) { int result = 0; int info_mask; struct nw_modify_dos_info info; - if (!ncp_conn_valid(NCP_SERVER(inode))) - { + if (!ncp_conn_valid(NCP_SERVER(inode))) { return -EIO; } - if ((result = inode_change_ok(inode, attr)) < 0) return result; @@ -447,7 +325,7 @@ if (((attr->ia_valid & ATTR_GID) && (attr->ia_uid != NCP_SERVER(inode)->m.gid))) - return -EPERM; + return -EPERM; if (((attr->ia_valid & ATTR_MODE) && (attr->ia_mode & @@ -457,67 +335,54 @@ info_mask = 0; memset(&info, 0, sizeof(info)); - if ((attr->ia_valid & ATTR_CTIME) != 0) - { - info_mask |= (DM_CREATE_TIME|DM_CREATE_DATE); + if ((attr->ia_valid & ATTR_CTIME) != 0) { + info_mask |= (DM_CREATE_TIME | DM_CREATE_DATE); ncp_date_unix2dos(attr->ia_ctime, - &(info.creationTime), &(info.creationDate)); + &(info.creationTime), &(info.creationDate)); info.creationTime = le16_to_cpu(info.creationTime); info.creationDate = le16_to_cpu(info.creationDate); } - - if ((attr->ia_valid & ATTR_MTIME) != 0) - { - info_mask |= (DM_MODIFY_TIME|DM_MODIFY_DATE); + if ((attr->ia_valid & ATTR_MTIME) != 0) { + info_mask |= (DM_MODIFY_TIME | DM_MODIFY_DATE); ncp_date_unix2dos(attr->ia_mtime, &(info.modifyTime), &(info.modifyDate)); info.modifyTime = le16_to_cpu(info.modifyTime); info.modifyDate = le16_to_cpu(info.modifyDate); } - - if ((attr->ia_valid & ATTR_ATIME) != 0) - { + if ((attr->ia_valid & ATTR_ATIME) != 0) { __u16 dummy; info_mask |= (DM_LAST_ACCESS_DATE); ncp_date_unix2dos(attr->ia_ctime, &(dummy), &(info.lastAccessDate)); info.lastAccessDate = le16_to_cpu(info.lastAccessDate); } - - if (info_mask != 0) - { + if (info_mask != 0) { if ((result = ncp_modify_file_or_subdir_dos_info(NCP_SERVER(inode), - NCP_ISTRUCT(inode), + NCP_ISTRUCT(inode), info_mask, - &info)) != 0) - { + &info)) != 0) { result = -EACCES; - if (info_mask == (DM_CREATE_TIME|DM_CREATE_DATE)) - { + if (info_mask == (DM_CREATE_TIME | DM_CREATE_DATE)) { /* NetWare seems not to allow this. I - do not know why. So, just tell the - user everything went fine. This is - a terrible hack, but I do not know - how to do this correctly. */ + do not know why. So, just tell the + user everything went fine. This is + a terrible hack, but I do not know + how to do this correctly. */ result = 0; } } } - - if ((attr->ia_valid & ATTR_SIZE) != 0) - { + if ((attr->ia_valid & ATTR_SIZE) != 0) { int written; DPRINTK("ncpfs: trying to change size of %s to %ld\n", NCP_ISTRUCT(inode)->entryName, attr->ia_size); - if ((result = ncp_make_open(inode, O_RDWR)) < 0) - { + if ((result = ncp_make_open(inode, O_RDWR)) < 0) { return -EACCES; } - ncp_write(NCP_SERVER(inode), NCP_FINFO(inode)->file_handle, attr->ia_size, 0, "", &written); @@ -529,8 +394,7 @@ result = 0; } - - ncp_invalid_dir_cache(NCP_INOP(inode)->dir->inode); + ncp_invalid_dir_cache(NCP_INOP(inode)->dir->inode); return result; } @@ -540,40 +404,40 @@ int ncp_current_malloced; #endif -static struct file_system_type ncp_fs_type = { - ncp_read_super, "ncpfs", 0, NULL - }; +static struct file_system_type ncp_fs_type = +{ + ncp_read_super, "ncpfs", 0, NULL +}; int init_ncp_fs(void) { - return register_filesystem(&ncp_fs_type); + return register_filesystem(&ncp_fs_type); } #ifdef MODULE EXPORT_NO_SYMBOLS; -int init_module( void) +int init_module(void) { - DPRINTK("ncpfs: init_module called\n"); + DPRINTK("ncpfs: init_module called\n"); #ifdef DEBUG_NCP_MALLOC - ncp_malloced = 0; - ncp_current_malloced = 0; + ncp_malloced = 0; + ncp_current_malloced = 0; #endif - ncp_init_dir_cache(); + ncp_init_dir_cache(); return init_ncp_fs(); } -void -cleanup_module(void) +void cleanup_module(void) { - DPRINTK("ncpfs: cleanup_module called\n"); - ncp_free_dir_cache(); - unregister_filesystem(&ncp_fs_type); + DPRINTK("ncpfs: cleanup_module called\n"); + ncp_free_dir_cache(); + unregister_filesystem(&ncp_fs_type); #ifdef DEBUG_NCP_MALLOC - printk("ncp_malloced: %d\n", ncp_malloced); - printk("ncp_current_malloced: %d\n", ncp_current_malloced); + printk("ncp_malloced: %d\n", ncp_malloced); + printk("ncp_current_malloced: %d\n", ncp_current_malloced); #endif } diff -urN 2.1.29/fs/ncpfs/ioctl.c 2.1.29-patched/fs/ncpfs/ioctl.c --- 2.1.29/fs/ncpfs/ioctl.c Mon Oct 28 13:29:26 1996 +++ 2.1.29-patched/fs/ncpfs/ioctl.c Sat Mar 22 19:13:11 1997 @@ -14,70 +14,41 @@ #include #include -int -ncp_ioctl (struct inode * inode, struct file * filp, - unsigned int cmd, unsigned long arg) +int ncp_ioctl(struct inode *inode, struct file *filp, + unsigned int cmd, unsigned long arg) { int result; struct ncp_ioctl_request request; struct ncp_fs_info info; struct ncp_server *server = NCP_SERVER(inode); - /* - * Binary compatible with 1.3.XX releases. - * Take this out in 2.1.0 development series. - * 12 Mar 1996 - */ - switch(cmd) { - case _IOR('n', 1, unsigned char *): - cmd = NCP_IOC_NCPREQUEST; - break; - case _IOR('u', 1, uid_t): - cmd = NCP_IOC_GETMOUNTUID; - break; - case _IO('l', 1): - cmd = NCP_IOC_CONN_LOGGED_IN; - break; - case _IOWR('i', 1, unsigned char *): - cmd = NCP_IOC_GET_FS_INFO; - break; - } - - switch(cmd) { + switch (cmd) { case NCP_IOC_NCPREQUEST: - if ( (permission(inode, MAY_WRITE) != 0) - && (current->uid != server->m.mounted_uid)) - { + if ((permission(inode, MAY_WRITE) != 0) + && (current->uid != server->m.mounted_uid)) { return -EACCES; } - - if ((result = verify_area(VERIFY_READ, (char *)arg, - sizeof(request))) != 0) - { + if ((result = verify_area(VERIFY_READ, (char *) arg, + sizeof(request))) != 0) { return result; } + copy_from_user(&request, (struct ncp_ioctl_request *) arg, + sizeof(request)); - copy_from_user(&request, (struct ncp_ioctl_request *)arg, - sizeof(request)); - - if ( (request.function > 255) + if ((request.function > 255) || (request.size > - NCP_PACKET_SIZE - sizeof(struct ncp_request_header))) - { + NCP_PACKET_SIZE - sizeof(struct ncp_request_header))) { return -EINVAL; } - - if ((result = verify_area(VERIFY_WRITE, (char *)request.data, - NCP_PACKET_SIZE)) != 0) - { + if ((result = verify_area(VERIFY_WRITE, (char *) request.data, + NCP_PACKET_SIZE)) != 0) { return result; } - ncp_lock_server(server); /* FIXME: We hack around in the server's structures - here to be able to use ncp_request */ + here to be able to use ncp_request */ server->has_subfunction = 0; server->current_size = request.size; @@ -95,66 +66,55 @@ case NCP_IOC_CONN_LOGGED_IN: - if ( (permission(inode, MAY_WRITE) != 0) - && (current->uid != server->m.mounted_uid)) - { + if ((permission(inode, MAY_WRITE) != 0) + && (current->uid != server->m.mounted_uid)) { return -EACCES; } - return ncp_conn_logged_in(server); - + case NCP_IOC_GET_FS_INFO: - if ( (permission(inode, MAY_WRITE) != 0) - && (current->uid != server->m.mounted_uid)) - { + if ((permission(inode, MAY_WRITE) != 0) + && (current->uid != server->m.mounted_uid)) { return -EACCES; } - - if ((result = verify_area(VERIFY_WRITE, (char *)arg, - sizeof(info))) != 0) - { + if ((result = verify_area(VERIFY_WRITE, (char *) arg, + sizeof(info))) != 0) { return result; } + copy_from_user(&info, (struct ncp_fs_info *) arg, + sizeof(info)); - copy_from_user(&info, (struct ncp_fs_info *)arg, - sizeof(info)); - - if (info.version != NCP_GET_FS_INFO_VERSION) - { + if (info.version != NCP_GET_FS_INFO_VERSION) { DPRINTK("info.version invalid: %d\n", info.version); return -EINVAL; } - - info.addr = server->m.serv_addr; - info.mounted_uid = server->m.mounted_uid; - info.connection = server->connection; - info.buffer_size = server->buffer_size; + /* TODO: info.addr = server->m.serv_addr; */ + info.mounted_uid = server->m.mounted_uid; + info.connection = server->connection; + info.buffer_size = server->buffer_size; info.volume_number = NCP_ISTRUCT(inode)->volNumber; - info.directory_id = NCP_ISTRUCT(inode)->DosDirNum; + info.directory_id = NCP_ISTRUCT(inode)->DosDirNum; - copy_to_user((struct ncp_fs_info *)arg, &info, sizeof(info)); - return 0; + copy_to_user((struct ncp_fs_info *) arg, &info, sizeof(info)); + return 0; - case NCP_IOC_GETMOUNTUID: + case NCP_IOC_GETMOUNTUID: - if ( (permission(inode, MAY_READ) != 0) - && (current->uid != server->m.mounted_uid)) - { + if ((permission(inode, MAY_READ) != 0) + && (current->uid != server->m.mounted_uid)) { return -EACCES; } - - if ((result = verify_area(VERIFY_WRITE, (uid_t*) arg, - sizeof(uid_t))) != 0) - { - return result; - } - put_user(server->m.mounted_uid, (uid_t *) arg); - return 0; + if ((result = verify_area(VERIFY_WRITE, (uid_t *) arg, + sizeof(uid_t))) != 0) { + return result; + } + put_user(server->m.mounted_uid, (uid_t *) arg); + return 0; default: return -EINVAL; } - + return -EINVAL; } diff -urN 2.1.29/fs/ncpfs/mmap.c 2.1.29-patched/fs/ncpfs/mmap.c --- 2.1.29/fs/ncpfs/mmap.c Mon Oct 28 13:29:26 1996 +++ 2.1.29-patched/fs/ncpfs/mmap.c Sat Mar 22 19:13:11 1997 @@ -23,17 +23,16 @@ static inline int min(int a, int b) { - return avm_inode; + struct inode *inode = area->vm_inode; unsigned long page; unsigned int clear; unsigned long tmp; @@ -48,37 +47,28 @@ pos = address - area->vm_start + area->vm_offset; clear = 0; - if (address + PAGE_SIZE > area->vm_end) - { + if (address + PAGE_SIZE > area->vm_end) { clear = address + PAGE_SIZE - area->vm_end; } - - /* what we can read in one go */ + /* what we can read in one go */ bufsize = NCP_SERVER(inode)->buffer_size; fs = get_fs(); set_fs(get_ds()); - if (ncp_make_open(inode, O_RDONLY) < 0) - { - clear = PAGE_SIZE; - } - else - { + if (ncp_make_open(inode, O_RDONLY) < 0) { + clear = PAGE_SIZE; + } else { int already_read = 0; int count = PAGE_SIZE - clear; int to_read; - while (already_read < count) - { + while (already_read < count) { int read_this_time; - if ((pos % bufsize) != 0) - { + if ((pos % bufsize) != 0) { to_read = bufsize - (pos % bufsize); - } - else - { + } else { to_read = bufsize; } @@ -87,33 +77,31 @@ if (ncp_read(NCP_SERVER(inode), NCP_FINFO(inode)->file_handle, pos, to_read, - (char *)(page + already_read), - &read_this_time) != 0) - { - read_this_time = 0; + (char *) (page + already_read), + &read_this_time) != 0) { + read_this_time = 0; } - pos += read_this_time; already_read += read_this_time; - if (read_this_time < to_read) - { + if (read_this_time < to_read) { break; } } - } + } set_fs(fs); tmp = page + PAGE_SIZE; while (clear--) { - *(char *)--tmp = 0; + *(char *) --tmp = 0; } return page; } -struct vm_operations_struct ncp_file_mmap = { +struct vm_operations_struct ncp_file_mmap = +{ NULL, /* open */ NULL, /* close */ NULL, /* unmap */ @@ -128,18 +116,15 @@ /* This is used for a general mmap of a ncp file */ -int -ncp_mmap(struct inode * inode, struct file * file, struct vm_area_struct * vma) +int ncp_mmap(struct inode *inode, struct file *file, struct vm_area_struct *vma) { - DPRINTK("ncp_mmap: called\n"); + DPRINTK("ncp_mmap: called\n"); - if (!ncp_conn_valid(NCP_SERVER(inode))) - { + if (!ncp_conn_valid(NCP_SERVER(inode))) { return -EIO; } - - /* only PAGE_COW or read-only supported now */ - if (vma->vm_flags & VM_SHARED) + /* only PAGE_COW or read-only supported now */ + if (vma->vm_flags & VM_SHARED) return -EINVAL; if (!inode->i_sb || !S_ISREG(inode->i_mode)) return -EACCES; @@ -147,7 +132,6 @@ inode->i_atime = CURRENT_TIME; inode->i_dirt = 1; } - vma->vm_inode = inode; inode->i_count++; vma->vm_ops = &ncp_file_mmap; diff -urN 2.1.29/fs/ncpfs/ncplib_kernel.c 2.1.29-patched/fs/ncpfs/ncplib_kernel.c --- 2.1.29/fs/ncpfs/ncplib_kernel.c Mon Dec 30 11:03:22 1996 +++ 2.1.29-patched/fs/ncpfs/ncplib_kernel.c Sat Mar 22 19:13:11 1997 @@ -8,53 +8,43 @@ #include "ncplib_kernel.h" -typedef __u8 byte; -typedef __u16 word; -typedef __u32 dword; - static inline int min(int a, int b) { - return alock == 0) - { + if (server->lock == 0) { DPRINTK("ncpfs: server not locked!\n"); } } -static void -ncp_add_byte(struct ncp_server *server, byte x) +static void ncp_add_byte(struct ncp_server *server, __u8 x) { assert_server_locked(server); - *(byte *)(&(server->packet[server->current_size])) = x; + *(__u8 *) (&(server->packet[server->current_size])) = x; server->current_size += 1; return; } -static void -ncp_add_word(struct ncp_server *server, word x) +static void ncp_add_word(struct ncp_server *server, __u16 x) { assert_server_locked(server); - put_unaligned(x, (word *)(&(server->packet[server->current_size]))); + put_unaligned(x, (__u16 *) (&(server->packet[server->current_size]))); server->current_size += 2; return; } -static void -ncp_add_dword(struct ncp_server *server, dword x) +static void ncp_add_dword(struct ncp_server *server, __u32 x) { assert_server_locked(server); - put_unaligned(x, (dword *)(&(server->packet[server->current_size]))); + put_unaligned(x, (__u32 *) (&(server->packet[server->current_size]))); server->current_size += 4; return; } -static void -ncp_add_mem(struct ncp_server *server, const void *source, int size) +static void ncp_add_mem(struct ncp_server *server, const void *source, int size) { assert_server_locked(server); memcpy(&(server->packet[server->current_size]), source, size); @@ -62,8 +52,7 @@ return; } -static void -ncp_add_mem_fromfs(struct ncp_server *server, const char *source, int size) +static void ncp_add_mem_fromfs(struct ncp_server *server, const char *source, int size) { assert_server_locked(server); copy_from_user(&(server->packet[server->current_size]), source, size); @@ -71,13 +60,11 @@ return; } -static void -ncp_add_pstring(struct ncp_server *server, const char *s) +static void ncp_add_pstring(struct ncp_server *server, const char *s) { int len = strlen(s); assert_server_locked(server); - if (len > 255) - { + if (len > 255) { DPRINTK("ncpfs: string too long: %s\n", s); len = 255; } @@ -86,8 +73,7 @@ return; } -static void -ncp_init_request(struct ncp_server *server) +static void ncp_init_request(struct ncp_server *server) { ncp_lock_server(server); @@ -95,11 +81,10 @@ server->has_subfunction = 0; } -static void -ncp_init_request_s(struct ncp_server *server, int subfunction) +static void ncp_init_request_s(struct ncp_server *server, int subfunction) { ncp_init_request(server); - ncp_add_word(server, 0); /* preliminary size */ + ncp_add_word(server, 0); /* preliminary size */ ncp_add_byte(server, subfunction); @@ -107,53 +92,49 @@ } static char * -ncp_reply_data(struct ncp_server *server, int offset) + ncp_reply_data(struct ncp_server *server, int offset) { return &(server->packet[sizeof(struct ncp_reply_header) + offset]); } -static byte -ncp_reply_byte(struct ncp_server *server, int offset) +static __u8 + ncp_reply_byte(struct ncp_server *server, int offset) { - return *(byte *)(ncp_reply_data(server, offset)); + return get_unaligned((__u8 *) ncp_reply_data(server, offset)); } -static word -ncp_reply_word(struct ncp_server *server, int offset) +static __u16 + ncp_reply_word(struct ncp_server *server, int offset) { - return *(word *)(ncp_reply_data(server, offset)); + return get_unaligned((__u16 *) ncp_reply_data(server, offset)); } -static dword -ncp_reply_dword(struct ncp_server *server, int offset) +static __u32 + ncp_reply_dword(struct ncp_server *server, int offset) { - return *(dword *)(ncp_reply_data(server, offset)); + return get_unaligned((__u32 *) ncp_reply_data(server, offset)); } -int -ncp_negotiate_buffersize(struct ncp_server *server, - int size, int *target) +int ncp_negotiate_buffersize(struct ncp_server *server, + int size, int *target) { int result; ncp_init_request(server); ncp_add_word(server, htons(size)); - - if ((result = ncp_request(server, 33)) != 0) - { + + if ((result = ncp_request(server, 33)) != 0) { ncp_unlock_server(server); return result; } - - *target =min(ntohs(ncp_reply_word(server, 0)), size); + *target = min(ntohs(ncp_reply_word(server, 0)), size); ncp_unlock_server(server); return 0; } -int -ncp_get_volume_info_with_number(struct ncp_server *server, int n, - struct ncp_volume_info *target) +int ncp_get_volume_info_with_number(struct ncp_server *server, int n, + struct ncp_volume_info *target) { int result; int len; @@ -161,14 +142,12 @@ ncp_init_request_s(server, 44); ncp_add_byte(server, n); - if ((result = ncp_request(server, 22)) != 0) - { + if ((result = ncp_request(server, 22)) != 0) { ncp_unlock_server(server); return result; } - target->total_blocks = ncp_reply_dword(server, 0); - target->free_blocks = ncp_reply_dword(server, 4); + target->free_blocks = ncp_reply_dword(server, 4); target->purgeable_blocks = ncp_reply_dword(server, 8); target->not_yet_purgeable_blocks = ncp_reply_dword(server, 12); target->total_dir_entries = ncp_reply_dword(server, 16); @@ -178,20 +157,17 @@ memset(&(target->volume_name), 0, sizeof(target->volume_name)); len = ncp_reply_byte(server, 29); - if (len > NCP_VOLNAME_LEN) - { + if (len > NCP_VOLNAME_LEN) { DPRINTK("ncpfs: volume name too long: %d\n", len); ncp_unlock_server(server); return -EIO; } - memcpy(&(target->volume_name), ncp_reply_data(server, 30), len); ncp_unlock_server(server); return 0; } -int -ncp_close_file(struct ncp_server *server, const char *file_id) +int ncp_close_file(struct ncp_server *server, const char *file_id) { int result; @@ -204,35 +180,27 @@ return result; } -static void -ncp_add_handle_path(struct ncp_server *server, - __u8 vol_num, - __u32 dir_base, int have_dir_base, - char *path) +static void ncp_add_handle_path(struct ncp_server *server, + __u8 vol_num, + __u32 dir_base, int have_dir_base, + char *path) { ncp_add_byte(server, vol_num); ncp_add_dword(server, dir_base); - if (have_dir_base != 0) - { - ncp_add_byte(server, 1); /* dir_base */ - } - else - { - ncp_add_byte(server, 0xff); /* no handle */ - } - if (path != NULL) - { - ncp_add_byte(server, 1); /* 1 component */ - ncp_add_pstring(server, path); + if (have_dir_base != 0) { + ncp_add_byte(server, 1); /* dir_base */ + } else { + ncp_add_byte(server, 0xff); /* no handle */ } - else - { + if (path != NULL) { + ncp_add_byte(server, 1); /* 1 component */ + ncp_add_pstring(server, path); + } else { ncp_add_byte(server, 0); } } -static void -ncp_extract_file_info(void *structure, struct nw_info_struct *target) +static void ncp_extract_file_info(void *structure, struct nw_info_struct *target) { __u8 *name_len; const int info_struct_size = sizeof(struct nw_info_struct) - 257; @@ -240,70 +208,60 @@ memcpy(target, structure, info_struct_size); name_len = structure + info_struct_size; target->nameLen = *name_len; - strncpy(target->entryName, name_len+1, *name_len); + strncpy(target->entryName, name_len + 1, *name_len); target->entryName[*name_len] = '\0'; return; } -int -ncp_obtain_info(struct ncp_server *server, - __u8 vol_num, __u32 dir_base, - char *path, /* At most 1 component */ - struct nw_info_struct *target) +int ncp_obtain_info(struct ncp_server *server, + __u8 vol_num, __u32 dir_base, + char *path, /* At most 1 component */ + struct nw_info_struct *target) { int result; - if (target == NULL) - { + if (target == NULL) { return -EINVAL; } - ncp_init_request(server); - ncp_add_byte(server, 6); /* subfunction */ + ncp_add_byte(server, 6); /* subfunction */ ncp_add_byte(server, server->name_space[vol_num]); ncp_add_byte(server, server->name_space[vol_num]); - ncp_add_word(server, htons(0xff00)); /* get all */ + ncp_add_word(server, htons(0xff00)); /* get all */ ncp_add_dword(server, RIM_ALL); ncp_add_handle_path(server, vol_num, dir_base, 1, path); - if ((result = ncp_request(server, 87)) != 0) - { + if ((result = ncp_request(server, 87)) != 0) { ncp_unlock_server(server); return result; } - ncp_extract_file_info(ncp_reply_data(server, 0), target); ncp_unlock_server(server); return 0; } -static inline int -ncp_has_os2_namespace(struct ncp_server *server, __u8 volume) +static inline int ncp_has_os2_namespace(struct ncp_server *server, __u8 volume) { int result; __u8 *namespace; __u16 no_namespaces; ncp_init_request(server); - ncp_add_byte(server, 24); /* Subfunction: Get Name Spaces Loaded */ + ncp_add_byte(server, 24); /* Subfunction: Get Name Spaces Loaded */ ncp_add_word(server, 0); ncp_add_byte(server, volume); - if ((result = ncp_request(server, 87)) != 0) - { + if ((result = ncp_request(server, 87)) != 0) { ncp_unlock_server(server); return 0; } - no_namespaces = ncp_reply_word(server, 0); namespace = ncp_reply_data(server, 2); - while (no_namespaces > 0) - { - DPRINTK("get_namespaces: found %d on %d\n", *namespace,volume); + while (no_namespaces > 0) { + DPRINTK("get_namespaces: found %d on %d\n", *namespace, volume); - if (*namespace == 4) - { + if (*namespace == 4) { DPRINTK("get_namespaces: found OS2\n"); ncp_unlock_server(server); return 1; @@ -315,10 +273,9 @@ return 0; } -int -ncp_lookup_volume(struct ncp_server *server, - char *volname, - struct nw_info_struct *target) +int ncp_lookup_volume(struct ncp_server *server, + char *volname, + struct nw_info_struct *target) { int result; int volnum; @@ -326,30 +283,28 @@ DPRINTK("ncp_lookup_volume: looking up vol %s\n", volname); ncp_init_request(server); - ncp_add_byte(server, 22); /* Subfunction: Generate dir handle */ - ncp_add_byte(server, 0); /* DOS namespace */ - ncp_add_byte(server, 0); /* reserved */ - ncp_add_byte(server, 0); /* reserved */ - ncp_add_byte(server, 0); /* reserved */ - - ncp_add_byte(server, 0); /* faked volume number */ - ncp_add_dword(server, 0); /* faked dir_base */ - ncp_add_byte(server, 0xff); /* Don't have a dir_base */ - ncp_add_byte(server, 1); /* 1 path component */ + ncp_add_byte(server, 22); /* Subfunction: Generate dir handle */ + ncp_add_byte(server, 0); /* DOS namespace */ + ncp_add_byte(server, 0); /* reserved */ + ncp_add_byte(server, 0); /* reserved */ + ncp_add_byte(server, 0); /* reserved */ + + ncp_add_byte(server, 0); /* faked volume number */ + ncp_add_dword(server, 0); /* faked dir_base */ + ncp_add_byte(server, 0xff); /* Don't have a dir_base */ + ncp_add_byte(server, 1); /* 1 path component */ ncp_add_pstring(server, volname); - if ((result = ncp_request(server, 87)) != 0) - { + if ((result = ncp_request(server, 87)) != 0) { ncp_unlock_server(server); return result; } - memset(target, 0, sizeof(*target)); target->DosDirNum = target->dirEntNum = ncp_reply_dword(server, 4); target->volNumber = volnum = ncp_reply_byte(server, 8); ncp_unlock_server(server); - server->name_space[volnum] = ncp_has_os2_namespace(server,volnum)?4:0; + server->name_space[volnum] = ncp_has_os2_namespace(server, volnum) ? 4 : 0; DPRINTK("lookup_vol: namespace[%d] = %d\n", volnum, server->name_space[volnum]); @@ -360,19 +315,18 @@ return 0; } -int -ncp_modify_file_or_subdir_dos_info(struct ncp_server *server, - struct nw_info_struct *file, - __u32 info_mask, - struct nw_modify_dos_info *info) +int ncp_modify_file_or_subdir_dos_info(struct ncp_server *server, + struct nw_info_struct *file, + __u32 info_mask, + struct nw_modify_dos_info *info) { int result; ncp_init_request(server); - ncp_add_byte(server, 7); /* subfunction */ + ncp_add_byte(server, 7); /* subfunction */ ncp_add_byte(server, server->name_space[file->volNumber]); - ncp_add_byte(server, 0); /* reserved */ - ncp_add_word(server, htons(0x0680)); /* search attribs: all */ + ncp_add_byte(server, 0); /* reserved */ + ncp_add_word(server, htons(0x0680)); /* search attribs: all */ ncp_add_dword(server, info_mask); ncp_add_mem(server, info, sizeof(*info)); @@ -384,55 +338,50 @@ return result; } -int -ncp_del_file_or_subdir(struct ncp_server *server, - struct nw_info_struct *dir, char *name) +int ncp_del_file_or_subdir(struct ncp_server *server, + struct nw_info_struct *dir, char *name) { int result; ncp_init_request(server); - ncp_add_byte(server, 8); /* subfunction */ + ncp_add_byte(server, 8); /* subfunction */ ncp_add_byte(server, server->name_space[dir->volNumber]); - ncp_add_byte(server, 0); /* reserved */ - ncp_add_word(server, ntohs(0x0680)); /* search attribs: all */ + ncp_add_byte(server, 0); /* reserved */ + ncp_add_word(server, ntohs(0x0680)); /* search attribs: all */ ncp_add_handle_path(server, dir->volNumber, dir->dirEntNum, 1, name); - + result = ncp_request(server, 87); ncp_unlock_server(server); return result; } -static inline void -ConvertToNWfromDWORD ( __u32 sfd , __u8 ret[6] ) +static inline void ConvertToNWfromDWORD(__u32 sfd, __u8 ret[6]) { - __u16 *dest = (__u16 *) ret; - memcpy (ret + 2, &sfd, 4); - dest[0] = cpu_to_le16((le16_to_cpu(dest[1]) + le16_to_cpu(1))); - return; + __u16 *dest = (__u16 *) ret; + memcpy(ret + 2, &sfd, 4); + dest[0] = cpu_to_le16((le16_to_cpu(dest[1]) + le16_to_cpu(1))); + return; } /* If both dir and name are NULL, then in target there's already a looked-up entry that wants to be opened. */ -int -ncp_open_create_file_or_subdir(struct ncp_server *server, - struct nw_info_struct *dir, char *name, - int open_create_mode, - __u32 create_attributes, - int desired_acc_rights, - struct nw_file_info *target) +int ncp_open_create_file_or_subdir(struct ncp_server *server, + struct nw_info_struct *dir, char *name, + int open_create_mode, + __u32 create_attributes, + int desired_acc_rights, + struct nw_file_info *target) { int result; __u16 search_attribs = ntohs(0x0600); __u8 volume = (dir != NULL) ? dir->volNumber : target->i.volNumber; - if ((create_attributes & aDIR) != 0) - { - search_attribs |= ntohs(0x0080); + if ((create_attributes & aDIR) != 0) { + search_attribs |= ntohs(0x0080); } - ncp_init_request(server); - ncp_add_byte(server, 1); /* subfunction */ + ncp_add_byte(server, 1); /* subfunction */ ncp_add_byte(server, server->name_space[volume]); ncp_add_byte(server, open_create_mode); ncp_add_word(server, search_attribs); @@ -442,89 +391,76 @@ for directories */ ncp_add_word(server, desired_acc_rights); - if (dir != NULL) - { + if (dir != NULL) { ncp_add_handle_path(server, volume, dir->dirEntNum, 1, name); - } - else - { + } else { ncp_add_handle_path(server, volume, target->i.dirEntNum, 1, NULL); - } + } - if ((result = ncp_request(server, 87)) != 0) - { + if ((result = ncp_request(server, 87)) != 0) { ncp_unlock_server(server); return result; } - target->opened = 1; target->server_file_handle = ncp_reply_dword(server, 0); target->open_create_action = ncp_reply_byte(server, 4); - if (dir != NULL) - { + if (dir != NULL) { /* in target there's a new finfo to fill */ ncp_extract_file_info(ncp_reply_data(server, 5), &(target->i)); } - ConvertToNWfromDWORD(target->server_file_handle, target->file_handle); ncp_unlock_server(server); return 0; } - -int -ncp_initialize_search(struct ncp_server *server, - struct nw_info_struct *dir, - struct nw_search_sequence *target) + +int ncp_initialize_search(struct ncp_server *server, + struct nw_info_struct *dir, + struct nw_search_sequence *target) { int result; ncp_init_request(server); - ncp_add_byte(server, 2); /* subfunction */ + ncp_add_byte(server, 2); /* subfunction */ ncp_add_byte(server, server->name_space[dir->volNumber]); - ncp_add_byte(server, 0); /* reserved */ + ncp_add_byte(server, 0); /* reserved */ ncp_add_handle_path(server, dir->volNumber, dir->dirEntNum, 1, NULL); - - if ((result = ncp_request(server, 87)) != 0) - { + + if ((result = ncp_request(server, 87)) != 0) { ncp_unlock_server(server); return result; } - memcpy(target, ncp_reply_data(server, 0), sizeof(*target)); ncp_unlock_server(server); return 0; } - + /* Search for everything */ -int -ncp_search_for_file_or_subdir(struct ncp_server *server, - struct nw_search_sequence *seq, - struct nw_info_struct *target) +int ncp_search_for_file_or_subdir(struct ncp_server *server, + struct nw_search_sequence *seq, + struct nw_info_struct *target) { int result; ncp_init_request(server); - ncp_add_byte(server, 3); /* subfunction */ + ncp_add_byte(server, 3); /* subfunction */ ncp_add_byte(server, server->name_space[seq->volNumber]); - ncp_add_byte(server, 0); /* data stream (???) */ - ncp_add_word(server, 0xffff); /* Search attribs */ - ncp_add_dword(server, RIM_ALL); /* return info mask */ + ncp_add_byte(server, 0); /* data stream (???) */ + ncp_add_word(server, 0xffff); /* Search attribs */ + ncp_add_dword(server, RIM_ALL); /* return info mask */ ncp_add_mem(server, seq, 9); - ncp_add_byte(server, 2); /* 2 byte pattern */ - ncp_add_byte(server, 0xff); /* following is a wildcard */ + ncp_add_byte(server, 2); /* 2 byte pattern */ + ncp_add_byte(server, 0xff); /* following is a wildcard */ ncp_add_byte(server, '*'); - - if ((result = ncp_request(server, 87)) != 0) - { + + if ((result = ncp_request(server, 87)) != 0) { ncp_unlock_server(server); return result; } - memcpy(seq, ncp_reply_data(server, 0), sizeof(*seq)); ncp_extract_file_info(ncp_reply_data(server, 10), target); @@ -532,34 +468,33 @@ return 0; } -int -ncp_ren_or_mov_file_or_subdir(struct ncp_server *server, - struct nw_info_struct *old_dir, char *old_name, - struct nw_info_struct *new_dir, char *new_name) +int ncp_ren_or_mov_file_or_subdir(struct ncp_server *server, + struct nw_info_struct *old_dir, char *old_name, + struct nw_info_struct *new_dir, char *new_name) { int result; - if ( (old_dir == NULL) || (old_name == NULL) + if ((old_dir == NULL) || (old_name == NULL) || (new_dir == NULL) || (new_name == NULL)) return -EINVAL; - + ncp_init_request(server); - ncp_add_byte(server, 4); /* subfunction */ + ncp_add_byte(server, 4); /* subfunction */ ncp_add_byte(server, server->name_space[old_dir->volNumber]); - ncp_add_byte(server, 1); /* rename flag */ - ncp_add_word(server, ntohs (0x0680)); /* search attributes */ + ncp_add_byte(server, 1); /* rename flag */ + ncp_add_word(server, ntohs(0x0680)); /* search attributes */ /* source Handle Path */ ncp_add_byte(server, old_dir->volNumber); ncp_add_dword(server, old_dir->dirEntNum); ncp_add_byte(server, 1); - ncp_add_byte(server, 1); /* 1 source component */ + ncp_add_byte(server, 1); /* 1 source component */ /* dest Handle Path */ ncp_add_byte(server, new_dir->volNumber); ncp_add_dword(server, new_dir->dirEntNum); ncp_add_byte(server, 1); - ncp_add_byte(server, 1); /* 1 destination component */ + ncp_add_byte(server, 1); /* 1 destination component */ /* source path string */ ncp_add_pstring(server, old_name); @@ -570,13 +505,12 @@ ncp_unlock_server(server); return result; } - + /* We have to transfer to/from user space */ -int -ncp_read(struct ncp_server *server, const char *file_id, - __u32 offset, __u16 to_read, - char *target, int *bytes_read) +int ncp_read(struct ncp_server *server, const char *file_id, + __u32 offset, __u16 to_read, + char *target, int *bytes_read) { int result; @@ -586,24 +520,21 @@ ncp_add_dword(server, htonl(offset)); ncp_add_word(server, htons(to_read)); - if ((result = ncp_request(server, 72)) != 0) - { + if ((result = ncp_request(server, 72)) != 0) { ncp_unlock_server(server); return result; } - *bytes_read = ntohs(ncp_reply_word(server, 0)); - copy_to_user(target, ncp_reply_data(server, 2+(offset&1)), *bytes_read); + copy_to_user(target, ncp_reply_data(server, 2 + (offset & 1)), *bytes_read); ncp_unlock_server(server); return 0; } -int -ncp_write(struct ncp_server *server, const char *file_id, - __u32 offset, __u16 to_write, - const char *source, int *bytes_written) +int ncp_write(struct ncp_server *server, const char *file_id, + __u32 offset, __u16 to_write, + const char *source, int *bytes_written) { int result; @@ -614,15 +545,12 @@ ncp_add_word(server, htons(to_write)); ncp_add_mem_fromfs(server, source, to_write); - if ((result = ncp_request(server, 73)) != 0) - { + if ((result = ncp_request(server, 73)) != 0) { ncp_unlock_server(server); return result; } - *bytes_written = to_write; ncp_unlock_server(server); return 0; } - diff -urN 2.1.29/fs/ncpfs/ncplib_kernel.h 2.1.29-patched/fs/ncpfs/ncplib_kernel.h --- 2.1.29/fs/ncpfs/ncplib_kernel.h Mon Dec 30 11:03:22 1996 +++ 2.1.29-patched/fs/ncpfs/ncplib_kernel.h Sun Mar 23 13:05:18 1997 @@ -29,89 +29,11 @@ ncp_negotiate_buffersize(struct ncp_server *server, int size, int *target); int -ncp_get_encryption_key(struct ncp_server *server, - char *target); -int -ncp_get_bindery_object_id(struct ncp_server *server, - int object_type, char *object_name, - struct ncp_bindery_object *target); -int -ncp_login_encrypted(struct ncp_server *server, - struct ncp_bindery_object *object, - unsigned char *key, - unsigned char *passwd); -int -ncp_login_user(struct ncp_server *server, - unsigned char *username, - unsigned char *password); -int ncp_get_volume_info_with_number(struct ncp_server *server, int n, struct ncp_volume_info *target); int -ncp_get_volume_number(struct ncp_server *server, const char *name, - int *target); - -int -ncp_file_search_init(struct ncp_server *server, - int dir_handle, const char *path, - struct ncp_filesearch_info *target); - -int -ncp_file_search_continue(struct ncp_server *server, - struct ncp_filesearch_info *fsinfo, - int attributes, const char *path, - struct ncp_file_info *target); - -int -ncp_get_finfo(struct ncp_server *server, - int dir_handle, const char *path, const char *name, - struct ncp_file_info *target); - -int -ncp_open_file(struct ncp_server *server, - int dir_handle, const char *path, - int attr, int access, - struct ncp_file_info *target); -int ncp_close_file(struct ncp_server *server, const char *file_id); - -int -ncp_create_newfile(struct ncp_server *server, - int dir_handle, const char *path, - int attr, - struct ncp_file_info *target); - -int -ncp_create_file(struct ncp_server *server, - int dir_handle, const char *path, - int attr, - struct ncp_file_info *target); - -int -ncp_erase_file(struct ncp_server *server, - int dir_handle, const char *path, - int attr); - -int -ncp_rename_file(struct ncp_server *server, - int old_handle, const char *old_path, - int attr, - int new_handle, const char *new_path); - -int -ncp_create_directory(struct ncp_server *server, - int dir_handle, const char *path, - int inherit_mask); - -int -ncp_delete_directory(struct ncp_server *server, - int dir_handle, const char *path); - -int -ncp_rename_directory(struct ncp_server *server, - int dir_handle, - const char *old_path, const char *new_path); int ncp_read(struct ncp_server *server, const char *file_id, diff -urN 2.1.29/fs/ncpfs/sock.c 2.1.29-patched/fs/ncpfs/sock.c --- 2.1.29/fs/ncpfs/sock.c Sun Jan 26 11:07:44 1997 +++ 2.1.29-patched/fs/ncpfs/sock.c Sun Mar 23 09:37:46 1997 @@ -25,315 +25,59 @@ #include #include #include +#include - -#define _S(nr) (1<<((nr)-1)) -static int _recvfrom(struct socket *sock, unsigned char *ubuf, - int size, int noblock, unsigned flags, - struct sockaddr_ipx *sa) +static int _recv(struct socket *sock, unsigned char *ubuf, int size, + unsigned flags) { - struct iovec iov; - struct msghdr msg; + struct iovec iov; + struct msghdr msg; struct scm_cookie scm; memset(&scm, 0, sizeof(scm)); - iov.iov_base = ubuf; - iov.iov_len = size; - - msg.msg_name = (void *)sa; - msg.msg_namelen = 0; - if (sa) - msg.msg_namelen = sizeof(struct sockaddr_ipx); - msg.msg_control = NULL; - msg.msg_iov = &iov; - msg.msg_iovlen = 1; - if (noblock) { - flags |= MSG_DONTWAIT; - } + iov.iov_base = ubuf; + iov.iov_len = size; - return sock->ops->recvmsg(sock, &msg, size, flags, &scm); + msg.msg_name = NULL; + msg.msg_namelen = 0; + msg.msg_control = NULL; + msg.msg_iov = &iov; + msg.msg_iovlen = 1; + return sock->ops->recvmsg(sock, &msg, size, flags, &scm); } -static int _sendto(struct socket *sock, const void *buff, - int len, int noblock, unsigned flags, - struct sockaddr_ipx *sa) - +static int _send(struct socket *sock, const void *buff, int len) { - struct iovec iov; - struct msghdr msg; + struct iovec iov; + struct msghdr msg; struct scm_cookie scm; int err; - iov.iov_base = (void *)buff; - iov.iov_len = len; - - msg.msg_name = (void *)sa; - msg.msg_namelen = sizeof(struct sockaddr_ipx); - msg.msg_control = NULL; - msg.msg_iov = &iov; - msg.msg_iovlen = 1; + iov.iov_base = (void *) buff; + iov.iov_len = len; - if (noblock) { - flags |= MSG_DONTWAIT; - } - - msg.msg_flags = flags; + msg.msg_name = NULL; + msg.msg_namelen = 0; + msg.msg_control = NULL; + msg.msg_iov = &iov; + msg.msg_iovlen = 1; + msg.msg_flags = 0; err = scm_send(sock, &msg, &scm); - if (err < 0) + if (err < 0) { return err; - err = sock->ops->sendmsg(sock, &msg, len, &scm); + } + err = sock->ops->sendmsg(sock, &msg, len, &scm); scm_destroy(&scm); return err; } - -static void -ncp_wdog_data_ready(struct sock *sk, int len) -{ - struct socket *sock = sk->socket; - - if (!sk->dead) - { - unsigned char packet_buf[2]; - struct sockaddr_ipx sender; - int result; - unsigned short fs; - - fs = get_fs(); - set_fs(get_ds()); - - result = _recvfrom(sock, (void *)packet_buf, 2, 1, 0, - &sender); - - if ( (result != 2) - || (packet_buf[1] != '?') - /* How to check connection number here? */ - ) - { - printk("ncpfs: got strange packet on watchdog " - "socket\n"); - } - else - { - int result; - DDPRINTK("ncpfs: got watchdog from:\n"); - DDPRINTK("ncpfs: %08lX:%02X%02X%02X%02X%02X%02X:%04X," - " conn:%02X,type:%c\n", - htonl(sender.sipx_network), - sender.sipx_node[0], sender.sipx_node[1], - sender.sipx_node[2], sender.sipx_node[3], - sender.sipx_node[4], sender.sipx_node[5], - ntohs(sender.sipx_port), - packet_buf[0], packet_buf[1]); - - packet_buf[1] = 'Y'; - result = _sendto(sock, (void *)packet_buf, 2, 1, 0, - &sender); - DDPRINTK("send result: %d\n", result); - } - set_fs(fs); - } -} - -int -ncp_catch_watchdog(struct ncp_server *server) -{ - struct file *file; - struct inode *inode; - struct socket *sock; - struct sock *sk; - - if ( (server == NULL) - || ((file = server->wdog_filp) == NULL) - || ((inode = file->f_inode) == NULL) - || (!S_ISSOCK(inode->i_mode))) - { - printk("ncp_catch_watchdog: did not get valid server!\n"); - server->data_ready = NULL; - return -EINVAL; - } - - sock = &(inode->u.socket_i); - - if (sock->type != SOCK_DGRAM) - { - printk("ncp_catch_watchdog: did not get SOCK_DGRAM\n"); - server->data_ready = NULL; - return -EINVAL; - } - - sk = sock->sk; - - if (sk == NULL) - { - printk("ncp_catch_watchdog: sk == NULL"); - server->data_ready = NULL; - return -EINVAL; - } - - DDPRINTK("ncp_catch_watchdog: sk->d_r = %x, server->d_r = %x\n", - (unsigned int)(sk->data_ready), - (unsigned int)(server->data_ready)); - - if (sk->data_ready == ncp_wdog_data_ready) - { - printk("ncp_catch_watchdog: already done\n"); - return -EINVAL; - } - - server->data_ready = sk->data_ready; - sk->data_ready = ncp_wdog_data_ready; - sk->allocation = GFP_ATOMIC; - return 0; -} - -int -ncp_dont_catch_watchdog(struct ncp_server *server) -{ - struct file *file; - struct inode *inode; - struct socket *sock; - struct sock *sk; - - if ( (server == NULL) - || ((file = server->wdog_filp) == NULL) - || ((inode = file->f_inode) == NULL) - || (!S_ISSOCK(inode->i_mode))) - { - printk("ncp_dont_catch_watchdog: " - "did not get valid server!\n"); - return -EINVAL; - } - - sock = &(inode->u.socket_i); - - if (sock->type != SOCK_DGRAM) - { - printk("ncp_dont_catch_watchdog: did not get SOCK_DGRAM\n"); - return -EINVAL; - } - - sk = sock->sk; - - if (sk == NULL) - { - printk("ncp_dont_catch_watchdog: sk == NULL"); - return -EINVAL; - } - - if (server->data_ready == NULL) - { - printk("ncp_dont_catch_watchdog: " - "server->data_ready == NULL\n"); - return -EINVAL; - } - - if (sk->data_ready != ncp_wdog_data_ready) - { - printk("ncp_dont_catch_watchdog: " - "sk->data_callback != ncp_data_callback\n"); - return -EINVAL; - } - - DDPRINTK("ncp_dont_catch_watchdog: sk->d_r = %x, server->d_r = %x\n", - (unsigned int)(sk->data_ready), - (unsigned int)(server->data_ready)); - - sk->data_ready = server->data_ready; - sk->allocation = GFP_KERNEL; - server->data_ready = NULL; - return 0; -} - -static void -ncp_msg_data_ready(struct sock *sk, int len) -{ - struct socket *sock = sk->socket; - - if (!sk->dead) - { - unsigned char packet_buf[2]; - struct sockaddr_ipx sender; - int result; - unsigned short fs; - - fs = get_fs(); - set_fs(get_ds()); - - result = _recvfrom(sock, (void *)packet_buf, 2, 1, 0, - &sender); - - DPRINTK("ncpfs: got message of size %d from:\n", result); - DPRINTK("ncpfs: %08lX:%02X%02X%02X%02X%02X%02X:%04X," - " conn:%02X,type:%c\n", - htonl(sender.sipx_network), - sender.sipx_node[0], sender.sipx_node[1], - sender.sipx_node[2], sender.sipx_node[3], - sender.sipx_node[4], sender.sipx_node[5], - ntohs(sender.sipx_port), - packet_buf[0], packet_buf[1]); - - ncp_trigger_message(sk->protinfo.af_ipx.ncp_server); - - set_fs(fs); - } -} - -int -ncp_catch_message(struct ncp_server *server) -{ - struct file *file; - struct inode *inode; - struct socket *sock; - struct sock *sk; - - if ( (server == NULL) - || ((file = server->msg_filp) == NULL) - || ((inode = file->f_inode) == NULL) - || (!S_ISSOCK(inode->i_mode))) - { - printk("ncp_catch_message: did not get valid server!\n"); - return -EINVAL; - } - - sock = &(inode->u.socket_i); - - if (sock->type != SOCK_DGRAM) - { - printk("ncp_catch_message: did not get SOCK_DGRAM\n"); - return -EINVAL; - } - - sk = sock->sk; - - if (sk == NULL) - { - printk("ncp_catch_message: sk == NULL"); - return -EINVAL; - } - - DDPRINTK("ncp_catch_message: sk->d_r = %x\n", - (unsigned int)(sk->data_ready)); - - if (sk->data_ready == ncp_msg_data_ready) - { - printk("ncp_catch_message: already done\n"); - return -EINVAL; - } - - sk->data_ready = ncp_msg_data_ready; - sk->protinfo.af_ipx.ncp_server = server; - return 0; -} - #define NCP_SLACK_SPACE 1024 #define _S(nr) (1<<((nr)-1)) -static int -do_ncp_rpc_call(struct ncp_server *server, int size) +static int do_ncp_rpc_call(struct ncp_server *server, int size) { struct file *file; struct inode *inode; @@ -343,29 +87,24 @@ char *start = server->packet; poll_table wait_table; struct poll_table_entry entry; - int (*select) (struct inode *, poll_table *); int init_timeout, max_timeout; int timeout; int retrans; int major_timeout_seen; int acknowledge_seen; - char *server_name; int n; unsigned long old_mask; /* We have to check the result, so store the complete header */ struct ncp_request_header request = - *((struct ncp_request_header *)(server->packet)); - - struct ncp_reply_header reply; + *((struct ncp_request_header *) (server->packet)); + struct ncp_reply_header reply; file = server->ncp_filp; inode = file->f_inode; - select = file->f_op->poll; sock = &inode->u.socket_i; - if (!sock) - { + if (!sock) { printk("ncp_rpc_call: socki_lookup failed\n"); return -EBADF; } @@ -374,61 +113,53 @@ retrans = server->m.retry_count; major_timeout_seen = 0; acknowledge_seen = 0; - server_name = server->m.server_name; old_mask = current->blocked; current->blocked |= ~(_S(SIGKILL) #if 0 - | _S(SIGSTOP) + | _S(SIGSTOP) #endif - | ((server->m.flags & NCP_MOUNT_INTR) - ? ((current->sig->action[SIGINT - 1].sa_handler == SIG_DFL - ? _S(SIGINT) : 0) - | (current->sig->action[SIGQUIT - 1].sa_handler == SIG_DFL - ? _S(SIGQUIT) : 0)) - : 0)); + | ((server->m.flags & NCP_MOUNT_INTR) + ? ((current->sig->action[SIGINT - 1].sa_handler == SIG_DFL + ? _S(SIGINT) : 0) + | (current->sig->action[SIGQUIT - 1].sa_handler == SIG_DFL + ? _S(SIGQUIT) : 0)) + : 0)); fs = get_fs(); set_fs(get_ds()); - for (n = 0, timeout = init_timeout; ; n++, timeout <<= 1) - { + for (n = 0, timeout = init_timeout;; n++, timeout <<= 1) { DDPRINTK("ncpfs: %08lX:%02X%02X%02X%02X%02X%02X:%04X\n", - htonl(server->m.serv_addr.sipx_network), - server->m.serv_addr.sipx_node[0], - server->m.serv_addr.sipx_node[1], - server->m.serv_addr.sipx_node[2], - server->m.serv_addr.sipx_node[3], - server->m.serv_addr.sipx_node[4], - server->m.serv_addr.sipx_node[5], - ntohs(server->m.serv_addr.sipx_port)); + htonl(server->m.serv_addr.sipx_network), + server->m.serv_addr.sipx_node[0], + server->m.serv_addr.sipx_node[1], + server->m.serv_addr.sipx_node[2], + server->m.serv_addr.sipx_node[3], + server->m.serv_addr.sipx_node[4], + server->m.serv_addr.sipx_node[5], + ntohs(server->m.serv_addr.sipx_port)); DDPRINTK("ncpfs: req.typ: %04X, con: %d, " - "seq: %d", - request.type, - (request.conn_high << 8) + request.conn_low, - request.sequence); + "seq: %d", + request.type, + (request.conn_high << 8) + request.conn_low, + request.sequence); DDPRINTK(" func: %d\n", request.function); - result = _sendto(sock, (void *) start, size, 0, 0, - &(server->m.serv_addr)); - if (result < 0) - { + result = _send(sock, (void *) start, size); + if (result < 0) { printk("ncp_rpc_call: send error = %d\n", result); break; } - re_select: + re_select: wait_table.nr = 0; wait_table.entry = &entry; current->state = TASK_INTERRUPTIBLE; - if (!select(inode, &wait_table)) - { - if (timeout > max_timeout) - { + if (!(file->f_op->poll(file, &wait_table) & POLLIN)) { + if (timeout > max_timeout) { /* JEJB/JSP 2/7/94 * This is useful to see if the system is * hanging */ - if (acknowledge_seen == 0) - { - printk("NCP max timeout reached on " - "%s\n", server_name); + if (acknowledge_seen == 0) { + printk("NCP max timeout\n"); } timeout = max_timeout; } @@ -436,102 +167,87 @@ schedule(); remove_wait_queue(entry.wait_address, &entry.wait); current->state = TASK_RUNNING; - if (current->signal & ~current->blocked) - { + if (current->signal & ~current->blocked) { current->timeout = 0; result = -ERESTARTSYS; break; } - if (!current->timeout) - { + if (!current->timeout) { if (n < retrans) continue; - if (server->m.flags & NCP_MOUNT_SOFT) - { - printk("NCP server %s not responding, " - "timed out\n", server_name); + if (server->m.flags & NCP_MOUNT_SOFT) { + printk("NCP server not responding\n"); result = -EIO; break; } n = 0; timeout = init_timeout; init_timeout <<= 1; - if (!major_timeout_seen) - { - printk("NCP server %s not responding, " - "still trying\n", server_name); + if (!major_timeout_seen) { + printk("NCP server not responding\n"); } major_timeout_seen = 1; continue; - } - else + } else current->timeout = 0; - } - else if (wait_table.nr) + } else if (wait_table.nr) remove_wait_queue(entry.wait_address, &entry.wait); current->state = TASK_RUNNING; /* Get the header from the next packet using a peek, so keep it * on the recv queue. If it is wrong, it will be some reply * we don't now need, so discard it */ - result = _recvfrom(sock, (void *)&reply, - sizeof(reply), 1, MSG_PEEK, NULL); - if (result < 0) - { - if (result == -EAGAIN) - { + result = _recv(sock, (void *) &reply, sizeof(reply), + MSG_PEEK | MSG_DONTWAIT); + if (result < 0) { + if (result == -EAGAIN) { DPRINTK("ncp_rpc_call: bad select ready\n"); goto re_select; } - if (result == -ECONNREFUSED) - { + if (result == -ECONNREFUSED) { DPRINTK("ncp_rpc_call: server playing coy\n"); goto re_select; } - if (result != -ERESTARTSYS) - { + if (result != -ERESTARTSYS) { printk("ncp_rpc_call: recv error = %d\n", - -result); + -result); } break; } - if ( (result == sizeof(reply)) - && (reply.type == NCP_POSITIVE_ACK)) - { + if ((result == sizeof(reply)) + && (reply.type == NCP_POSITIVE_ACK)) { /* Throw away the packet */ DPRINTK("ncp_rpc_call: got positive acknowledge\n"); - _recvfrom(sock, (void *)&reply, sizeof(reply), 1, 0, - NULL); + _recv(sock, (void *) &reply, sizeof(reply), + MSG_DONTWAIT); n = 0; timeout = max_timeout; acknowledge_seen = 1; goto re_select; } - DDPRINTK("ncpfs: rep.typ: %04X, con: %d, tsk: %d," - "seq: %d\n", - reply.type, - (reply.conn_high << 8) + reply.conn_low, - reply.task, - reply.sequence); - - if ( (result >= sizeof(reply)) - && (reply.type == NCP_REPLY) - && ( (request.type == NCP_ALLOC_SLOT_REQUEST) - || ( (reply.sequence == request.sequence) - && (reply.conn_low == request.conn_low) -/* seem to get wrong task from NW311 && (reply.task == request.task)*/ - && (reply.conn_high == request.conn_high)))) - { + "seq: %d\n", + reply.type, + (reply.conn_high << 8) + reply.conn_low, + reply.task, + reply.sequence); + + if ((result >= sizeof(reply)) + && (reply.type == NCP_REPLY) + && ((request.type == NCP_ALLOC_SLOT_REQUEST) + || ((reply.sequence == request.sequence) + && (reply.conn_low == request.conn_low) +/* seem to get wrong task from NW311 && (reply.task == request.task) */ + && (reply.conn_high == request.conn_high)))) { if (major_timeout_seen) - printk("NCP server %s OK\n", server_name); + printk("NCP server OK\n"); break; } /* JEJB/JSP 2/7/94 * we have xid mismatch, so discard the packet and start * again. What a hack! but I can't call recvfrom with * a null buffer yet. */ - _recvfrom(sock, (void *)&reply, sizeof(reply), 1, 0, NULL); + _recv(sock, (void *) &reply, sizeof(reply), MSG_DONTWAIT); DPRINTK("ncp_rpc_call: reply mismatch\n"); goto re_select; @@ -540,54 +256,42 @@ * we have the correct reply, so read into the correct place and * return it */ - result = _recvfrom(sock, (void *)start, server->packet_size, - 1, 0, NULL); - if (result < 0) - { + result = _recv(sock, (void *) start, server->packet_size, MSG_DONTWAIT); + if (result < 0) { printk("NCP: notice message: result=%d\n", result); - } - else if (result < sizeof(struct ncp_reply_header)) - { + } else if (result < sizeof(struct ncp_reply_header)) { printk("NCP: just caught a too small read memory size..., " "email to NET channel\n"); printk("NCP: result=%d\n", result); result = -EIO; } - current->blocked = old_mask; set_fs(fs); return result; } - /* * We need the server to be locked here, so check! */ -static int -ncp_do_request(struct ncp_server *server, int size) +static int ncp_do_request(struct ncp_server *server, int size) { int result; - if (server->lock == 0) - { + if (server->lock == 0) { printk("ncpfs: Server not locked!\n"); return -EIO; } - - if (!ncp_conn_valid(server)) - { + if (!ncp_conn_valid(server)) { return -EIO; } - result = do_ncp_rpc_call(server, size); DDPRINTK("do_ncp_rpc_call returned %d\n", result); - if (result < 0) - { + if (result < 0) { /* There was a problem with I/O, so the connections is - * no longer usable. */ + * no longer usable. */ ncp_invalidate_conn(server); } return result; @@ -596,121 +300,105 @@ /* ncp_do_request assures that at least a complete reply header is * received. It assumes that server->current_size contains the ncp * request size */ -int -ncp_request(struct ncp_server *server, int function) +int ncp_request(struct ncp_server *server, int function) { struct ncp_request_header *h - = (struct ncp_request_header *)(server->packet); + = (struct ncp_request_header *) (server->packet); struct ncp_reply_header *reply - = (struct ncp_reply_header *)(server->packet); + = (struct ncp_reply_header *) (server->packet); int request_size = server->current_size - - sizeof(struct ncp_request_header); + - sizeof(struct ncp_request_header); int result; - if (server->has_subfunction != 0) - { - *(__u16 *)&(h->data[0]) = htons(request_size - 2); + if (server->has_subfunction != 0) { + *(__u16 *) & (h->data[0]) = htons(request_size - 2); } - h->type = NCP_REQUEST; - + server->sequence += 1; - h->sequence = server->sequence; - h->conn_low = (server->connection) & 0xff; + h->sequence = server->sequence; + h->conn_low = (server->connection) & 0xff; h->conn_high = ((server->connection) & 0xff00) >> 8; - h->task = (current->pid) & 0xff; - h->function = function; + h->task = (current->pid) & 0xff; + h->function = function; - if ((result = ncp_do_request(server, request_size + sizeof(*h))) < 0) - { + if ((result = ncp_do_request(server, request_size + sizeof(*h))) < 0) { DPRINTK("ncp_request_error: %d\n", result); return result; } - - server->completion = reply->completion_code; + server->completion = reply->completion_code; server->conn_status = reply->connection_state; - server->reply_size = result; + server->reply_size = result; server->ncp_reply_size = result - sizeof(struct ncp_reply_header); result = reply->completion_code; - if (result != 0) - { + if (result != 0) { DPRINTK("ncp_completion_code: %x\n", result); } - return result; + return result; } -int -ncp_connect(struct ncp_server *server) +int ncp_connect(struct ncp_server *server) { struct ncp_request_header *h - = (struct ncp_request_header *)(server->packet); + = (struct ncp_request_header *) (server->packet); int result; h->type = NCP_ALLOC_SLOT_REQUEST; - + server->sequence = 0; - h->sequence = server->sequence; - h->conn_low = 0xff; + h->sequence = server->sequence; + h->conn_low = 0xff; h->conn_high = 0xff; - h->task = (current->pid) & 0xff; - h->function = 0; + h->task = (current->pid) & 0xff; + h->function = 0; - if ((result = ncp_do_request(server, sizeof(*h))) < 0) - { + if ((result = ncp_do_request(server, sizeof(*h))) < 0) { return result; } - server->sequence = 0; server->connection = h->conn_low + (h->conn_high * 256); return 0; } - -int -ncp_disconnect(struct ncp_server *server) + +int ncp_disconnect(struct ncp_server *server) { struct ncp_request_header *h - = (struct ncp_request_header *)(server->packet); + = (struct ncp_request_header *) (server->packet); h->type = NCP_DEALLOC_SLOT_REQUEST; - + server->sequence += 1; - h->sequence = server->sequence; - h->conn_low = (server->connection) & 0xff; + h->sequence = server->sequence; + h->conn_low = (server->connection) & 0xff; h->conn_high = ((server->connection) & 0xff00) >> 8; - h->task = (current->pid) & 0xff; - h->function = 0; + h->task = (current->pid) & 0xff; + h->function = 0; return ncp_do_request(server, sizeof(*h)); } -void -ncp_lock_server(struct ncp_server *server) +void ncp_lock_server(struct ncp_server *server) { #if 0 /* For testing, only 1 process */ - if (server->lock != 0) - { + if (server->lock != 0) { DPRINTK("ncpfs: server locked!!!\n"); } #endif - while (server->lock) + while (server->lock) sleep_on(&server->wait); server->lock = 1; } -void -ncp_unlock_server(struct ncp_server *server) +void ncp_unlock_server(struct ncp_server *server) { - if (server->lock != 1) - { - printk("ncp_unlock_server: was not locked!\n"); - } - - server->lock = 0; - wake_up(&server->wait); + if (server->lock != 1) { + printk("ncp_unlock_server: was not locked!\n"); + } + server->lock = 0; + wake_up(&server->wait); } - diff -urN 2.1.29/include/linux/ipx.h 2.1.29-patched/include/linux/ipx.h --- 2.1.29/include/linux/ipx.h Thu Dec 12 16:14:38 1996 +++ 2.1.29-patched/include/linux/ipx.h Sun Mar 23 11:28:24 1997 @@ -1,6 +1,7 @@ #ifndef _IPX_H_ #define _IPX_H_ #include +#include #define IPX_NODE_LEN 6 #define IPX_MTU 576 diff -urN 2.1.29/include/linux/ncp.h 2.1.29-patched/include/linux/ncp.h --- 2.1.29/include/linux/ncp.h Thu Feb 6 11:58:49 1997 +++ 2.1.29-patched/include/linux/ncp.h Sun Mar 23 13:02:34 1997 @@ -20,78 +20,42 @@ #define NCP_DEALLOC_SLOT_REQUEST (0x5555) struct ncp_request_header { - __u16 type __attribute__ ((packed)); - __u8 sequence __attribute__ ((packed)); - __u8 conn_low __attribute__ ((packed)); - __u8 task __attribute__ ((packed)); - __u8 conn_high __attribute__ ((packed)); - __u8 function __attribute__ ((packed)); - __u8 data[0] __attribute__ ((packed)); + __u16 type __attribute__((packed)); + __u8 sequence __attribute__((packed)); + __u8 conn_low __attribute__((packed)); + __u8 task __attribute__((packed)); + __u8 conn_high __attribute__((packed)); + __u8 function __attribute__((packed)); + __u8 data[0] __attribute__((packed)); }; #define NCP_REPLY (0x3333) #define NCP_POSITIVE_ACK (0x9999) struct ncp_reply_header { - __u16 type __attribute__ ((packed)); - __u8 sequence __attribute__ ((packed)); - __u8 conn_low __attribute__ ((packed)); - __u8 task __attribute__ ((packed)); - __u8 conn_high __attribute__ ((packed)); - __u8 completion_code __attribute__ ((packed)); - __u8 connection_state __attribute__ ((packed)); - __u8 data[0] __attribute__ ((packed)); -}; - - -#define NCP_BINDERY_USER (0x0001) -#define NCP_BINDERY_UGROUP (0x0002) -#define NCP_BINDERY_PQUEUE (0x0003) -#define NCP_BINDERY_FSERVER (0x0004) -#define NCP_BINDERY_NAME_LEN (48) -struct ncp_bindery_object { - __u32 object_id; - __u16 object_type; - __u8 object_name[NCP_BINDERY_NAME_LEN]; - __u8 object_flags; - __u8 object_security; - __u8 object_has_prop; -}; - -struct nw_property { - __u8 value[128]; - __u8 more_flag; - __u8 property_flag; -}; - -struct prop_net_address { - __u32 network __attribute__ ((packed)); - __u8 node[IPX_NODE_LEN] __attribute__ ((packed)); - __u16 port __attribute__ ((packed)); + __u16 type __attribute__((packed)); + __u8 sequence __attribute__((packed)); + __u8 conn_low __attribute__((packed)); + __u8 task __attribute__((packed)); + __u8 conn_high __attribute__((packed)); + __u8 completion_code __attribute__((packed)); + __u8 connection_state __attribute__((packed)); + __u8 data[0] __attribute__((packed)); }; #define NCP_VOLNAME_LEN (16) #define NCP_NUMBER_OF_VOLUMES (64) struct ncp_volume_info { - __u32 total_blocks; - __u32 free_blocks; - __u32 purgeable_blocks; - __u32 not_yet_purgeable_blocks; - __u32 total_dir_entries; - __u32 available_dir_entries; - __u8 sectors_per_block; - char volume_name[NCP_VOLNAME_LEN+1]; -}; - -struct ncp_filesearch_info { - __u8 volume_number; - __u16 directory_id; - __u16 sequence_no; - __u8 access_rights; + __u32 total_blocks; + __u32 free_blocks; + __u32 purgeable_blocks; + __u32 not_yet_purgeable_blocks; + __u32 total_dir_entries; + __u32 available_dir_entries; + __u8 sectors_per_block; + char volume_name[NCP_VOLNAME_LEN + 1]; }; -#define NCP_MAX_FILENAME 14 - /* these define the attribute byte as seen by NCP */ #define aRONLY (ntohl(0x01000000)) #define aHIDDEN (ntohl(0x02000000)) @@ -105,17 +69,6 @@ #define AR_EXCLUSIVE (ntohs(0x2000)) #define NCP_FILE_ID_LEN 6 -struct ncp_file_info { - __u8 file_id[NCP_FILE_ID_LEN]; - char file_name[NCP_MAX_FILENAME+1]; - __u8 file_attributes; - __u8 file_mode; - __u32 file_length; - __u16 creation_date; - __u16 access_date; - __u16 update_date; - __u16 update_time; -}; /* Defines for Name Spaces */ #define NW_NS_DOS 0 @@ -164,34 +117,33 @@ #define AR_OPEN_COMPRESSED 0x0100 #endif -struct nw_info_struct -{ - __u32 spaceAlloc __attribute__ ((packed)); - __u32 attributes __attribute__ ((packed)); - __u16 flags __attribute__ ((packed)); - __u32 dataStreamSize __attribute__ ((packed)); - __u32 totalStreamSize __attribute__ ((packed)); - __u16 numberOfStreams __attribute__ ((packed)); - __u16 creationTime __attribute__ ((packed)); - __u16 creationDate __attribute__ ((packed)); - __u32 creatorID __attribute__ ((packed)); - __u16 modifyTime __attribute__ ((packed)); - __u16 modifyDate __attribute__ ((packed)); - __u32 modifierID __attribute__ ((packed)); - __u16 lastAccessDate __attribute__ ((packed)); - __u16 archiveTime __attribute__ ((packed)); - __u16 archiveDate __attribute__ ((packed)); - __u32 archiverID __attribute__ ((packed)); - __u16 inheritedRightsMask __attribute__ ((packed)); - __u32 dirEntNum __attribute__ ((packed)); - __u32 DosDirNum __attribute__ ((packed)); - __u32 volNumber __attribute__ ((packed)); - __u32 EADataSize __attribute__ ((packed)); - __u32 EAKeyCount __attribute__ ((packed)); - __u32 EAKeySize __attribute__ ((packed)); - __u32 NSCreator __attribute__ ((packed)); - __u8 nameLen __attribute__ ((packed)); - __u8 entryName[256] __attribute__ ((packed)); +struct nw_info_struct { + __u32 spaceAlloc __attribute__((packed)); + __u32 attributes __attribute__((packed)); + __u16 flags __attribute__((packed)); + __u32 dataStreamSize __attribute__((packed)); + __u32 totalStreamSize __attribute__((packed)); + __u16 numberOfStreams __attribute__((packed)); + __u16 creationTime __attribute__((packed)); + __u16 creationDate __attribute__((packed)); + __u32 creatorID __attribute__((packed)); + __u16 modifyTime __attribute__((packed)); + __u16 modifyDate __attribute__((packed)); + __u32 modifierID __attribute__((packed)); + __u16 lastAccessDate __attribute__((packed)); + __u16 archiveTime __attribute__((packed)); + __u16 archiveDate __attribute__((packed)); + __u32 archiverID __attribute__((packed)); + __u16 inheritedRightsMask __attribute__((packed)); + __u32 dirEntNum __attribute__((packed)); + __u32 DosDirNum __attribute__((packed)); + __u32 volNumber __attribute__((packed)); + __u32 EADataSize __attribute__((packed)); + __u32 EAKeyCount __attribute__((packed)); + __u32 EAKeySize __attribute__((packed)); + __u32 NSCreator __attribute__((packed)); + __u8 nameLen __attribute__((packed)); + __u8 entryName[256] __attribute__((packed)); }; /* modify mask - use with MODIFY_DOS_INFO structure */ @@ -209,97 +161,36 @@ #define DM_INHERITED_RIGHTS_MASK (ntohl(0x00100000L)) #define DM_MAXIMUM_SPACE (ntohl(0x00200000L)) -struct nw_modify_dos_info -{ - __u32 attributes __attribute__ ((packed)); - __u16 creationDate __attribute__ ((packed)); - __u16 creationTime __attribute__ ((packed)); - __u32 creatorID __attribute__ ((packed)); - __u16 modifyDate __attribute__ ((packed)); - __u16 modifyTime __attribute__ ((packed)); - __u32 modifierID __attribute__ ((packed)); - __u16 archiveDate __attribute__ ((packed)); - __u16 archiveTime __attribute__ ((packed)); - __u32 archiverID __attribute__ ((packed)); - __u16 lastAccessDate __attribute__ ((packed)); - __u16 inheritanceGrantMask __attribute__ ((packed)); - __u16 inheritanceRevokeMask __attribute__ ((packed)); - __u32 maximumSpace __attribute__ ((packed)); +struct nw_modify_dos_info { + __u32 attributes __attribute__((packed)); + __u16 creationDate __attribute__((packed)); + __u16 creationTime __attribute__((packed)); + __u32 creatorID __attribute__((packed)); + __u16 modifyDate __attribute__((packed)); + __u16 modifyTime __attribute__((packed)); + __u32 modifierID __attribute__((packed)); + __u16 archiveDate __attribute__((packed)); + __u16 archiveTime __attribute__((packed)); + __u32 archiverID __attribute__((packed)); + __u16 lastAccessDate __attribute__((packed)); + __u16 inheritanceGrantMask __attribute__((packed)); + __u16 inheritanceRevokeMask __attribute__((packed)); + __u32 maximumSpace __attribute__((packed)); }; struct nw_file_info { struct nw_info_struct i; - int opened; - int access; - __u32 server_file_handle __attribute__ ((packed)); - __u8 open_create_action __attribute__ ((packed)); - __u8 file_handle[6] __attribute__ ((packed)); + int opened; + int access; + __u32 server_file_handle __attribute__((packed)); + __u8 open_create_action __attribute__((packed)); + __u8 file_handle[6] __attribute__((packed)); }; struct nw_search_sequence { - __u8 volNumber __attribute__ ((packed)); - __u32 dirBase __attribute__ ((packed)); - __u32 sequence __attribute__ ((packed)); + __u8 volNumber __attribute__((packed)); + __u32 dirBase __attribute__((packed)); + __u32 sequence __attribute__((packed)); }; -struct nw_queue_job_entry { - __u16 InUse __attribute__ ((packed)); - __u32 prev __attribute__ ((packed)); - __u32 next __attribute__ ((packed)); - __u32 ClientStation __attribute__ ((packed)); - __u32 ClientTask __attribute__ ((packed)); - __u32 ClientObjectID __attribute__ ((packed)); - __u32 TargetServerID __attribute__ ((packed)); - __u8 TargetExecTime[6] __attribute__ ((packed)); - __u8 JobEntryTime[6] __attribute__ ((packed)); - __u32 JobNumber __attribute__ ((packed)); - __u16 JobType __attribute__ ((packed)); - __u16 JobPosition __attribute__ ((packed)); - __u16 JobControlFlags __attribute__ ((packed)); - __u8 FileNameLen __attribute__ ((packed)); - char JobFileName[13] __attribute__ ((packed)); - __u32 JobFileHandle __attribute__ ((packed)); - __u32 ServerStation __attribute__ ((packed)); - __u32 ServerTaskNumber __attribute__ ((packed)); - __u32 ServerObjectID __attribute__ ((packed)); - char JobTextDescription[50] __attribute__ ((packed)); - char ClientRecordArea[152] __attribute__ ((packed)); -}; - -struct queue_job { - struct nw_queue_job_entry j; - __u8 file_handle[6]; -}; - -#define QJE_OPER_HOLD 0x80 -#define QJE_USER_HOLD 0x40 -#define QJE_ENTRYOPEN 0x20 -#define QJE_SERV_RESTART 0x10 -#define QJE_SERV_AUTO 0x08 - -/* ClientRecordArea for print jobs */ - -#define KEEP_ON 0x0400 -#define NO_FORM_FEED 0x0800 -#define NOTIFICATION 0x1000 -#define DELETE_FILE 0x2000 -#define EXPAND_TABS 0x4000 -#define PRINT_BANNER 0x8000 - -struct print_job_record { - __u8 Version __attribute__ ((packed)); - __u8 TabSize __attribute__ ((packed)); - __u16 Copies __attribute__ ((packed)); - __u16 CtrlFlags __attribute__ ((packed)); - __u16 Lines __attribute__ ((packed)); - __u16 Rows __attribute__ ((packed)); - char FormName[16] __attribute__ ((packed)); - __u8 Reserved[6] __attribute__ ((packed)); - char BannerName[13] __attribute__ ((packed)); - char FnameBanner[13] __attribute__ ((packed)); - char FnameHeader[14] __attribute__ ((packed)); - char Path[80] __attribute__ ((packed)); -}; - - -#endif /* _LINUX_NCP_H */ +#endif /* _LINUX_NCP_H */ diff -urN 2.1.29/include/linux/ncp_fs.h 2.1.29-patched/include/linux/ncp_fs.h --- 2.1.29/include/linux/ncp_fs.h Thu Feb 6 11:58:49 1997 +++ 2.1.29-patched/include/linux/ncp_fs.h Sun Mar 23 13:02:43 1997 @@ -21,22 +21,22 @@ */ struct ncp_ioctl_request { - unsigned int function; - unsigned int size; - char *data; + unsigned int function; + unsigned int size; + char *data; }; struct ncp_fs_info { - int version; + int version; struct sockaddr_ipx addr; - uid_t mounted_uid; - int connection; /* Connection number the server assigned us */ - int buffer_size; /* The negotiated buffer size, to be + uid_t mounted_uid; + int connection; /* Connection number the server assigned us */ + int buffer_size; /* The negotiated buffer size, to be used for read/write requests! */ - int volume_number; - __u32 directory_id; -}; + int volume_number; + __u32 directory_id; +}; #define NCP_IOC_NCPREQUEST _IOR('n', 1, struct ncp_ioctl_request) #define NCP_IOC_GETMOUNTUID _IOW('n', 2, uid_t) @@ -53,8 +53,6 @@ #define NCP_MAXPATHLEN 255 #define NCP_MAXNAMELEN 14 -#define NCP_MSG_COMMAND "/sbin/nwmsg" - #ifdef __KERNEL__ /* The readdir cache size controls how many directory entries are @@ -62,7 +60,6 @@ */ #define NCP_READDIR_CACHE_SIZE 64 - #define NCP_MAX_RPC_TIMEOUT (6*HZ) /* Guess, what 0x564c is :-) */ @@ -84,26 +81,25 @@ extern int ncp_current_malloced; static inline void * -ncp_kmalloc(unsigned int size, int priority) + ncp_kmalloc(unsigned int size, int priority) { - ncp_malloced += 1; - ncp_current_malloced += 1; - return kmalloc(size, priority); + ncp_malloced += 1; + ncp_current_malloced += 1; + return kmalloc(size, priority); } -static inline void -ncp_kfree_s(void *obj, int size) +static inline void ncp_kfree_s(void *obj, int size) { - ncp_current_malloced -= 1; - kfree_s(obj, size); + ncp_current_malloced -= 1; + kfree_s(obj, size); } -#else /* DEBUG_NCP_MALLOC */ +#else /* DEBUG_NCP_MALLOC */ #define ncp_kmalloc(s,p) kmalloc(s,p) #define ncp_kfree_s(o,s) kfree_s(o,s) -#endif /* DEBUG_NCP_MALLOC */ +#endif /* DEBUG_NCP_MALLOC */ #if DEBUG_NCP > 0 #define DPRINTK(format, args...) printk(format , ## args) @@ -127,39 +123,35 @@ void ncp_free_inode_info(struct ncp_inode_info *i); void ncp_free_all_inodes(struct ncp_server *server); void ncp_init_root(struct ncp_server *server); -int ncp_conn_logged_in(struct ncp_server *server); +int ncp_conn_logged_in(struct ncp_server *server); void ncp_init_dir_cache(void); void ncp_invalid_dir_cache(struct inode *ino); struct ncp_inode_info *ncp_find_inode(struct inode *inode); ino_t ncp_info_ino(struct ncp_server *server, struct ncp_inode_info *info); void ncp_free_dir_cache(void); -int ncp_date_dos2unix(__u16 time, __u16 date); -void ncp_date_unix2dos(int unix_date, __u16 *time, __u16 *date); +int ncp_date_dos2unix(__u16 time, __u16 date); +void ncp_date_unix2dos(int unix_date, __u16 * time, __u16 * date); /* linux/fs/ncpfs/ioctl.c */ -int ncp_ioctl (struct inode * inode, struct file * filp, - unsigned int cmd, unsigned long arg); +int ncp_ioctl(struct inode *inode, struct file *filp, + unsigned int cmd, unsigned long arg); /* linux/fs/ncpfs/inode.c */ struct super_block *ncp_read_super(struct super_block *sb, - void *raw_data, int silent); + void *raw_data, int silent); extern int init_ncp_fs(void); -void ncp_trigger_message(struct ncp_server *server); /* linux/fs/ncpfs/sock.c */ int ncp_request(struct ncp_server *server, int function); int ncp_connect(struct ncp_server *server); int ncp_disconnect(struct ncp_server *server); -int ncp_catch_watchdog(struct ncp_server *server); -int ncp_dont_catch_watchdog(struct ncp_server *server); -int ncp_catch_message(struct ncp_server *server); void ncp_lock_server(struct ncp_server *server); void ncp_unlock_server(struct ncp_server *server); /* linux/fs/ncpfs/mmap.c */ -int ncp_mmap(struct inode * inode, struct file * file, struct vm_area_struct * vma); +int ncp_mmap(struct inode *inode, struct file *file, struct vm_area_struct *vma); -#endif /* __KERNEL__ */ +#endif /* __KERNEL__ */ -#endif /* _LINUX_NCP_FS_H */ +#endif /* _LINUX_NCP_FS_H */ diff -urN 2.1.29/include/linux/ncp_fs_i.h 2.1.29-patched/include/linux/ncp_fs_i.h --- 2.1.29/include/linux/ncp_fs_i.h Thu Feb 6 11:58:49 1997 +++ 2.1.29-patched/include/linux/ncp_fs_i.h Sun Mar 23 13:02:43 1997 @@ -13,21 +13,21 @@ #ifdef __KERNEL__ enum ncp_inode_state { - NCP_INODE_VALID = 19, /* Inode currently in use */ - NCP_INODE_LOOKED_UP, /* directly before iget */ - NCP_INODE_CACHED, /* in a path to an inode which is in use */ - NCP_INODE_INVALID + NCP_INODE_VALID = 19, /* Inode currently in use */ + NCP_INODE_LOOKED_UP, /* directly before iget */ + NCP_INODE_CACHED, /* in a path to an inode which is in use */ + NCP_INODE_INVALID }; /* * ncp fs inode data (in memory only) */ struct ncp_inode_info { - enum ncp_inode_state state; - int nused; /* for directories: - number of references in memory */ - struct ncp_inode_info *dir; - struct ncp_inode_info *next, *prev; + enum ncp_inode_state state; + int nused; /* for directories: + number of references in memory */ + struct ncp_inode_info *dir; + struct ncp_inode_info *next, *prev; struct inode *inode; struct nw_file_info finfo; }; diff -urN 2.1.29/include/linux/ncp_fs_sb.h 2.1.29-patched/include/linux/ncp_fs_sb.h --- 2.1.29/include/linux/ncp_fs_sb.h Thu Feb 6 11:58:49 1997 +++ 2.1.29-patched/include/linux/ncp_fs_sb.h Sun Mar 23 13:02:43 1997 @@ -17,60 +17,52 @@ struct ncp_server { - struct ncp_mount_data m; /* Nearly all of the mount data is of - interest for us later, so we store - it completely. */ + struct ncp_mount_data m; /* Nearly all of the mount data is of + interest for us later, so we store + it completely. */ __u8 name_space[NCP_NUMBER_OF_VOLUMES]; struct file *ncp_filp; /* File pointer to ncp socket */ - struct file *wdog_filp; /* File pointer to wdog socket */ - struct file *msg_filp; /* File pointer to message socket */ - void *data_ready; /* The wdog socket gets a new - data_ready callback. We store the - old one for checking purposes and - to reset it on unmounting. */ - - u8 sequence; - u8 task; - u16 connection; /* Remote connection number */ - u8 completion; /* Status message from server */ - u8 conn_status; /* Bit 4 = 1 ==> Server going down, no + u8 sequence; + u8 task; + u16 connection; /* Remote connection number */ + + u8 completion; /* Status message from server */ + u8 conn_status; /* Bit 4 = 1 ==> Server going down, no requests allowed anymore. Bit 0 = 1 ==> Server is down. */ - int buffer_size; /* Negotiated bufsize */ + int buffer_size; /* Negotiated bufsize */ - int reply_size; /* Size of last reply */ + int reply_size; /* Size of last reply */ - int packet_size; + int packet_size; unsigned char *packet; /* Here we prepare requests and receive replies */ - int lock; /* To prevent mismatch in protocols. */ + int lock; /* To prevent mismatch in protocols. */ struct wait_queue *wait; - int current_size; /* for packet preparation */ - int has_subfunction; - int ncp_reply_size; + int current_size; /* for packet preparation */ + int has_subfunction; + int ncp_reply_size; - struct ncp_inode_info root; - char root_path; /* '\0' */ + struct ncp_inode_info root; + char root_path; /* '\0' */ }; -static inline int -ncp_conn_valid(struct ncp_server *server) +static inline int ncp_conn_valid(struct ncp_server *server) { return ((server->conn_status & 0x11) == 0); } -static inline void -ncp_invalidate_conn(struct ncp_server *server) +static inline void ncp_invalidate_conn(struct ncp_server *server) { server->conn_status |= 0x01; } -#endif /* __KERNEL__ */ +#endif /* __KERNEL__ */ #endif diff -urN 2.1.29/include/linux/ncp_mount.h 2.1.29-patched/include/linux/ncp_mount.h --- 2.1.29/include/linux/ncp_mount.h Thu Feb 6 11:58:49 1997 +++ 2.1.29-patched/include/linux/ncp_mount.h Sun Mar 23 13:02:43 1997 @@ -13,40 +13,28 @@ #include #include -#define NCP_MOUNT_VERSION 2 - -#define NCP_USERNAME_LEN (NCP_BINDERY_NAME_LEN) -#define NCP_PASSWORD_LEN 20 +#define NCP_MOUNT_VERSION 3 /* Values for flags */ #define NCP_MOUNT_SOFT 0x0001 #define NCP_MOUNT_INTR 0x0002 -/* Gosh... */ -#define NCP_PATH_MAX 1024 - struct ncp_mount_data { int version; unsigned int ncp_fd; /* The socket to the ncp port */ - unsigned int wdog_fd; /* Watchdog packets come here */ - unsigned int message_fd; /* Message notifications come here */ - uid_t mounted_uid; /* Who may umount() this filesystem? */ - - struct sockaddr_ipx serv_addr; - unsigned char server_name[NCP_BINDERY_NAME_LEN]; - - unsigned char mount_point[NCP_PATH_MAX+1]; - unsigned char mounted_vol[NCP_VOLNAME_LEN+1]; + uid_t mounted_uid; /* Who may umount() this filesystem? */ + pid_t wdog_pid; /* Who cares for our watchdog packets? */ + unsigned char mounted_vol[NCP_VOLNAME_LEN + 1]; unsigned int time_out; /* How long should I wait after sending a NCP request? */ - unsigned int retry_count; /* And how often should I retry? */ + unsigned int retry_count; /* And how often should I retry? */ unsigned int flags; - uid_t uid; - gid_t gid; - mode_t file_mode; - mode_t dir_mode; + uid_t uid; + gid_t gid; + mode_t file_mode; + mode_t dir_mode; }; #endif