vde-2/datasock.c

   1 /* Copyright 2005 Renzo Davoli - VDE-2
   2  * --pidfile/-p and cleanup management by Mattia Belletti (C) 2004.
   3  * Licensed under the GPLv2
   4  * Modified by Ludovico Gardenghi 2005
   5  * -g option (group management) by Daniel P. Berrange
   6  * dir permission patch by Alessio Caprari 2006
   7  */
   8
   9 #include <config.h>
  10 #include <stdio.h>
  11 #include <fcntl.h>
  12 #include <errno.h>
  13 #include <string.h>
  14 #include <unistd.h>
  15 #include <syslog.h>
  16 #include <stdlib.h>
  17 #include <stdint.h>
  18 #include <libgen.h>
  19 #include <sys/types.h>
  20 #include <sys/stat.h>
  21 #include <sys/ioctl.h>
  22 #include <sys/socket.h>
  23 #include <sys/types.h>
  24 #include <sys/un.h>
  25 #include <net/if.h>
  26 #include <stdarg.h>
  27 #include <grp.h>
  28 #define _GNU_SOURCE
  29 #include <getopt.h>
  30
  31 //#include <linux/if_tun.h>
  32
  33 #include <port.h>
  34 #include <switch.h>
  35 #include <vde.h>
  36 #include <sockutils.h>
  37 #include <consmgmt.h>
  38
  39 static struct swmodule swmi;
  40 static struct mod_support modfun;
  41 static unsigned int ctl_type;
  42 static unsigned int wd_type;
  43 static unsigned int data_type;
  44 static int mode = 0700;
  45
  46 static char *ctl_socket;
  47 static gid_t grp_owner = -1;
  48
  49 #define MODULENAME "unix prog"
  50
  51 #define DATA_BUF_SIZE 131072
  52 #define SWITCH_MAGIC 0xfeedface
  53 #define REQBUFLEN 256
  54
  55 enum request_type { REQ_NEW_CONTROL, REQ_NEW_PORT0 };
  56
  57 struct request_v1 {
  58         uint32_t magic;
  59         enum request_type type;
  60         union {
  61                 struct {
  62                         unsigned char addr[ETH_ALEN];
  63                         struct sockaddr_un name;
  64                 } new_control;
  65         } u;
  66         char description[];
  67 };
  68
  69 struct request_v3 {
  70         uint32_t magic;
  71         uint32_t version;
  72         enum request_type type;
  73         struct sockaddr_un sock;
  74         char description[];
  75 };
  76
  77 union request {
  78         struct request_v1 v1;
  79         struct request_v3 v3;
  80 };
  81
  82 static int send_datasock(int fd, int ctl_fd, void *packet, int len, void *data, int port)
  83 {
  84         int n;
  85         struct sockaddr *dst=(struct sockaddr *)data;
  86
  87         n = len - sendto(fd, packet, len, 0, dst, sizeof(struct sockaddr_un));
  88         if(n){
  89                 int rv=errno;
  90 #ifndef VDE_PQ
  91                 if(errno != EAGAIN) printlog(LOG_WARNING,"send_sockaddr port %d: %s",port,strerror(errno));
  92 #endif
  93                 if (n>len)
  94                         return -rv;
  95                 else
  96                         return n;
  97         }
  98         return 0;
  99 }
 100
 101 static void closeport(int fd, int portno)
 102 {
 103         if (fd>0)
 104                 remove_fd(fd);
 105 }
 106
 107 static int newport(int fd, int portno)
 108 {
 109         int data_fd;
 110         struct sockaddr_un sun;
 111 #ifdef VDE_DARWIN
 112         int sockbufsize = DATA_BUF_SIZE;
 113         int optsize = sizeof(sockbufsize);
 114 #endif
 115
 116         if((data_fd = socket(PF_UNIX, SOCK_DGRAM, 0)) < 0){
 117                 printlog(LOG_ERR,"socket: %s",strerror(errno));
 118                 return -1;
 119         }
 120         if(fcntl(data_fd, F_SETFL, O_NONBLOCK) < 0){
 121                 printlog(LOG_ERR,"Setting O_NONBLOCK on data fd %s",strerror(errno));
 122                 return -1;
 123         }
 124
 125 #ifdef VDE_DARWIN
 126         if(setsockopt(data_fd, SOL_SOCKET, SO_SNDBUF, &sockbufsize, optsize) < 0)
 127                 printlog(LOG_WARNING, "Warning: setting send buffer size on data fd %d to %d failed, expect packet loss: %s",
 128                                 data_fd, sockbufsize, strerror(errno));
 129         if(setsockopt(data_fd, SOL_SOCKET, SO_RCVBUF, &sockbufsize, optsize) < 0)
 130                 printlog(LOG_WARNING, "Warning: setting send buffer size on data fd %d to %d failed, expect packet loss: %s",
 131                                 data_fd, sockbufsize, strerror(errno));
 132 #endif
 133
 134         sun.sun_family = AF_UNIX;
 135         snprintf(sun.sun_path,sizeof(sun.sun_path),"%s/%03d",ctl_socket,portno);
 136         if ((unlink(sun.sun_path) < 0 && errno != ENOENT) ||
 137                         bind(data_fd, (struct sockaddr *) &sun, sizeof(sun)) < 0){
 138                 printlog(LOG_ERR,"Binding to data socket %s",strerror(errno));
 139                 close_ep(portno-1,fd);
 140                 return -1;
 141         }
 142         chmod(sun.sun_path,mode);
 143         if(chown(sun.sun_path,-1,grp_owner) < 0) {
 144                 printlog(LOG_ERR, "chown: %s", strerror(errno));
 145                 close_ep(portno-1,fd);
 146                 return -1;
 147         }
 148
 149         add_fd(data_fd,data_type,portno);
 150
 151         return data_fd;
 152 }
 153
 154 static void *memdup(void *src,int size)
 155 {
 156         void *dst=malloc(size);
 157         if (dst != NULL)
 158                 memcpy(dst,src,size);
 159         return dst;
 160 }
 161
 162 #define GETFILEOWNER(PATH) ({\
 163                 struct stat s; \
 164                 (stat((PATH),&s)?-1:s.st_uid); \
 165                 })
 166
 167 static int checksockperm(char *path,char *lpath)
 168 {
 169         int rvuid=0;
 170         if (access(path,R_OK | W_OK) != 0)
 171                 return -1;
 172         if (geteuid() == 0) { /* switch run by root */
 173                 int luid;
 174                 if ((rvuid=GETFILEOWNER(path)) < 0)
 175                         return -1;
 176                 luid=GETFILEOWNER(lpath);
 177                 if (luid > 0 && luid != rvuid) {
 178                         errno=EADDRINUSE;
 179                         return -1;
 180                 }
 181         }
 182         return rvuid;
 183 }
 184
 185 static int new_port_v1_v3(int fd, int type_port,
 186                 struct sockaddr_un *sun_out)
 187 {
 188         int n, port;
 189         enum request_type type = type_port & 0xff;
 190         int port_request=type_port >> 8;
 191         int cluid=-1;
 192         struct sockaddr_un sun_in;
 193         switch(type){
 194                 case REQ_NEW_PORT0:
 195                         port_request= -1;
 196                         /* no break: falltrough */
 197                 case REQ_NEW_CONTROL:
 198                         port = setup_ep(port_request, fd, memdup(sun_out,sizeof(struct sockaddr_un)), &modfun);
 199                         if(port<0) {
 200                                 remove_fd(fd);
 201                                 return -1;
 202                         }
 203                         sun_in.sun_family = AF_UNIX;
 204                         snprintf(sun_in.sun_path,sizeof(sun_in.sun_path),"%s/%03d",ctl_socket,port);
 205                         if (sun_out->sun_path[0] != 0) { //not for unnamed sockets
 206                                 if ((cluid=checksockperm(sun_out->sun_path,sun_in.sun_path)) < 0) {
 207                                         printlog(LOG_WARNING,"Data_out socket permission: %s",strerror(errno));
 208                                         close_ep(port,fd);
 209                                         return -1;
 210                                 }
 211                         }
 212                         n = write(fd, &sun_in, sizeof(sun_in));
 213                         if(n != sizeof(sun_in)){
 214                                 printlog(LOG_WARNING,"Sending data socket name %s",strerror(errno));
 215                                 close_ep(port,fd);
 216                                 return -1;
 217                         }
 218                         if (type==REQ_NEW_PORT0)
 219                                 setmgmtperm(sun_in.sun_path);
 220                         else if (cluid > 0) {
 221                                 chown(sun_in.sun_path,cluid,-1);
 222                                 chmod(sun_in.sun_path,mode & 0700);
 223                         }
 224                         return port;
 225                         break;
 226                 default:
 227                         printlog(LOG_WARNING,"Bad request type : %d", type);
 228                         remove_fd(fd);
 229                         return -1;
 230         }
 231 }
 232
 233 static void handle_input(unsigned char type,int fd,int revents,int *arg)
 234 {
 235         if (type == data_type) {
 236                 struct bipacket packet;
 237                 struct sockaddr sock;
 238                 int len;
 239                 socklen_t socklen = sizeof(sock);
 240
 241                 len=recvfrom(fd, &(packet.p), sizeof(struct packet),0, &sock, &socklen);
 242                 if(len < 0){
 243                         if (errno == EAGAIN) return;
 244                         printlog(LOG_WARNING,"Reading  data: %s",strerror(errno));
 245                 }
 246                 else if(len == 0)
 247                         printlog(LOG_WARNING,"EOF data port: %s",strerror(errno));
 248                 else if(len >= ETH_HEADER_SIZE)
 249                         handle_in_packet(*arg, &(packet.p), len);
 250         }
 251         else if (type == wd_type) {
 252                 char reqbuf[REQBUFLEN+1];
 253                 union request *req=(union request *)reqbuf;
 254                 int len;
 255
 256                 len = read(fd, reqbuf, REQBUFLEN);
 257                 if (len < 0) {
 258                         if(errno != EAGAIN){
 259                                 printlog(LOG_WARNING,"Reading request %s", strerror(errno));
 260                                 remove_fd(fd);
 261                         }
 262                         return;
 263                 } else if (len > 0) {
 264                         reqbuf[len]=0;
 265                         if(req->v1.magic == SWITCH_MAGIC){
 266                                 int port=-1;
 267                                 if(req->v3.version == 3) {
 268                                         *arg=port=new_port_v1_v3(fd, req->v3.type, &(req->v3.sock));
 269                                         setup_description(*arg,fd,strdup(req->v3.description));
 270                                 }
 271                                 else if(req->v3.version > 2 || req->v3.version == 2) {
 272                                         printlog(LOG_ERR, "Request for a version %d port, which this "
 273                                                         "vde_switch doesn't support", req->v3.version);
 274                                         remove_fd(fd);
 275                                 }
 276                                 else {
 277                                         *arg=port=new_port_v1_v3(fd, req->v1.type, &(req->v1.u.new_control.name));
 278                                         setup_description(*arg,fd,strdup(req->v1.description));
 279                                 }
 280                         }
 281                         else {
 282                                 printlog(LOG_WARNING,"V0 request not supported");
 283                                 remove_fd(fd);
 284                                 return;
 285                         }
 286                 } else {
 287                         close_ep(*arg,fd);
 288                 }
 289         }
 290         else /*if (type == ctl_type)*/ {
 291                 struct sockaddr addr;
 292                 socklen_t len;
 293                 int new;
 294
 295                 len = sizeof(addr);
 296                 new = accept(fd, &addr, &len);
 297                 if(new < 0){
 298                         printlog(LOG_WARNING,"accept %s",strerror(errno));
 299                         return;
 300                 }
 301                 if(fcntl(new, F_SETFL, O_NONBLOCK) < 0){
 302                         printlog(LOG_WARNING,"fcntl - setting O_NONBLOCK %s",strerror(errno));
 303                         close(new);
 304                         return;
 305                 }
 306
 307                 add_fd(new,wd_type,-1);
 308         }
 309 }
 310
 311 static void cleanup(unsigned char type,int fd,int arg)
 312 {
 313         struct sockaddr_un clun;
 314         if (fd < 0) {
 315                 snprintf(clun.sun_path,sizeof(clun.sun_path),"%s/ctl",ctl_socket);
 316                 if(unlink(clun.sun_path) < 0)
 317                         printlog(LOG_WARNING,"Couldn't remove ctl socket '%s' : %s", ctl_socket, strerror(errno));
 318                 else if(rmdir(ctl_socket) < 0)
 319                         printlog(LOG_WARNING,"Couldn't remove ctl dir '%s' : %s", ctl_socket, strerror(errno));
 320         } else {
 321                 if (type == data_type && arg>=0) {
 322                         snprintf(clun.sun_path,sizeof(clun.sun_path),"%s/%03d",ctl_socket,arg);
 323                         unlink(clun.sun_path);
 324                 }
 325                 close(fd);
 326         }
 327 }
 328
 329 static struct option long_options[] = {
 330         {"sock", 1, 0, 's'},
 331         {"vdesock", 1, 0, 's'},
 332         {"unix", 1, 0, 's'},
 333         {"mod", 1, 0, 'm'},
 334         {"group", 1, 0, 'g'},
 335 };
 336
 337 #define Nlong_options (sizeof(long_options)/sizeof(struct option));
 338
 339 static void usage(void)
 340 {
 341         printf(
 342                         "(opts from datasock module)\n"
 343                         "  -s, --sock SOCK            control directory pathname\n"
 344                         "  -s, --vdesock SOCK         Same as --sock SOCK\n"
 345                         "  -s, --unix SOCK            Same as --sock SOCK\n"
 346                         "  -m, --mod MODE             Standard access mode for comm sockets (octal)\n"
 347                         "  -g, --group GROUP          Group owner for comm sockets\n"
 348                         );
 349 }
 350
 351 static int parseopt(int c, char *optarg)
 352 {
 353         int outc=0;
 354         struct group *grp;
 355         switch (c) {
 356                 case 's':
 357                         ctl_socket=strdup(optarg);
 358                         break;
 359                 case 'm':
 360                         sscanf(optarg,"%o",&mode);
 361                         break;
 362                 case 'g':
 363                         if (!(grp = getgrnam(optarg))) {
 364                                 fprintf(stderr, "No such group '%s'\n", optarg);
 365                                 exit(1);
 366                         }
 367                         grp_owner=grp->gr_gid;
 368                         break;
 369                 default:
 370                         outc=c;
 371         }
 372         return outc;
 373 }
 374
 375 static void init(void)
 376 {
 377         int connect_fd;
 378         struct sockaddr_un sun;
 379         int one = 1;
 380
 381         if((connect_fd = socket(PF_UNIX, SOCK_STREAM, 0)) < 0){
 382                 printlog(LOG_ERR,"socket: %s",strerror(errno));
 383                 return;
 384         }
 385         if(setsockopt(connect_fd, SOL_SOCKET, SO_REUSEADDR, (char *) &one,
 386                                 sizeof(one)) < 0){
 387                 printlog(LOG_ERR,"setsockopt: %s",strerror(errno));
 388                 return;
 389         }
 390         if(fcntl(connect_fd, F_SETFL, O_NONBLOCK) < 0){
 391                 printlog(LOG_ERR,"Setting O_NONBLOCK on connection fd: %s",strerror(errno));
 392                 return;
 393         }
 394         if (mkdir(ctl_socket, (mode & 0700 ? 0700 : 0) |
 395                                 (mode & 0070 ? 0050 : 0) | (mode & 0007 ? 0005 : 0)) < 0) {
 396                 printlog(LOG_ERR,"creating vde ctl dir: %s",strerror(errno));
 397                 return;
 398         }
 399         sun.sun_family = AF_UNIX;
 400         snprintf(sun.sun_path,sizeof(sun.sun_path),"%s/ctl",ctl_socket);
 401         if(bind(connect_fd, (struct sockaddr *) &sun, sizeof(sun)) < 0){
 402                 if((errno == EADDRINUSE) && still_used(&sun)) return;
 403                 else if(bind(connect_fd, (struct sockaddr *) &sun, sizeof(sun)) < 0){
 404                         printlog(LOG_ERR,"bind %s",strerror(errno));
 405                         return;
 406                 }
 407         }
 408         chmod(sun.sun_path,mode);
 409         if(chown(sun.sun_path,-1,grp_owner) < 0) {
 410                 printlog(LOG_ERR, "chown: %s", strerror(errno));
 411                 return;
 412         }
 413         if(listen(connect_fd, 15) < 0){
 414                 printlog(LOG_ERR,"listen: %s",strerror(errno));
 415                 return;
 416         }
 417         ctl_type=add_type(&swmi,0);
 418         wd_type=add_type(&swmi,0);
 419         data_type=add_type(&swmi,1);
 420         add_fd(connect_fd,ctl_type,-1);
 421 }
 422
 423 static int showinfo(int fd)
 424 {
 425         printoutc(fd,"ctl dir %s",ctl_socket);
 426         printoutc(fd,"std mode 0%03o",mode);
 427         return 0;
 428 }
 429
 430 static struct comlist cl[]={
 431         {"ds","============","DATA SOCKET MENU",NULL,NOARG},
 432         {"ds/showinfo","","show ds info",showinfo,NOARG|WITHFD},
 433 };
 434
 435 static void delep (int fd, void* data, void *descr)
 436 {
 437         if (fd>=0) remove_fd(fd);
 438         if (data) free(data);
 439         if (descr) free(descr);
 440 }
 441
 442 void start_datasock(void)
 443 {
 444         ctl_socket = (geteuid()==0)?VDESTDSOCK:VDETMPSOCK;
 445         modfun.modname=swmi.swmname=MODULENAME;
 446         swmi.swmnopts=Nlong_options;
 447         swmi.swmopts=long_options;
 448         swmi.usage=usage;
 449         swmi.parseopt=parseopt;
 450         swmi.init=init;
 451         swmi.handle_input=handle_input;
 452         swmi.cleanup=cleanup;
 453         modfun.sender=send_datasock;
 454         modfun.newport=newport;
 455         modfun.delep=delep;
 456         modfun.delport=closeport;
 457         ADDCL(cl);
 458         add_swm(&swmi);
 459 }