Logo Search packages:      
Sourcecode: linux version File versions  Download package

socksys.c

/* $Id: socksys.c,v 1.21 2002/02/08 03:57:14 davem Exp $
 * socksys.c: /dev/inet/ stuff for Solaris emulation.
 *
 * Copyright (C) 1997 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
 * Copyright (C) 1997, 1998 Patrik Rak (prak3264@ss1000.ms.mff.cuni.cz)
 * Copyright (C) 1995, 1996 Mike Jagdis (jaggy@purplet.demon.co.uk)
 */

/*
 *  Dave, _please_ give me specifications on this fscking mess so that I
 * could at least get it into the state when it wouldn't screw the rest of
 * the kernel over.  socksys.c and timod.c _stink_ and we are not talking
 * H2S here, it's isopropilmercaptan in concentrations way over LD50. -- AV
 */

#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/smp.h>
#include <linux/ioctl.h>
#include <linux/fs.h>
#include <linux/file.h>
#include <linux/init.h>
#include <linux/poll.h>
#include <linux/slab.h>
#include <linux/syscalls.h>
#include <linux/in.h>

#include <net/sock.h>

#include <asm/uaccess.h>
#include <asm/termios.h>

#include "conv.h"
#include "socksys.h"

static int af_inet_protocols[] = {
IPPROTO_ICMP, IPPROTO_ICMP, IPPROTO_IGMP, IPPROTO_IPIP, IPPROTO_TCP,
IPPROTO_EGP, IPPROTO_PUP, IPPROTO_UDP, IPPROTO_IDP, IPPROTO_RAW,
0, 0, 0, 0, 0, 0,
};

#ifndef DEBUG_SOLARIS_KMALLOC

#define mykmalloc kmalloc
#define mykfree kfree

#else

extern void * mykmalloc(size_t s, gfp_t gfp);
extern void mykfree(void *);

#endif

static unsigned int (*sock_poll)(struct file *, poll_table *);

static struct file_operations socksys_file_ops = {
      /* Currently empty */
};

static int socksys_open(struct inode * inode, struct file * filp)
{
      int family, type, protocol, fd;
      struct dentry *dentry;
      int (*sys_socket)(int,int,int) =
            (int (*)(int,int,int))SUNOS(97);
        struct sol_socket_struct * sock;
      
      family = ((iminor(inode) >> 4) & 0xf);
      switch (family) {
      case AF_UNIX:
            type = SOCK_STREAM;
            protocol = 0;
            break;
      case AF_INET:
            protocol = af_inet_protocols[iminor(inode) & 0xf];
            switch (protocol) {
            case IPPROTO_TCP: type = SOCK_STREAM; break;
            case IPPROTO_UDP: type = SOCK_DGRAM; break;
            default: type = SOCK_RAW; break;
            }
            break;
      default:
            type = SOCK_RAW;
            protocol = 0;
            break;
      }

      fd = sys_socket(family, type, protocol);
      if (fd < 0)
            return fd;
      /*
       * N.B. The following operations are not legal!
       *
       * No shit.  WTF is it supposed to do, anyway?
       *
       * Try instead:
       * d_delete(filp->f_path.dentry), then d_instantiate with sock inode
       */
      dentry = filp->f_path.dentry;
      filp->f_path.dentry = dget(fcheck(fd)->f_path.dentry);
      filp->f_path.dentry->d_inode->i_rdev = inode->i_rdev;
      filp->f_path.dentry->d_inode->i_flock = inode->i_flock;
      SOCKET_I(filp->f_path.dentry->d_inode)->file = filp;
      filp->f_op = &socksys_file_ops;
        sock = (struct sol_socket_struct*) 
            mykmalloc(sizeof(struct sol_socket_struct), GFP_KERNEL);
        if (!sock) return -ENOMEM;
      SOLDD(("sock=%016lx(%016lx)\n", sock, filp));
        sock->magic = SOLARIS_SOCKET_MAGIC;
        sock->modcount = 0;
        sock->state = TS_UNBND;
        sock->offset = 0;
        sock->pfirst = sock->plast = NULL;
        filp->private_data = sock;
      SOLDD(("filp->private_data %016lx\n", filp->private_data));

      sys_close(fd);
      dput(dentry);
      return 0;
}

static int socksys_release(struct inode * inode, struct file * filp)
{
        struct sol_socket_struct * sock;
        struct T_primsg *it;

      /* XXX: check this */
      sock = (struct sol_socket_struct *)filp->private_data;
      SOLDD(("sock release %016lx(%016lx)\n", sock, filp));
      it = sock->pfirst;
      while (it) {
            struct T_primsg *next = it->next;
            
            SOLDD(("socksys_release %016lx->%016lx\n", it, next));
            mykfree((char*)it);
            it = next;
      }
      filp->private_data = NULL;
      SOLDD(("socksys_release %016lx\n", sock));
      mykfree((char*)sock);
      return 0;
}

static unsigned int socksys_poll(struct file * filp, poll_table * wait)
{
      struct inode *ino;
      unsigned int mask = 0;

      ino=filp->f_path.dentry->d_inode;
      if (ino && S_ISSOCK(ino->i_mode)) {
            struct sol_socket_struct *sock;
            sock = (struct sol_socket_struct*)filp->private_data;
            if (sock && sock->pfirst) {
                  mask |= POLLIN | POLLRDNORM;
                  if (sock->pfirst->pri == MSG_HIPRI)
                        mask |= POLLPRI;
            }
      }
      if (sock_poll)
            mask |= (*sock_poll)(filp, wait);
      return mask;
}
      
static const struct file_operations socksys_fops = {
      .open =           socksys_open,
      .release =  socksys_release,
};

int __init init_socksys(void)
{
      int ret;
      struct file * file;
      int (*sys_socket)(int,int,int) =
            (int (*)(int,int,int))SUNOS(97);
      int (*sys_close)(unsigned int) = 
            (int (*)(unsigned int))SYS(close);
      
      ret = register_chrdev (30, "socksys", &socksys_fops);
      if (ret < 0) {
            printk ("Couldn't register socksys character device\n");
            return ret;
      }
      ret = sys_socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
      if (ret < 0) {
            printk ("Couldn't create socket\n");
            return ret;
      }

      file = fcheck(ret);
      /* N.B. Is this valid? Suppose the f_ops are in a module ... */
      socksys_file_ops = *file->f_op;
      sys_close(ret);
      sock_poll = socksys_file_ops.poll;
      socksys_file_ops.poll = socksys_poll;
      socksys_file_ops.release = socksys_release;
      return 0;
}

void __exit cleanup_socksys(void)
{
      unregister_chrdev(30, "socksys");
}

Generated by  Doxygen 1.6.0   Back to index