arch/um/drivers/slirp_user.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <unistd.h>
   4 #include <stddef.h>
   5 #include <sched.h>
   6 #include <string.h>
   7 #include <sys/fcntl.h>
   8 #include <sys/errno.h>
   9 #include <sys/wait.h>
  10 #include <sys/signal.h>
  11 #include "user_util.h"
  12 #include "kern_util.h"
  13 #include "user.h"
  14 #include "net_user.h"
  15 #include "slirp.h"
  16 #include "slip_proto.h"
  17 #include "helper.h"
  18 #include "os.h"
  19
  20 void slirp_user_init(void *data, void *dev)
  21 {
  22         struct slirp_data *pri = data;
  23
  24         pri->dev = dev;
  25 }
  26
  27 struct slirp_pre_exec_data {
  28         int stdin;
  29         int stdout;
  30 };
  31
  32 static void slirp_pre_exec(void *arg)
  33 {
  34         struct slirp_pre_exec_data *data = arg;
  35
  36         if(data->stdin != -1) dup2(data->stdin, 0);
  37         if(data->stdout != -1) dup2(data->stdout, 1);
  38 }
  39
  40 static int slirp_tramp(char **argv, int fd)
  41 {
  42         struct slirp_pre_exec_data pe_data;
  43         int pid;
  44
  45         pe_data.stdin = fd;
  46         pe_data.stdout = fd;
  47         pid = run_helper(slirp_pre_exec, &pe_data, argv, NULL);
  48
  49         return(pid);
  50 }
  51
  52 static int slirp_datachan(int *mfd, int *sfd)
  53 {
  54         int fds[2], err;
  55
  56         err = os_pipe(fds, 1, 1);
  57         if(err){
  58                 printk("slirp_datachan: Failed to open pipe, errno = %d\n",
  59                        -err);
  60                 return(err);
  61         }
  62
  63         *mfd = fds[0];
  64         *sfd = fds[1];
  65         return(0);
  66 }
  67
  68 static int slirp_open(void *data)
  69 {
  70         struct slirp_data *pri = data;
  71         int sfd, mfd, pid, err;
  72
  73         err = slirp_datachan(&mfd, &sfd);
  74         if(err)
  75                 return(err);
  76
  77         pid = slirp_tramp(pri->argw.argv, sfd);
  78
  79         if(pid < 0){
  80                 printk("slirp_tramp failed - errno = %d\n", pid);
  81                 os_close_file(sfd);
  82                 os_close_file(mfd);
  83                 return(pid);
  84         }
  85
  86         pri->slave = sfd;
  87         pri->pos = 0;
  88         pri->esc = 0;
  89
  90         pri->pid = pid;
  91
  92         return(mfd);
  93 }
  94
  95 static void slirp_close(int fd, void *data)
  96 {
  97         struct slirp_data *pri = data;
  98         int status,err;
  99
 100         close(fd);
 101         close(pri->slave);
 102
 103         pri->slave = -1;
 104
 105         if(pri->pid<1) {
 106                 printk("slirp_close: no child process to shut down\n");
 107                 return;
 108         }
 109
 110 #if 0
 111         if(kill(pri->pid, SIGHUP)<0) {
 112                 printk("slirp_close: sending hangup to %d failed (%d)\n",
 113                         pri->pid, errno);
 114         }
 115 #endif
 116
 117         err = waitpid(pri->pid, &status, WNOHANG);
 118         if(err<0) {
 119                 printk("slirp_close: waitpid returned %d\n", errno);
 120                 return;
 121         }
 122
 123         if(err==0) {
 124                 printk("slirp_close: process %d has not exited\n");
 125                 return;
 126         }
 127
 128         pri->pid = -1;
 129 }
 130
 131 int slirp_user_read(int fd, void *buf, int len, struct slirp_data *pri)
 132 {
 133         int i, n, size, start;
 134
 135         if(pri->more>0) {
 136                 i = 0;
 137                 while(i < pri->more) {
 138                         size = slip_unesc(pri->ibuf[i++],
 139                                         pri->ibuf,&pri->pos,&pri->esc);
 140                         if(size){
 141                                 memcpy(buf, pri->ibuf, size);
 142                                 memmove(pri->ibuf, &pri->ibuf[i], pri->more-i);
 143                                 pri->more=pri->more-i;
 144                                 return(size);
 145                         }
 146                 }
 147                 pri->more=0;
 148         }
 149
 150         n = net_read(fd, &pri->ibuf[pri->pos], sizeof(pri->ibuf) - pri->pos);
 151         if(n <= 0) return(n);
 152
 153         start = pri->pos;
 154         for(i = 0; i < n; i++){
 155                 size = slip_unesc(pri->ibuf[start + i],
 156                                 pri->ibuf,&pri->pos,&pri->esc);
 157                 if(size){
 158                         memcpy(buf, pri->ibuf, size);
 159                         memmove(pri->ibuf, &pri->ibuf[start+i+1], n-(i+1));
 160                         pri->more=n-(i+1);
 161                         return(size);
 162                 }
 163         }
 164         return(0);
 165 }
 166
 167 int slirp_user_write(int fd, void *buf, int len, struct slirp_data *pri)
 168 {
 169         int actual, n;
 170
 171         actual = slip_esc(buf, pri->obuf, len);
 172         n = net_write(fd, pri->obuf, actual);
 173         if(n < 0) return(n);
 174         else return(len);
 175 }
 176
 177 static int slirp_set_mtu(int mtu, void *data)
 178 {
 179         return(mtu);
 180 }
 181
 182 struct net_user_info slirp_user_info = {
 183         .init           = slirp_user_init,
 184         .open           = slirp_open,
 185         .close          = slirp_close,
 186         .remove         = NULL,
 187         .set_mtu        = slirp_set_mtu,
 188         .add_address    = NULL,
 189         .delete_address = NULL,
 190         .max_packet     = BUF_SIZE
 191 };
 192
 193 /*
 194  * Overrides for Emacs so that we follow Linus's tabbing style.
 195  * Emacs will notice this stuff at the end of the file and automatically
 196  * adjust the settings for this buffer only.  This must remain at the end
 197  * of the file.
 198  * ---------------------------------------------------------------------------
 199  * Local variables:
 200  * c-file-style: "linux"
 201  * End:
 202  */