mars_nwe/ncpfs
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 2 Wiki Activity

Import ncpfs 0.10

Browse Source
This commit is contained in:
ncpfs archive import
2026-04-28 20:39:57 +02:00
parent 5d4b23a5c1
commit 517e207709
45 changed files with 3393 additions and 6000 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
kernel-1.2/src/Makefile
View File

@@ -2,8 +2,6 @@
# Makefile for the linux ncp-filesystem routines.
#
INCLUDES = -I/usr/src/linux/include -I..
CFLAGS = -Wall -Wstrict-prototypes -O2 -DMODULE -fomit-frame-pointer \
$(INCLUDES) \
# -DDEBUG_NCP=1 -DDEBUG_NCP_MALLOC
@@ -20,12 +18,12 @@ ARCH = i386
.s.o:
$(AS) -o $*.o $<
OBJS= dir.o inode.o file.o sock.o ioctl.o ncplib_kernel.o
OBJS= dir.o inode.o file.o sock.o ioctl.o ncplib_kernel.o mmap.o
all: ncpfs.o
all: $(BINDIR)/ncpfs.o
ncpfs.o: $(OBJS)
$(LD) -r -o ncpfs.o $(OBJS)
$(BINDIR)/ncpfs.o: $(OBJS)
$(LD) -r -o $@ $(OBJS)
ncplib_kernel.o: ncplib_kernel.c ncplib_kernel.h
$(CC) $(CFLAGS) -finline-functions -c $<

302
kernel-1.2/src/dir.c
View File

