Linux Cross Reference
Linux/arch/um/drivers/umn_user.c

** Warning: Cannot open xref database.
   #include <stdio.h>
   #include <unistd.h>
   #include <stdlib.h>
   #include <fcntl.h>
   #include <termios.h>
   #include <wait.h>
   #include <signal.h>
   #include <sched.h>
   #include <errno.h>
  #include <sys/socket.h>
  #include <sys/ioctl.h>
  #include <sys/vfs.h> 
  #include "umn.h"
  #include "user_util.h"
  #include "kern_util.h"
  #include "user.h"
  
  extern char *ptsname(int);
  
  char buff[3000];
  
  /* SLIP protocol characters. */
  #define END             0300            /* indicates end of frame       */
  #define ESC             0333            /* indicates byte stuffing      */
  #define ESC_END         0334            /* ESC ESC_END means END 'data' */
  #define ESC_ESC         0335            /* ESC ESC_ESC means ESC 'data' */
  
  static int slip_esc(unsigned char *s, unsigned char *d, int len)
  {
          unsigned char *ptr = d;
          unsigned char c;
  
          /*
           * Send an initial END character to flush out any
           * data that may have accumulated in the receiver
           * due to line noise.
           */
  
          *ptr++ = END;
  
          /*
           * For each byte in the packet, send the appropriate
           * character sequence, according to the SLIP protocol.
           */
  
          while (len-- > 0) {
                  switch(c = *s++) {
                   case END:
                          *ptr++ = ESC;
                          *ptr++ = ESC_END;
                          break;
                   case ESC:
                          *ptr++ = ESC;
                          *ptr++ = ESC_ESC;
                          break;
                   default:
                          *ptr++ = c;
                          break;
                  }
          }
          *ptr++ = END;
          return (ptr - d);
  }
  
  int umn_send_packet(int fd, void *data, int len)
  {
    int actual, n;
  
    actual = slip_esc(data, buff, len);
    n = write(fd, buff, actual);
    if(n == actual) return(0);
    else return(1);
  }
  
  static void umn_read(int fd)
  {
    int i, n;
  
    n = read(fd, buff, sizeof(buff)/sizeof(buff[0]));
    if(n == 0) printk("umn_read hit EOF\n");
    else if(n < 0){
      if(errno == EIO){
        close(fd);
        return;
      }
      printk("umn_read had error, errno = %d\n", errno);
    }
    else {
      for(i=0;i<n;i++)
        slip_unesc(buff[i]);
    }
  }
  
  static int set_up_tty(int fd)
  {
      int i;
      struct termios tios;
  
      if (tcgetattr(fd, &tios) < 0) {
         printk("could not get initial terminal attributes\n");
         return(-1);
     }
 
     tios.c_cflag = CS8 | CREAD | HUPCL | CLOCAL;
     tios.c_iflag = IGNBRK | IGNPAR;
     tios.c_oflag = 0;
     tios.c_lflag = 0;
     for (i = 0; i < NCCS; i++)
         tios.c_cc[i] = 0;
     tios.c_cc[VMIN] = 1;
     tios.c_cc[VTIME] = 0;
 
     cfsetospeed(&tios, B38400);
     cfsetispeed(&tios, B38400);
 
     if (tcsetattr(fd, TCSAFLUSH, &tios) < 0) {
         printk("failed to set terminal attributes\n");
         return(-1);
     }
     return(0);
 }
 
 static int run_ifconfig(int (*proc)(void *), void *arg)
 {
   unsigned long stack;
   int pid, status;
 
   stack = alloc_stack();
   pid = clone(proc, (void *) stack_sp(stack), SIGCHLD, arg);
   if(pid < 0){
     printk("clone of ifconfig failed\n");
     return(-1);
   }
   pid = waitpid(pid, &status, 0);
   if(pid < 0){
     printk("wait for um_ifconfig failed\n");
     return(-1);
   }
   if(!WIFEXITED(status) || (WEXITSTATUS(status) != 0)){
     printk("um_ifconfig failed\n");
     return(-1);
   }
   free_stack(stack);
   return(0);
 }
 
 int open_umn_tty(int *orig_disc_out, int *slave_out, int *slipno_out)
 {
   struct statfs buf;
   int sfd, mfd, disc, sencap, n;
   char slip_name[sizeof("slxxxx")];
 
   if((mfd = open("/dev/ptmx", O_RDWR)) < 0){
     printk("Couldn't open tty for slip line\n");
     return(-1);
   }
   if(statfs(ptsname(mfd), &buf) < 0){
     printk("statfs failed\n");
     return(-1);
   }
   if(unlockpt(mfd) < 0){
     printk("Couldn't open tty for slip line\n");
     return(-1);
   }
   if((sfd = open(ptsname(mfd), O_RDWR)) < 0){
     printk("Couldn't open tty for slip line\n");
     return(-1);
   }
   if(set_up_tty(sfd)) return(-1);
   disc = N_SLIP;
   sencap = 0;
   if((ioctl(sfd, TIOCGETD, &orig_disc_out) < 0) ||
      ((n = ioctl(sfd, TIOCSETD, &disc)) < 0) ||
      (ioctl(sfd, SIOCSIFENCAP, &sencap) < 0)){
     printk("Couldn't set up slip\n");
     return(-1);
   }
   sprintf(slip_name, "sl%d", n);
   add_input_request(INPUT_NEW_FD, mfd, umn_read);
   *slave_out = sfd;
   *slipno_out = n;
   return(mfd);
 }
 
 static int ifconfig_addr_tramp(void *arg)
 {
   char *args[] = { "um_ifconfig", "-n", NULL, "192.168.0.254",
                    "pointopoint", NULL, NULL };
   char **more_args;
 
   more_args = arg;
   args[2] = more_args[0];
   args[5] = more_args[1];
   execvp("um_ifconfig", args);
   return(-1);
 }
 
 int set_umn_addr(int slipno, char *addr)
 {
   char slip_name[sizeof("slxxxx")], *args[2];
 
   sprintf(slip_name, "sl%d", slipno);
   args[0] = slip_name;
   args[1] = addr;
   return(run_ifconfig(ifconfig_addr_tramp, args));
 }
 
 void close_umn_tty(int master, int slave, int orig_disc)
 {
   ioctl(slave, TIOCSETD, &orig_disc);
   close(slave);
   close(master);
 }