/*
   *  linux/fs/ncpfs/symlink.c
   *
   *  Code for allowing symbolic links on NCPFS (i.e. NetWare)
   *  Symbolic links are not supported on native NetWare, so we use an
   *  infrequently-used flag (Sh) and store a two-word magic header in
   *  the file to make sure we don't accidentally use a non-link file
   *  as a link.
   *
   *  When using the NFS namespace, we set the mode to indicate a symlink and
   *  don't bother with the magic numbers.
   *
   *  from linux/fs/ext2/symlink.c
   *
   *  Copyright (C) 1998-99, Frank A. Vorstenbosch
   *
   *  ncpfs symlink handling code
   *  NLS support (c) 1999 Petr Vandrovec
   *  Modified 2000 Ben Harris, University of Cambridge for NFS NS meta-info
   *
   */

  
  #include <asm/uaccess.h>
  
  #include <linux/errno.h>
  #include <linux/fs.h>

  #include <linux/time.h>

  #include <linux/slab.h>

  #include <linux/mm.h>
  #include <linux/stat.h>

  #include "ncp_fs.h"

  
  /* these magic numbers must appear in the symlink file -- this makes it a bit
     more resilient against the magic attributes being set on random files. */
  
  #define NCP_SYMLINK_MAGIC0	cpu_to_le32(0x6c6d7973)     /* "symlnk->" */
  #define NCP_SYMLINK_MAGIC1	cpu_to_le32(0x3e2d6b6e)
  
  /* ----- read a symbolic link ------------------------------------------ */
  
  static int ncp_symlink_readpage(struct file *file, struct page *page)
  {
  	struct inode *inode = page->mapping->host;
  	int error, length, len;
  	char *link, *rawlink;
  	char *buf = kmap(page);
  
  	error = -ENOMEM;

  	rawlink = kmalloc(NCP_MAX_SYMLINK_SIZE, GFP_KERNEL);

  	if (!rawlink)
  		goto fail;
  
  	if (ncp_make_open(inode,O_RDONLY))
  		goto failEIO;
  
  	error=ncp_read_kernel(NCP_SERVER(inode),NCP_FINFO(inode)->file_handle,
                           0,NCP_MAX_SYMLINK_SIZE,rawlink,&length);
  
  	ncp_inode_close(inode);
  	/* Close file handle if no other users... */
  	ncp_make_closed(inode);
  	if (error)
  		goto failEIO;
  
  	if (NCP_FINFO(inode)->flags & NCPI_KLUDGE_SYMLINK) {
  		if (length<NCP_MIN_SYMLINK_SIZE || 
  		    ((__le32 *)rawlink)[0]!=NCP_SYMLINK_MAGIC0 ||
  		    ((__le32 *)rawlink)[1]!=NCP_SYMLINK_MAGIC1)
  		    	goto failEIO;
  		link = rawlink + 8;
  		length -= 8;
  	} else {
  		link = rawlink;
  	}
  
  	len = NCP_MAX_SYMLINK_SIZE;
  	error = ncp_vol2io(NCP_SERVER(inode), buf, &len, link, length, 0);
  	kfree(rawlink);
  	if (error)
  		goto fail;
  	SetPageUptodate(page);
  	kunmap(page);
  	unlock_page(page);
  	return 0;
  
  failEIO:
  	error = -EIO;
  	kfree(rawlink);
  fail:
  	SetPageError(page);
  	kunmap(page);
  	unlock_page(page);
  	return error;
  }
  
  /*
   * symlinks can't do much...
   */

  const struct address_space_operations ncp_symlink_aops = {

  	.readpage	= ncp_symlink_readpage,
  };
  	
  /* ----- create a new symbolic link -------------------------------------- */
   
  int ncp_symlink(struct inode *dir, struct dentry *dentry, const char *symname) {
  	struct inode *inode;
  	char *rawlink;
  	int length, err, i, outlen;
  	int kludge;

  	umode_t mode;

  	__le32 attr;
  	unsigned int hdr;
  
  	DPRINTK("ncp_symlink(dir=%p,dentry=%p,symname=%s)
  ",dir,dentry,symname);
  
  	if (ncp_is_nfs_extras(NCP_SERVER(dir), NCP_FINFO(dir)->volNumber))
  		kludge = 0;
  	else
  #ifdef CONFIG_NCPFS_EXTRAS
  	if (NCP_SERVER(dir)->m.flags & NCP_MOUNT_SYMLINKS)
  		kludge = 1;
  	else
  #endif
  	/* EPERM is returned by VFS if symlink procedure does not exist */
  		return -EPERM;
    

  	rawlink = kmalloc(NCP_MAX_SYMLINK_SIZE, GFP_KERNEL);

  	if (!rawlink)
  		return -ENOMEM;
  
  	if (kludge) {
  		mode = 0;
  		attr = aSHARED | aHIDDEN;
  		((__le32 *)rawlink)[0]=NCP_SYMLINK_MAGIC0;
  		((__le32 *)rawlink)[1]=NCP_SYMLINK_MAGIC1;
  		hdr = 8;
  	} else {
  		mode = S_IFLNK | S_IRWXUGO;
  		attr = 0;
  		hdr = 0;
  	}			
  
  	length = strlen(symname);
  	/* map to/from server charset, do not touch upper/lower case as
  	   symlink can point out of ncp filesystem */
  	outlen = NCP_MAX_SYMLINK_SIZE - hdr;
  	err = ncp_io2vol(NCP_SERVER(dir), rawlink + hdr, &outlen, symname, length, 0);
  	if (err)
  		goto failfree;
  
  	outlen += hdr;
  
  	err = -EIO;
  	if (ncp_create_new(dir,dentry,mode,0,attr)) {
  		goto failfree;
  	}
  
  	inode=dentry->d_inode;
  
  	if (ncp_make_open(inode, O_WRONLY))
  		goto failfree;
  
  	if (ncp_write_kernel(NCP_SERVER(inode), NCP_FINFO(inode)->file_handle, 
  			     0, outlen, rawlink, &i) || i!=outlen) {
  		goto fail;
  	}
  
  	ncp_inode_close(inode);
  	ncp_make_closed(inode);
  	kfree(rawlink);
  	return 0;
  fail:;
  	ncp_inode_close(inode);
  	ncp_make_closed(inode);
  failfree:;
  	kfree(rawlink);
  	return err;
  }
  
  /* ----- EOF ----- */