@@ -9,9 +9,6 @@
#ifdef MODULE
#include <linux/module.h>
#include <linux/version.h>
#else
#define MOD_INC_USE_COUNT
#define MOD_DEC_USE_COUNT
#endif
#include <linux/sched.h>
@@ -76,9 +73,12 @@ ncp_rename(struct inode *old_dir, const char *old_name, int old_len,
static inline void
str_upper(char *name)
{
while (*name) {
while (*name)
{
if (*name >= 'a' && *name <= 'z')
{
*name -= ('a' - 'A');
}
name++;
}
}
@@ -86,9 +86,12 @@ str_upper(char *name)
static inline void
str_lower(char *name)
{
while (*name) {
while (*name)
{
if (*name >= 'A' && *name <= 'Z')
{
*name += ('a' - 'A');
}
name ++;
}
}
@@ -100,7 +103,7 @@ static struct file_operations ncp_dir_operations = {
ncp_readdir, /* readdir */
NULL, /* select - default */
ncp_ioctl, /* ioctl - default */
NULL, /* mmap */
NULL, /* mmap */
NULL, /* no special open code */
NULL, /* no special release code */
NULL /* fsync */
@@ -166,13 +169,13 @@ ncp_readdir(struct inode *inode, struct file *filp,
put_fs_word(f_pos, &dirent->d_off);
return 1;
}
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;
}
@@ -181,34 +184,40 @@ ncp_readdir(struct inode *inode, struct file *filp,
{
i = sizeof (struct ncp_dirent) * NCP_READDIR_CACHE_SIZE;
c_entry = (struct ncp_dirent *) ncp_kmalloc(i, GFP_KERNEL);
if (c_entry == NULL) {
if (c_entry == NULL)
{
printk("ncp_readdir: no MEMORY for cache\n");
return -ENOMEM;
}
}
if (filp->f_pos == 0) {
if (filp->f_pos == 0)
{
ncp_invalid_dir_cache(inode->i_ino);
if (filldir(dirent,".",1, filp->f_pos, (int)dir) < 0) {
if (filldir(dirent,".",1, filp->f_pos, (int)dir) < 0)
{
return 0;
}
filp->f_pos += 1;
return ROUND_UP(NAME_OFFSET(dirent)+i+1);
}
if (filp->f_pos == 1) {
if (filldir(dirent,"..",2, filp->f_pos, (int)(dir->dir)) < 0) {
if (filp->f_pos == 1)
{
if (filldir(dirent,"..",2, filp->f_pos, (int)(dir->dir)) < 0)
{
return 0;
}
filp->f_pos += 1;
return ROUND_UP(NAME_OFFSET(dirent)+i+1);
}
if (inode->i_ino == c_ino) {
for (i = 0; i < c_size; i++) {
if (filp->f_pos == c_entry[i].f_pos) {
if (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;
@@ -216,33 +225,38 @@ ncp_readdir(struct inode *inode, struct file *filp,
}
}
if ((entry == NULL) && c_seen_eof)
{
return 0;
}
}
if (entry == NULL) {
if (entry == NULL)
{
DDPRINTK("ncp_readdir: Not found in cache.\n");
if (inode->i_ino == (int)&(server->root)) {
if (inode->i_ino == (int)&(server->root))
{
result = ncp_read_volume_list(server, filp->f_pos,
NCP_READDIR_CACHE_SIZE);
DPRINTK("ncp_read_volume_list returned %d\n", result);
} else {
}
else
{
result = ncp_do_readdir(server, inode, filp->f_pos,
NCP_READDIR_CACHE_SIZE,
c_entry);
DPRINTK("ncp_readdir returned %d\n", result);
}
if (result < 0) {
if (result < 0)
{
c_ino = 0;
return result;
}
if (result > 0) {
if (result > 0)
{
c_seen_eof = (result < NCP_READDIR_CACHE_SIZE);
c_ino = inode->i_ino;
c_size = result;
@@ -250,19 +264,21 @@ ncp_readdir(struct inode *inode, struct file *filp,
c_last_returned_index = 0;
index = 0;
for (i = 0; i < c_size; i++) {
for (i = 0; i < c_size; i++)
{
str_lower(c_entry[i].i.entryName);
}
}
}
if (entry == NULL) {
if (entry == NULL)
{
/* Nothing found, even from a ncp call */
return 0;
}
if (index < c_size) {
if (index < c_size)
{
/* We found it. 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
@@ -270,12 +286,12 @@ ncp_readdir(struct inode *inode, struct file *filp,
struct ncp_inode_info *ino_info;
ino_info = ncp_find_inode(inode, entry->i.entryName);
/* 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;
}
@@ -283,7 +299,8 @@ ncp_readdir(struct inode *inode, struct file *filp,
DDPRINTK("ncp_readdir: entry->f_pos = %ld\n", entry->f_pos);
if (filldir(dirent, entry->i.entryName, entry->i.nameLen,
entry->f_pos, (ino_t)ino_info) < 0) {
entry->f_pos, (ino_t)ino_info) < 0)
{
return 0;
}
@@ -304,33 +321,42 @@ ncp_read_volume_list(struct ncp_server *server, int fpos, int cache_size)
int i;
#if 1
if (fpos < 2) {
if (fpos < 2)
{
printk("OOPS, we expect fpos >= 2");
fpos = 2;
}
#endif
for (i=0; i<NCP_NUMBER_OF_VOLUMES; i++) {
for (i=0; i<NCP_NUMBER_OF_VOLUMES; i++)
{
struct ncp_volume_info info;
if (ncp_get_volume_info_with_number(server, i, &info) != 0) {
if (ncp_get_volume_info_with_number(server, i, &info) != 0)
{
return total_count;
}
if (strlen(info.volume_name) > 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_do_lookup(server, NULL,
info.volume_name,
&(entry->i)) != 0) {
&(entry->i)) != 0)
{
printk("ncpfs: could not lookup vol "
"%s\n", info.volume_name);
continue;
@@ -342,7 +368,6 @@ ncp_read_volume_list(struct ncp_server *server, int fpos, int cache_size)
total_count += 1;
}
}
return (total_count - fpos);
}
@@ -355,43 +380,50 @@ ncp_do_readdir(struct ncp_server *server, struct inode *dir, int fpos,
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;
@@ -400,7 +432,6 @@ ncp_do_readdir(struct ncp_server *server, struct inode *dir, int fpos,
}
total_count += 1;
}
return (total_count - fpos);
}
@@ -414,7 +445,8 @@ ncp_init_dir_cache(void)
void
ncp_invalid_dir_cache(unsigned long ino)
{
if (ino == c_ino) {
if (ino == c_ino)
{
c_ino = 0;
c_seen_eof = 0;
}
@@ -426,7 +458,9 @@ ncp_free_dir_cache(void)
DPRINTK("ncp_free_dir_cache: enter\n");
if (c_entry == NULL)
{
return;
}
ncp_kfree_s(c_entry,
sizeof(struct ncp_dirent) * NCP_READDIR_CACHE_SIZE);
@@ -443,12 +477,14 @@ ncp_iget(struct inode *dir, struct nw_file_info *finfo)
struct ncp_inode_info *new_inode_info;
struct ncp_inode_info *root;
if (!dir) {
if (dir == NULL)
{
printk("ncp_iget: dir is NULL\n");
return NULL;
}
if (!finfo) {
if (finfo == NULL)
{
printk("ncp_iget: finfo is NULL\n");
return NULL;
}
@@ -456,13 +492,14 @@ ncp_iget(struct inode *dir, struct nw_file_info *finfo)
new_inode_info = ncp_kmalloc(sizeof(struct ncp_inode_info),
GFP_KERNEL);
if (new_inode_info == NULL) {
if (new_inode_info == NULL)
{
printk("ncp_iget: could not alloc mem for %s\n",
finfo->i.entryName);
return NULL;
}
new_inode_info->state = INODE_LOOKED_UP;
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;
@@ -480,7 +517,8 @@ ncp_iget(struct inode *dir, struct nw_file_info *finfo)
root->next->prev = new_inode_info;
root->next = new_inode_info;
if (!(inode = iget(dir->i_sb, (int)new_inode_info))) {
if (!(inode = iget(dir->i_sb, (int)new_inode_info)))
{
printk("ncp_iget: iget failed!");
return NULL;
}
@@ -491,13 +529,15 @@ ncp_iget(struct inode *dir, struct nw_file_info *finfo)
void
ncp_free_inode_info(struct ncp_inode_info *i)
{
if (i == NULL) {
if (i == NULL)
{
printk("ncp_free_inode: i == NULL\n");
return;
}
i->state = INODE_CACHED;
while ((i->nused == 0) && (i->state == INODE_CACHED)) {
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;
@@ -522,7 +562,6 @@ ncp_init_root(struct ncp_server *server)
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);
root->finfo.opened = 0;
@@ -534,7 +573,7 @@ ncp_init_root(struct ncp_server *server)
i->nameLen = 0;
i->entryName[0] = '\0';
root->state = INODE_LOOKED_UP;
root->state = NCP_INODE_LOOKED_UP;
root->nused = 1;
root->dir = root;
root->next = root->prev = root;
@@ -550,11 +589,13 @@ ncp_free_all_inodes(struct ncp_server *server)
#if 1
struct ncp_inode_info *root = &(server->root);
if (root->next != root) {
if (root->next != root)
{
printk("ncp_free_all_inodes: INODES LEFT!!!\n");
}
while (root->next != root) {
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.. */
@@ -575,17 +616,22 @@ ncp_find_inode(struct inode *dir, const char *name)
struct nw_info_struct *dir_info = NCP_ISTRUCT(dir);
struct ncp_inode_info *result = &(server->root);
if (name == NULL) {
if (name == NULL)
{
return NULL;
}
do {
do
{
if ( (result->dir->finfo.i.DosDirNum == dir_info->DosDirNum)
&& (strcmp(result->finfo.i.entryName, name) == 0))
{
return result;
}
result = result->next;
} while (result != &(server->root));
}
while (result != &(server->root));
return NULL;
}
@@ -601,7 +647,8 @@ ncp_lookup(struct inode *dir, const char *__name, int len,
*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;
@@ -612,33 +659,42 @@ ncp_lookup(struct inode *dir, const char *__name, int len,
server = NCP_SERVER(dir);
/* 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 == INODE_CACHED) {
parent->state = INODE_LOOKED_UP;
if (parent->state == NCP_INODE_CACHED)
{
parent->state = NCP_INODE_LOOKED_UP;
}
*result = iget(dir->i_sb, (int)parent);
iput(dir);
if (*result == 0)
{
return -EACCES;
}
else
{
return 0;
}
}
result_info = ncp_find_inode(dir, __name);
if (result_info != 0) {
if (result_info->state == INODE_CACHED)
result_info->state = 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 */
@@ -646,7 +702,8 @@ ncp_lookup(struct inode *dir, const char *__name, int len,
*result = iget(dir->i_sb, (int)result_info);
iput(dir);
if (*result == NULL) {
if (*result == NULL)
{
return -EACCES;
}
@@ -658,26 +715,31 @@ ncp_lookup(struct inode *dir, const char *__name, int len,
found_in_cache = 0;
if (dir->i_ino == c_ino) {
if (dir->i_ino == c_ino)
{
int first = c_last_returned_index;
int i;
i = first;
do {
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) {
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;
} while (i != first);
}
while (i != first);
}
if (found_in_cache == 0) {
if (found_in_cache == 0)
{
char this_name[len+1];
memcpy(this_name, __name, len);
@@ -691,7 +753,8 @@ ncp_lookup(struct inode *dir, const char *__name, int len,
dir->i_ino == (int)&(NCP_SERVER(dir)->root)
? NULL : NCP_ISTRUCT(dir),
this_name,
&(finfo.i)) != 0) {
&(finfo.i)) != 0)
{
iput(dir);
return -ENOENT;
}
@@ -700,7 +763,8 @@ ncp_lookup(struct inode *dir, const char *__name, int len,
finfo.opened = 0;
str_lower(finfo.i.entryName);
if (!(*result = ncp_iget(dir, &finfo))) {
if (!(*result = ncp_iget(dir, &finfo)))
{
iput(dir);
return -EACCES;
}
@@ -718,7 +782,8 @@ ncp_create(struct inode *dir, const char *name, int len, int mode,
*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;
@@ -732,7 +797,8 @@ ncp_create(struct inode *dir, const char *name, int len, int mode,
NCP_ISTRUCT(dir), _name,
OC_MODE_CREATE|OC_MODE_OPEN,
0, AR_READ|AR_WRITE,
&finfo) != 0) {
&finfo) != 0)
{
iput(dir);
return -EACCES;
}
@@ -742,7 +808,8 @@ ncp_create(struct inode *dir, const char *name, int len, int mode,
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);
iput(dir);
return -EINVAL;
@@ -759,11 +826,20 @@ ncp_mkdir(struct inode *dir, const char *name, int len, int mode)
struct nw_file_info new_dir;
__u8 _name[len+1];
if ( (name[0] == '.')
&& ( (len == 1)
|| ( (len == 2)
&& (name[1] == '.'))))
{
return -EEXIST;
}
strncpy(_name, name, len);
_name[len] = '\0';
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;
@@ -772,9 +848,12 @@ ncp_mkdir(struct inode *dir, const char *name, int len, int mode)
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->i_ino);
}
@@ -789,12 +868,14 @@ ncp_rmdir(struct inode *dir, const char *name, int len)
int error;
__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_find_inode(dir, name) != NULL) {
if (ncp_find_inode(dir, name) != NULL)
{
error = -EBUSY;
}
else
@@ -806,7 +887,8 @@ ncp_rmdir(struct inode *dir, const char *name, int len)
if ((error = ncp_del_file_or_subdir(NCP_SERVER(dir),
NCP_ISTRUCT(dir),
_name)) == 0) {
_name)) == 0)
{
ncp_invalid_dir_cache(dir->i_ino);
}
else
@@ -824,24 +906,26 @@ ncp_unlink(struct inode *dir, const char *name, int len)
int error;
__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_find_inode(dir, name) != NULL) {
if (ncp_find_inode(dir, name) != NULL)
{
error = -EBUSY;
}
else
{
strncpy(_name, name, len);
_name[len] = '\0';
str_upper(_name);
if ((error = ncp_del_file_or_subdir(NCP_SERVER(dir),
NCP_ISTRUCT(dir),
_name)) == 0) {
_name)) == 0)
{
ncp_invalid_dir_cache(dir->i_ino);
}
else
@@ -861,20 +945,23 @@ ncp_rename(struct inode *old_dir, const char *old_name, int old_len,
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;
}
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;
}
if ( (ncp_find_inode(old_dir, old_name) != NULL)
|| (ncp_find_inode(new_dir, new_name) != NULL)) {
|| (ncp_find_inode(new_dir, new_name) != NULL))
{
res = -EBUSY;
goto finished;
}
@@ -884,14 +971,15 @@ ncp_rename(struct inode *old_dir, const char *old_name, int old_len,
str_upper(_old_name);
strncpy(_new_name, new_name, new_len);
_new_name[old_len] = '\0';
_new_name[new_len] = '\0';
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);
if (res == 0) {
if (res == 0)
{
ncp_invalid_dir_cache(old_dir->i_ino);
ncp_invalid_dir_cache(new_dir->i_ino);
}

105
kernel-1.2/src/file.c
View File

@@ -5,15 +5,10 @@
*
*/
/* #include <linux/module.h>*/
#include <linux/config.h>
#ifdef MODULE
#include <linux/module.h>
#include <linux/version.h>
#else
#define MOD_INC_USE_COUNT
#define MOD_DEC_USE_COUNT
#endif
#include <asm/segment.h>
@@ -29,6 +24,11 @@
#include "ncplib_kernel.h"
#include <linux/malloc.h>
static inline int min(int a, int b)
{
return a<b ? a : b;
}
static int
ncp_fsync(struct inode *inode, struct file *file)
{
@@ -40,7 +40,8 @@ ncp_make_open(struct inode *i, int right)
{
struct nw_file_info *finfo;
if (i == NULL) {
if (i == NULL)
{
printk("ncp_make_open: got NULL inode\n");
return -EINVAL;
}
@@ -49,23 +50,27 @@ ncp_make_open(struct inode *i, int right)
DPRINTK("ncp_make_open: dirent->opened = %d\n", finfo->opened);
if (finfo->opened == 0) {
if (finfo->opened == 0)
{
/* 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) {
finfo) == 0)
{
finfo->access = O_RDONLY;
} else {
}
else
{
return -EACCES;
}
}
@@ -83,18 +88,20 @@ ncp_make_open(struct inode *i, int right)
static int
ncp_file_read(struct inode *inode, struct file *file, char *buf, int count)
{
int bufsize, to_read, already_read;
int bufsize, already_read;
off_t pos;
int errno;
DPRINTK("ncp_file_read: enter %s\n", NCP_ISTRUCT(inode)->entryName);
if (!inode) {
if (inode == NULL)
{
DPRINTK("ncp_file_read: inode = NULL\n");
return -EINVAL;
}
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);
return -EINVAL;
@@ -103,33 +110,34 @@ ncp_file_read(struct inode *inode, struct file *file, char *buf, int count)
pos = file->f_pos;
if (pos + count > inode->i_size)
{
count = inode->i_size - pos;
}
if (count <= 0)
{
return 0;
}
if ((errno = ncp_make_open(inode, O_RDONLY)) != 0)
{
return errno;
}
bufsize = NCP_SERVER(inode)->buffer_size;
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;
if ((pos % bufsize) != 0) {
to_read = bufsize - (pos % bufsize);
} else {
to_read = bufsize;
}
to_read = min(to_read, count - already_read);
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) {
pos, to_read, buf, &read_this_time) != 0)
{
return -EIO; /* This is not exact, i know.. */
}
@@ -137,14 +145,19 @@ ncp_file_read(struct inode *inode, struct file *file, char *buf, int count)
buf += read_this_time;
already_read += read_this_time;
if (read_this_time < to_read) {
if (read_this_time < to_read)
{
break;
}
}
file->f_pos = pos;
if (!IS_RDONLY(inode)) inode->i_atime = CURRENT_TIME;
if (!IS_RDONLY(inode))
{
inode->i_atime = CURRENT_TIME;
}
inode->i_dirt = 1;
DPRINTK("ncp_file_read: exit %s\n", NCP_ISTRUCT(inode)->entryName);
@@ -156,16 +169,18 @@ static int
ncp_file_write(struct inode *inode, struct file *file, char *buf,
int count)
{
int bufsize, to_write, already_written;
int bufsize, already_written;
off_t pos;
int errno;
if (!inode) {
if (inode == NULL)
{
DPRINTK("ncp_file_write: inode = NULL\n");
return -EINVAL;
}
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);
return -EINVAL;
@@ -174,33 +189,35 @@ ncp_file_write(struct inode *inode, struct file *file, char *buf,
DPRINTK("ncp_file_write: enter %s\n", NCP_ISTRUCT(inode)->entryName);
if (count <= 0)
{
return 0;
}
if ((errno = ncp_make_open(inode, O_RDWR)) != 0)
{
return errno;
}
pos = file->f_pos;
if (file->f_flags & O_APPEND)
{
pos = inode->i_size;
}
bufsize = NCP_SERVER(inode)->buffer_size;
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 ((pos % bufsize) != 0) {
to_write = bufsize - (pos % bufsize);
} else {
to_write = bufsize;
}
to_write = min(to_write, 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;
}
@@ -208,7 +225,8 @@ ncp_file_write(struct inode *inode, struct file *file, char *buf,
buf += written_this_time;
already_written += written_this_time;
if (written_this_time < to_write) {
if (written_this_time < to_write)
{
break;
}
}
@@ -218,7 +236,8 @@ ncp_file_write(struct inode *inode, struct file *file, char *buf,
file->f_pos = pos;
if (pos > inode->i_size) {
if (pos > inode->i_size)
{
inode->i_size = pos;
}
@@ -234,7 +253,7 @@ static struct file_operations ncp_file_operations = {
NULL, /* readdir - bad */
NULL, /* select - default */
ncp_ioctl, /* ioctl */
NULL, /* mmap */
ncp_mmap, /* mmap */
NULL, /* open */
NULL, /* release */
ncp_fsync, /* fsync */

123
kernel-1.2/src/inode.c
View File

@@ -46,7 +46,7 @@ static struct super_operations ncp_sops = {
NULL, /* write superblock */
ncp_statfs, /* stat filesystem */
NULL
};
};
/* ncp_read_inode: Called from iget, it only traverses the allocated
ncp_inode_info's and initializes the inode from the data found
@@ -68,20 +68,25 @@ ncp_read_inode(struct inode *inode)
struct ncp_inode_info *root = &(NCP_SERVER(inode)->root);
struct ncp_inode_info *check_info = root;
do {
if (inode_info == check_info) {
if (check_info->state == INODE_LOOKED_UP) {
do
{
if (inode_info == check_info)
{
if (check_info->state == NCP_INODE_LOOKED_UP)
{
DDPRINTK("ncp_read_inode: found it!\n");
goto good;
}
else {
else
{
printk("ncp_read_inode: "
"state != INODE_LOOKED_UP\n");
"state != NCP_INODE_LOOKED_UP\n");
goto good;
}
}
check_info = check_info->next;
} while (check_info != root);
}
while (check_info != root);
/* Ok, now we're in trouble. The inode info is not there. What
should we do now??? */
@@ -92,17 +97,18 @@ ncp_read_inode(struct inode *inode)
DDPRINTK("ncp_read_inode: read entry %s\n",
inode_info->finfo.i.entryName);
#endif
inode_info->state = INODE_VALID;
inode_info->state = NCP_INODE_VALID;
NCP_INOP(inode) = inode_info;
if (NCP_ISTRUCT(inode)->attributes & aDIR) {
if (NCP_ISTRUCT(inode)->attributes & aDIR)
{
inode->i_mode = NCP_SERVER(inode)->m.dir_mode;
/* for directories in dataStreamSize seems to be some
Object ID ??? */
inode->i_size = 0;
inode->i_size = 512;
}
else
else
{
inode->i_mode = NCP_SERVER(inode)->m.file_mode;
inode->i_size = NCP_ISTRUCT(inode)->dataStreamSize;
@@ -115,11 +121,16 @@ ncp_read_inode(struct inode *inode)
inode->i_gid = NCP_SERVER(inode)->m.gid;
inode->i_blksize = 1024;
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(NCP_ISTRUCT(inode)->modifyTime,
NCP_ISTRUCT(inode)->modifyDate);
@@ -129,12 +140,17 @@ ncp_read_inode(struct inode *inode)
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;
}
}
static void
@@ -142,9 +158,10 @@ ncp_put_inode(struct inode *inode)
{
struct nw_file_info *finfo = NCP_FINFO(inode);
if (finfo->opened != 0) {
if (ncp_close_file(NCP_SERVER(inode), finfo->file_handle)!=0) {
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");
}
@@ -152,10 +169,11 @@ ncp_put_inode(struct inode *inode)
DDPRINTK("ncp_put_inode: put %s\n",
finfo->i.entryName);
ncp_free_inode_info(NCP_INOP(inode));
if (S_ISDIR(inode->i_mode)) {
if (S_ISDIR(inode->i_mode))
{
DDPRINTK("ncp_put_inode: put directory %ld\n",
inode->i_ino);
ncp_invalid_dir_cache(inode->i_ino);
@@ -174,22 +192,24 @@ ncp_read_super(struct super_block *sb, void *raw_data, int silent)
dev_t dev = sb->s_dev;
int error;
if (!data) {
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");
}
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;
@@ -197,7 +217,8 @@ ncp_read_super(struct super_block *sb, void *raw_data, int silent)
if ( (data->wdog_fd >= NR_OPEN)
|| ((wdog_filp = current->files->fd[data->wdog_fd]) == NULL)
|| (!S_ISSOCK(wdog_filp->f_inode->i_mode))) {
|| (!S_ISSOCK(wdog_filp->f_inode->i_mode)))
{
printk("ncp_read_super: invalid wdog socket\n");
sb->s_dev = 0;
return NULL;
@@ -207,7 +228,8 @@ ncp_read_super(struct super_block *sb, void *raw_data, int silent)
server = (struct ncp_server *)ncp_kmalloc(sizeof(struct ncp_server),
GFP_KERNEL);
if (server == NULL) {
if (server == NULL)
{
printk("ncp_read_super: could not alloc ncp_server\n");
return NULL;
}
@@ -241,7 +263,8 @@ ncp_read_super(struct super_block *sb, void *raw_data, int silent)
server->packet_size = NCP_PACKET_SIZE;
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);
@@ -254,7 +277,8 @@ ncp_read_super(struct super_block *sb, void *raw_data, int silent)
* Make the connection to the server
*/
if (ncp_catch_watchdog(server) != 0) {
if (ncp_catch_watchdog(server) != 0)
{
printk("ncp_read_super: Could not catch watchdog\n");
error = -EINVAL;
unlock_super(sb);
@@ -266,7 +290,8 @@ ncp_read_super(struct super_block *sb, void *raw_data, int silent)
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);
@@ -277,14 +302,16 @@ ncp_read_super(struct super_block *sb, void *raw_data, int silent)
DPRINTK("ncp_read_super: NCP_SBP(sb) = %x\n", (int)NCP_SBP(sb));
if (!(sb->s_mounted = iget(sb, (int)&(server->root)))) {
if (!(sb->s_mounted = iget(sb, (int)&(server->root))))
{
sb->s_dev = 0;
printk("ncp_read_super: get root inode failed\n");
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;
@@ -292,14 +319,6 @@ ncp_read_super(struct super_block *sb, void *raw_data, int silent)
DPRINTK("ncpfs: bufsize = %d\n", server->buffer_size);
/* if (ncp_login_user(server, server->m.username,
server->m.password) != 0) {
sb->s_dev = 0;
printk("ncp_read_super: login failed\n");
goto disconnect;
}
*/
MOD_INC_USE_COUNT;
return sb;
@@ -393,43 +412,59 @@ ncp_notify_change(struct inode *inode, struct iattr *attr)
info_mask = 0;
memset(&info, 0, sizeof(info));
if ((attr->ia_valid & ATTR_CTIME) != 0) {
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));
}
if ((attr->ia_valid & ATTR_MTIME) != 0) {
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));
}
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));
}
if (info_mask != 0) {
if (info_mask != 0)
{
if ((result =
ncp_modify_file_or_subdir_dos_info(NCP_SERVER(inode),
NCP_ISTRUCT(inode),
info_mask,
&info)) != 0) {
&info)) != 0)
{
result = -EACCES;
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. */
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;
}

75
kernel-1.2/src/ioctl.c
View File

@@ -9,9 +9,6 @@
#ifdef MODULE
#include <linux/module.h>
#include <linux/version.h>
#else
#define MOD_INC_USE_COUNT
#define MOD_DEC_USE_COUNT
#endif
#include <asm/segment.h>
@@ -29,17 +26,21 @@ ncp_ioctl (struct inode * inode, struct file * filp,
{
int result;
struct ncp_ioctl_request request;
struct ncp_server *server;
struct ncp_fs_info info;
struct ncp_server *server = NCP_SERVER(inode);
switch(cmd) {
case NCP_IOC_NCPREQUEST:
if (!suser()) {
return -EPERM;
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) {
sizeof(request))) != 0)
{
return result;
}
@@ -48,45 +49,81 @@ ncp_ioctl (struct inode * inode, struct file * filp,
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) {
NCP_PACKET_SIZE)) != 0)
{
return result;
}
server = NCP_SERVER(inode);
ncp_lock_server(server);
/* FIXME: We hack around in the server's structures
here to be able to use ncp_request */
server->has_subfunction = 0;
server->current_size =
request.size + sizeof(struct ncp_request_header);
memcpy_fromfs(server->packet, request.data,
request.size+sizeof(struct ncp_request_header));
server->current_size = request.size;
memcpy_fromfs(server->packet, request.data, request.size);
ncp_request(server, request.function);
DPRINTK("ncp_ioctl: copy %d bytes\n",
server->reply_size);
memcpy_tofs(request.data, server->packet,
server->reply_size);
memcpy_tofs(request.data, server->packet, server->reply_size);
ncp_unlock_server(server);
return server->reply_size;
case NCP_IOC_GET_FS_INFO:
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)
{
return result;
}
memcpy_fromfs(&info, (struct ncp_fs_info *)arg,
sizeof(info));
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;
memcpy_tofs((struct ncp_fs_info *)arg, &info, sizeof(info));
return 0;
case NCP_IOC_GETMOUNTUID:
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) {
sizeof(uid_t))) != 0)
{
return result;
}
put_fs_word(NCP_SERVER(inode)->m.mounted_uid, (uid_t*) arg);
put_fs_word(server->m.mounted_uid, (uid_t*) arg);
return 0;
default:

152
kernel-1.2/src/mmap.c Normal file
View File

@@ -0,0 +1,152 @@
/*
* mmap.c
*
* Copyright (C) 1995 by Volker Lendecke
*
*/
#include <linux/config.h>
#ifdef MODULE
#include <linux/module.h>
#include <linux/version.h>
#endif
#include <linux/stat.h>
#include <linux/sched.h>
#include <linux/kernel.h>
#include <linux/mm.h>
#include <linux/shm.h>
#include <linux/errno.h>
#include <linux/mman.h>
#include <linux/string.h>
#include <linux/malloc.h>
#include <linux/fcntl.h>
#include <linux/ncp_fs.h>
#include "ncplib_kernel.h"
#include <asm/segment.h>
#include <asm/system.h>
static inline int min(int a, int b)
{
return a<b ? a : b;
}
/*
* Fill in the supplied page for mmap
*/
static unsigned long
ncp_file_mmap_nopage(struct vm_area_struct * area,
unsigned long address, unsigned long page, int no_share)
{
struct inode * inode = area->vm_inode;
unsigned int clear;
unsigned long tmp;
int bufsize;
int pos;
unsigned short fs;
address &= PAGE_MASK;
pos = address - area->vm_start + area->vm_offset;
clear = 0;
if (address + PAGE_SIZE > area->vm_end)
{
clear = address + PAGE_SIZE - area->vm_end;
}
/* 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
{
int already_read = 0;
int count = PAGE_SIZE - clear;
int to_read;
while (already_read < count)
{
int read_this_time;
if ((pos % bufsize) != 0)
{
to_read = bufsize - (pos % bufsize);
}
else
{
to_read = bufsize;
}
to_read = min(to_read, count - already_read);
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;
}
pos += read_this_time;
already_read += read_this_time;
if (read_this_time < to_read)
{
break;
}
}
}
set_fs(fs);
tmp = page + PAGE_SIZE;
while (clear--) {
*(char *)--tmp = 0;
}
return page;
}
struct vm_operations_struct ncp_file_mmap = {
NULL, /* open */
NULL, /* close */
NULL, /* unmap */
NULL, /* protect */
NULL, /* sync */
NULL, /* advise */
ncp_file_mmap_nopage, /* nopage */
NULL, /* wppage */
NULL, /* swapout */
NULL, /* swapin */
};
/* 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)
{
DPRINTK("ncp_mmap: called\n");
/* 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;
if (!IS_RDONLY(inode)) {
inode->i_atime = CURRENT_TIME;
inode->i_dirt = 1;
}
vma->vm_inode = inode;
inode->i_count++;
vma->vm_ops = &ncp_file_mmap;
return 0;
}

91
kernel-1.2/src/ncplib_kernel.c
View File

@@ -2,23 +2,24 @@
#ifdef MODULE
#include <linux/module.h>
#include <linux/version.h>
#else
#define MOD_INC_USE_COUNT
#define MOD_DEC_USE_COUNT
#endif
#include "ncplib_kernel.h"
typedef __u8 byte;
typedef __u16 word;
typedef __u32 dword;
static inline int min(int a, int b)
{
return a<b ? a : b;
}
static void
assert_server_locked(struct ncp_server *server)
{
if (server->lock == 0) {
if (server->lock == 0)
{
DPRINTK("ncpfs: server not locked!\n");
}
}
@@ -73,7 +74,8 @@ 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;
}
@@ -128,14 +130,15 @@ ncp_reply_dword(struct ncp_server *server, int offset)
int
ncp_negotiate_buffersize(struct ncp_server *server,
int size, int *target) {
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;
}
@@ -156,7 +159,8 @@ ncp_get_volume_info_with_number(struct ncp_server *server, int n,
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;
}
@@ -172,7 +176,8 @@ ncp_get_volume_info_with_number(struct ncp_server *server, int n,
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;
@@ -191,7 +196,8 @@ ncp_get_volume_number(struct ncp_server *server, const char *name, int *target)
ncp_init_request_s(server, 5);
ncp_add_pstring(server, name);
if ((result = ncp_request(server, 22)) != 0) {
if ((result = ncp_request(server, 22)) != 0)
{
ncp_unlock_server(server);
return result;
}
@@ -210,7 +216,8 @@ ncp_close_file(struct ncp_server *server, const char *file_id)
ncp_add_byte(server, 0);
ncp_add_mem(server, file_id, 6);
if ((result = ncp_request(server, 66)) != 0) {
if ((result = ncp_request(server, 66)) != 0)
{
ncp_unlock_server(server);
return result;
}
@@ -227,12 +234,16 @@ ncp_add_handle_path(struct ncp_server *server,
{
ncp_add_byte(server, vol_num);
ncp_add_dword(server, dir_base);
if (have_dir_base != 0) {
if (have_dir_base != 0)
{
ncp_add_byte(server, 1); /* dir_base */
} else {
}
else
{
ncp_add_byte(server, 0xff); /* no handle */
}
if (path != NULL) {
if (path != NULL)
{
ncp_add_byte(server, 1); /* 1 component */
ncp_add_pstring(server, path);
}
@@ -268,11 +279,13 @@ ncp_do_lookup(struct ncp_server *server,
int result;
char *volname = NULL;
if (target == NULL) {
if (target == NULL)
{
return -EINVAL;
}
if (dir == NULL) {
if (dir == NULL)
{
DDPRINTK("ncp_do_lookup: looking up vol %s\n", path);
@@ -286,7 +299,8 @@ ncp_do_lookup(struct ncp_server *server,
ncp_add_handle_path(server, 0, 0, 0, /* no handle */
path);
if ((result = ncp_request(server, 87)) != 0) {
if ((result = ncp_request(server, 87)) != 0)
{
ncp_unlock_server(server);
return result;
}
@@ -312,14 +326,16 @@ ncp_do_lookup(struct ncp_server *server,
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);
if (volname != NULL) {
if (volname != NULL)
{
target->nameLen = strlen(volname);
strcpy(target->entryName, volname);
}
@@ -347,7 +363,8 @@ ncp_modify_file_or_subdir_dos_info(struct ncp_server *server,
ncp_add_handle_path(server, file->volNumber,
file->DosDirNum, 1, NULL);
if ((result = ncp_request(server, 87)) != 0) {
if ((result = ncp_request(server, 87)) != 0)
{
ncp_unlock_server(server);
return result;
}
@@ -370,7 +387,8 @@ ncp_del_file_or_subdir(struct ncp_server *server,
ncp_add_handle_path(server, dir->volNumber,
dir->DosDirNum, 1, name);
if ((result = ncp_request(server, 87)) != 0) {
if ((result = ncp_request(server, 87)) != 0)
{
ncp_unlock_server(server);
return result;
}
@@ -411,16 +429,20 @@ ncp_open_create_file_or_subdir(struct ncp_server *server,
for directories */
ncp_add_word(server, desired_acc_rights);
if (dir != NULL) {
if (dir != NULL)
{
ncp_add_handle_path(server, dir->volNumber,
dir->DosDirNum, 1, name);
} else {
}
else
{
ncp_add_handle_path(server,
target->i.volNumber, target->i.DosDirNum,
1, NULL);
}
if ((result = ncp_request(server, 87)) != 0) {
if ((result = ncp_request(server, 87)) != 0)
{
ncp_unlock_server(server);
return result;
}
@@ -429,7 +451,8 @@ ncp_open_create_file_or_subdir(struct ncp_server *server,
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));
}
@@ -454,7 +477,8 @@ ncp_initialize_search(struct ncp_server *server,
ncp_add_byte(server, 0); /* reserved */
ncp_add_handle_path(server, dir->volNumber, dir->DosDirNum, 1, NULL);
if ((result = ncp_request(server, 87)) != 0) {
if ((result = ncp_request(server, 87)) != 0)
{
ncp_unlock_server(server);
return result;
}
@@ -484,7 +508,8 @@ ncp_search_for_file_or_subdir(struct ncp_server *server,
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;
}
@@ -550,7 +575,8 @@ ncp_read(struct ncp_server *server, const char *file_id,
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;
}
@@ -577,7 +603,8 @@ ncp_write(struct ncp_server *server, const char *file_id,
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;
}

124
kernel-1.2/src/sock.c
View File

@@ -11,9 +11,6 @@
#ifdef MODULE
#include <linux/module.h>
#include <linux/version.h>
#else
#define MOD_INC_USE_COUNT
#define MOD_DEC_USE_COUNT
#endif
#include <linux/sched.h>
@@ -69,7 +66,9 @@ ncp_wdog_data_ready(struct sock *sk, int len)
printk("ncpfs: got strange packet on watchdog "
"socket\n");
} else {
}
else
{
int result;
DDPRINTK("ncpfs: got watchdog from:\n");
DDPRINTK("ncpfs: %08lX:%02X%02X%02X%02X%02X%02X:%04X,"
@@ -104,8 +103,8 @@ ncp_catch_watchdog(struct ncp_server *server)
if ( (server == NULL)
|| ((file = server->wdog_filp) == NULL)
|| ((inode = file->f_inode) == NULL)
|| (!S_ISSOCK(inode->i_mode))) {
|| (!S_ISSOCK(inode->i_mode)))
{
printk("ncp_catch_watchdog: did not get valid server!\n");
server->data_ready = NULL;
return -EINVAL;
@@ -113,7 +112,8 @@ ncp_catch_watchdog(struct ncp_server *server)
sock = &(inode->u.socket_i);
if (sock->type != SOCK_DGRAM) {
if (sock->type != SOCK_DGRAM)
{
printk("ncp_catch_watchdog: did not get SOCK_STREAM\n");
server->data_ready = NULL;
return -EINVAL;
@@ -121,7 +121,8 @@ ncp_catch_watchdog(struct ncp_server *server)
sk = (struct sock *)(sock->data);
if (sk == NULL) {
if (sk == NULL)
{
printk("ncp_catch_watchdog: sk == NULL");
server->data_ready = NULL;
return -EINVAL;
@@ -131,7 +132,8 @@ ncp_catch_watchdog(struct ncp_server *server)
(unsigned int)(sk->data_ready),
(unsigned int)(server->data_ready));
if (sk->data_ready == ncp_wdog_data_ready) {
if (sk->data_ready == ncp_wdog_data_ready)
{
printk("ncp_catch_watchdog: already done\n");
return -EINVAL;
}
@@ -152,8 +154,8 @@ ncp_dont_catch_watchdog(struct ncp_server *server)
if ( (server == NULL)
|| ((file = server->wdog_filp) == NULL)
|| ((inode = file->f_inode) == NULL)
|| (!S_ISSOCK(inode->i_mode))) {
|| (!S_ISSOCK(inode->i_mode)))
{
printk("ncp_dont_catch_watchdog: "
"did not get valid server!\n");
return -EINVAL;
@@ -161,25 +163,29 @@ ncp_dont_catch_watchdog(struct ncp_server *server)
sock = &(inode->u.socket_i);
if (sock->type != SOCK_DGRAM) {
if (sock->type != SOCK_DGRAM)
{
printk("ncp_dont_catch_watchdog: did not get SOCK_STREAM\n");
return -EINVAL;
}
sk = (struct sock *)(sock->data);
if (sk == NULL) {
if (sk == NULL)
{
printk("ncp_dont_catch_watchdog: sk == NULL");
return -EINVAL;
}
if (server->data_ready == NULL) {
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) {
if (sk->data_ready != ncp_wdog_data_ready)
{
printk("ncp_dont_catch_watchdog: "
"sk->data_callback != ncp_data_callback\n");
return -EINVAL;
@@ -216,7 +222,6 @@ do_ncp_rpc_call(struct ncp_server *server, int size)
int timeout;
int retrans;
int major_timeout_seen;
char *server_name;
int n;
int addrlen;
unsigned long old_mask;
@@ -232,7 +237,8 @@ do_ncp_rpc_call(struct ncp_server *server, int size)
inode = file->f_inode;
select = file->f_op->select;
sock = &inode->u.socket_i;
if (!sock) {
if (!sock)
{
printk("ncp_rpc_call: socki_lookup failed\n");
return -EBADF;
}
@@ -240,7 +246,6 @@ do_ncp_rpc_call(struct ncp_server *server, int size)
max_timeout = NCP_MAX_RPC_TIMEOUT*HZ/10;
retrans = server->m.retry_count;
major_timeout_seen = 0;
server_name = server->m.server_name;
old_mask = current->blocked;
current->blocked |= ~(_S(SIGKILL)
#if 0
@@ -254,7 +259,8 @@ do_ncp_rpc_call(struct ncp_server *server, int size)
: 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],
@@ -276,7 +282,8 @@ do_ncp_rpc_call(struct ncp_server *server, int size)
(struct sockaddr *)
&(server->m.serv_addr),
sizeof(server->m.serv_addr));
if (result < 0) {
if (result < 0)
{
printk("ncp_rpc_call: send error = %d\n", result);
break;
}
@@ -285,39 +292,42 @@ do_ncp_rpc_call(struct ncp_server *server, int size)
wait_table.entry = &entry;
current->state = TASK_INTERRUPTIBLE;
if ( !select(inode, file, SEL_IN, &wait_table)
&& !select(inode, file, SEL_IN, NULL)) {
if (timeout > max_timeout) {
&& !select(inode, file, SEL_IN, NULL))
{
if (timeout > max_timeout)
{
/* JEJB/JSP 2/7/94
* This is useful to see if the system is
* hanging */
printk("NCP max timeout reached on %s\n",
server_name);
printk("NCP max timeout reached\n");
timeout = max_timeout;
}
current->timeout = jiffies + timeout;
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;
@@ -336,23 +346,28 @@ do_ncp_rpc_call(struct ncp_server *server, int size)
result = sock->ops->recvfrom(sock, (void *)&reply,
sizeof(reply), 1, MSG_PEEK,
NULL, &addrlen);
if (result < 0) {
if (result == -EAGAIN) {
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);
}
break;
}
if ( (result == sizeof(reply))
&& (reply.type == NCP_POSITIVE_ACK)) {
&& (reply.type == NCP_POSITIVE_ACK))
{
/* Throw away the packet */
DPRINTK("ncp_rpc_call: got positive acknowledge\n");
sock->ops->recvfrom(sock, (void *)&reply,
@@ -374,9 +389,10 @@ do_ncp_rpc_call(struct ncp_server *server, int size)
|| ( (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)))) {
&& (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
@@ -396,9 +412,12 @@ do_ncp_rpc_call(struct ncp_server *server, int size)
*/
result = sock->ops->recvfrom(sock, (void *)start, server->packet_size,
1, 0, NULL, &addrlen);
if (result < 0) {
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,addrlen=%d\n", result, addrlen);
@@ -418,7 +437,8 @@ do_ncp_rpc_call(struct ncp_server *server, int size)
static int
ncp_do_request(struct ncp_server *server, int size)
{
if (server->lock == 0) {
if (server->lock == 0)
{
printk("ncpfs: Server not locked!\n");
return -EIO;
}
@@ -442,7 +462,8 @@ ncp_request(struct ncp_server *server, int function)
int result;
if (server->has_subfunction != 0) {
if (server->has_subfunction != 0)
{
*(__u16 *)&(h->data[0]) = request_size - 2;
}
@@ -455,7 +476,8 @@ ncp_request(struct ncp_server *server, int 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;
}
@@ -467,7 +489,8 @@ ncp_request(struct ncp_server *server, int function)
result = reply->completion_code;
if (result != 0) {
if (result != 0)
{
DPRINTK("ncp_completion_code: %d\n", result);
}
return result;
@@ -489,7 +512,8 @@ ncp_connect(struct ncp_server *server)
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;
}
@@ -519,9 +543,10 @@ ncp_disconnect(struct ncp_server *server)
void
ncp_lock_server(struct ncp_server *server)
{
#if 1
#if 0
/* For testing, only 1 process */
if (server->lock != 0) {
if (server->lock != 0)
{
DPRINTK("ncpfs: server locked!!!\n");
}
#endif
@@ -533,7 +558,8 @@ ncp_lock_server(struct ncp_server *server)
void
ncp_unlock_server(struct ncp_server *server)
{
if (server->lock != 1) {
if (server->lock != 1)
{
printk("ncp_unlock_server: was not locked!\n");
}