src/dumm/mconsole.c

   1 /*
   2  * Copyright (C) 2007 Martin Willi
   3  * Hochschule fuer Technik Rapperswil
   4  * Copyright (C) 2001-2004 Jeff Dike
   5  *
   6  * Based on the "uml_mconsole" utility from Jeff Dike.
   7  *
   8  * This program is free software; you can redistribute it and/or modify it
   9  * under the terms of the GNU General Public License as published by the
  10  * Free Software Foundation; either version 2 of the License, or (at your
  11  * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
  12  *
  13  * This program is distributed in the hope that it will be useful, but
  14  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  15  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16  * for more details.
  17  */
  18
  19 #define _GNU_SOURCE
  20
  21 #include <sys/types.h>
  22 #include <unistd.h>
  23 #include <stdio.h>
  24 #include <sys/socket.h>
  25 #include <errno.h>
  26 #include <sys/un.h>
  27
  28 #include <debug.h>
  29
  30 #include "mconsole.h"
  31
  32 #define MCONSOLE_MAGIC 0xcafebabe
  33 #define MCONSOLE_VERSION 2
  34 #define MCONSOLE_MAX_DATA 512
  35
  36 typedef struct private_mconsole_t private_mconsole_t;
  37
  38 struct private_mconsole_t {
  39         /** public interface */
  40         mconsole_t public;
  41         /** mconsole socket */
  42         int console;
  43         /** notify socket */
  44         int notify;
  45         /** address of uml socket */
  46         struct sockaddr_un uml;
  47         /** idle function */
  48         void (*idle)(void);
  49 };
  50
  51 /**
  52  * mconsole message format from "arch/um/include/mconsole.h"
  53  */
  54 typedef struct mconsole_request mconsole_request;
  55 /** mconsole request message */
  56 struct mconsole_request {
  57         u_int32_t magic;
  58         u_int32_t version;
  59         u_int32_t len;
  60         char data[MCONSOLE_MAX_DATA];
  61 };
  62
  63
  64 typedef struct mconsole_reply mconsole_reply;
  65 /** mconsole reply message */
  66 struct mconsole_reply {
  67         u_int32_t err;
  68         u_int32_t more;
  69         u_int32_t len;
  70         char data[MCONSOLE_MAX_DATA];
  71 };
  72
  73 typedef struct mconsole_notify mconsole_notify;
  74 /** mconsole notify message */
  75 struct mconsole_notify {
  76     u_int32_t magic;
  77     u_int32_t version;
  78     enum {
  79                 MCONSOLE_SOCKET,
  80                 MCONSOLE_PANIC,
  81                 MCONSOLE_HANG,
  82                 MCONSOLE_USER_NOTIFY,
  83     } type;
  84     u_int32_t len;
  85     char data[MCONSOLE_MAX_DATA];
  86 };
  87
  88 /**
  89  * send a request to UML using mconsole
  90  */
  91 static int request(private_mconsole_t *this, char *command,
  92                                    char buf[], size_t *size)
  93 {
  94         mconsole_request request;
  95         mconsole_reply reply;
  96         int len, total = 0, flags = 0;
  97
  98         memset(&request, 0, sizeof(request));
  99         request.magic = MCONSOLE_MAGIC;
 100         request.version = MCONSOLE_VERSION;
 101         request.len = min(strlen(command), sizeof(reply.data) - 1);
 102         strncpy(request.data, command, request.len);
 103         *buf = '\0';
 104         (*size)--;
 105
 106         if (this->idle)
 107         {
 108                 flags = MSG_DONTWAIT;
 109         }
 110         do
 111         {
 112                 if (this->idle)
 113                 {
 114                         this->idle();
 115                 }
 116                 len = sendto(this->console, &request, sizeof(request), flags,
 117                                          (struct sockaddr*)&this->uml, sizeof(this->uml));
 118         }
 119         while (len < 0 && (errno == EINTR || errno == EAGAIN));
 120
 121         if (len < 0)
 122         {
 123                 snprintf(buf, *size, "sending mconsole command to UML failed: %m");
 124                 return -1;
 125         }
 126         do
 127         {
 128                 len = recv(this->console, &reply, sizeof(reply), flags);
 129                 if (len < 0 && (errno == EINTR || errno == EAGAIN))
 130                 {
 131                         if (this->idle)
 132                         {
 133                                 this->idle();
 134                         }
 135                         continue;
 136                 }
 137                 if (len < 0)
 138                 {
 139                         snprintf(buf, *size, "receiving from mconsole failed: %m");
 140                         return -1;
 141                 }
 142                 if (len > 0)
 143                 {
 144                         strncat(buf, reply.data, min(reply.len, *size - total));
 145                         total += reply.len;
 146                 }
 147         }
 148         while (reply.more);
 149
 150         *size = total;
 151         return reply.err;
 152 }
 153
 154 /**
 155  * Implementation of mconsole_t.add_iface.
 156  */
 157 static bool add_iface(private_mconsole_t *this, char *guest, char *host)
 158 {
 159         char in[128], out[128];
 160         int len, tries = 0;
 161
 162         len = snprintf(in, sizeof(in), "config %s=tuntap,%s", guest, host);
 163         if (len < 0 || len >= sizeof(in))
 164         {
 165                 return FALSE;
 166         }
 167         while (tries++ < 10)
 168         {
 169                 len = sizeof(in);
 170                 if (request(this, in, out, &len) == 0)
 171                 {
 172                         return TRUE;
 173                 }
 174                 usleep(10000 * tries);
 175         }
 176         DBG1("adding interface failed: %.*s", len, out);
 177         return FALSE;
 178 }
 179
 180 /**
 181  * Implementation of mconsole_t.del_iface.
 182  */
 183 static bool del_iface(private_mconsole_t *this, char *guest)
 184 {
 185         char buf[128];
 186         int len;
 187
 188         len = snprintf(buf, sizeof(buf), "remove %s", guest);
 189         if (len < 0 || len >= sizeof(buf))
 190         {
 191                 return FALSE;
 192         }
 193         if (request(this, buf, buf, &len) != 0)
 194         {
 195                 return FALSE;
 196         }
 197         return TRUE;
 198 }
 199
 200 /**
 201  * Poll until guest is ready
 202  */
 203 static bool wait_bootup(private_mconsole_t *this)
 204 {
 205         char buf[128];
 206         int len, res;
 207
 208         while (TRUE)
 209         {
 210                 len = sizeof(buf);
 211                 res = request(this, "config eth9=mcast", buf, &len);
 212                 if (res < 0)
 213                 {
 214                         return FALSE;
 215                 }
 216                 if (res == 0)
 217                 {
 218                         while (request(this, "remove eth9", buf, &len) != 0)
 219                         {
 220                                 usleep(50000);
 221                         }
 222                         return TRUE;
 223                 }
 224                 if (this->idle)
 225                 {
 226                         this->idle();
 227                 }
 228                 else
 229                 {
 230                         usleep(50000);
 231                 }
 232         }
 233 }
 234
 235 /**
 236  * Implementation of mconsole_t.destroy.
 237  */
 238 static void destroy(private_mconsole_t *this)
 239 {
 240         close(this->console);
 241         close(this->notify);
 242         free(this);
 243 }
 244
 245 /**
 246  * setup the mconsole notify connection and wait for its readyness
 247  */
 248 static bool wait_for_notify(private_mconsole_t *this, char *nsock)
 249 {
 250         struct sockaddr_un addr;
 251         mconsole_notify notify;
 252         int len, flags = 0;
 253
 254         this->notify = socket(AF_UNIX, SOCK_DGRAM, 0);
 255         if (this->notify < 0)
 256         {
 257                 DBG1("opening mconsole notify socket failed: %m");
 258                 return FALSE;
 259         }
 260         memset(&addr, 0, sizeof(addr));
 261         addr.sun_family = AF_UNIX;
 262         strncpy(addr.sun_path, nsock, sizeof(addr));
 263         if (bind(this->notify, (struct sockaddr*)&addr, sizeof(addr)) < 0)
 264         {
 265                 DBG1("binding mconsole notify socket to '%s' failed: %m", nsock);
 266                 close(this->notify);
 267                 return FALSE;
 268         }
 269         if (this->idle)
 270         {
 271                 flags = MSG_DONTWAIT;
 272         }
 273         do
 274         {
 275                 if (this->idle)
 276                 {
 277                         this->idle();
 278                 }
 279                 len = recvfrom(this->notify, &notify, sizeof(notify), flags, NULL, 0);
 280         }
 281         while (len < 0 && (errno == EINTR || errno == EAGAIN));
 282
 283         if (len < 0 || len >= sizeof(notify))
 284         {
 285                 DBG1("reading from mconsole notify socket failed: %m");
 286                 close(this->notify);
 287                 unlink(nsock);
 288                 return FALSE;
 289         }
 290         if (notify.magic != MCONSOLE_MAGIC ||
 291                 notify.version != MCONSOLE_VERSION ||
 292                 notify.type != MCONSOLE_SOCKET)
 293         {
 294                 DBG1("received unexpected message from mconsole notify socket: %b",
 295                          &notify, sizeof(notify));
 296                 close(this->notify);
 297                 unlink(nsock);
 298                 return FALSE;
 299         }
 300         memset(&this->uml, 0, sizeof(this->uml));
 301         this->uml.sun_family = AF_UNIX;
 302         strncpy(this->uml.sun_path, (char*)&notify.data, sizeof(this->uml.sun_path));
 303         return TRUE;
 304 }
 305
 306 /**
 307  * setup the mconsole console connection
 308  */
 309 static bool setup_console(private_mconsole_t *this)
 310 {
 311         struct sockaddr_un addr;
 312
 313         this->console = socket(AF_UNIX, SOCK_DGRAM, 0);
 314         if (this->console < 0)
 315         {
 316                 DBG1("opening mconsole socket failed: %m");
 317                 return FALSE;
 318         }
 319         memset(&addr, 0, sizeof(addr));
 320         addr.sun_family = AF_UNIX;
 321         snprintf(&addr.sun_path[1], sizeof(addr.sun_path), "%5d-%d",
 322                          getpid(), this->console);
 323         if (bind(this->console, (struct sockaddr*)&addr, sizeof(addr)) < 0)
 324         {
 325                 DBG1("binding mconsole socket to '%s' failed: %m", &addr.sun_path[1]);
 326                 close(this->console);
 327                 return FALSE;
 328         }
 329         return TRUE;
 330 }
 331
 332 /**
 333  * create the mconsole instance
 334  */
 335 mconsole_t *mconsole_create(char *notify, void(*idle)(void))
 336 {
 337         private_mconsole_t *this = malloc_thing(private_mconsole_t);
 338
 339         this->public.add_iface = (bool(*)(mconsole_t*, char *guest, char *host))add_iface;
 340         this->public.del_iface = (bool(*)(mconsole_t*, char *guest))del_iface;
 341         this->public.destroy = (void*)destroy;
 342
 343         this->idle = idle;
 344
 345         if (!wait_for_notify(this, notify))
 346         {
 347                 free(this);
 348                 return NULL;
 349         }
 350
 351         if (!setup_console(this))
 352         {
 353                 close(this->notify);
 354                 unlink(notify);
 355                 free(this);
 356                 return NULL;
 357         }
 358         unlink(notify);
 359
 360         if (!wait_bootup(this))
 361         {
 362                 destroy(this);
 363                 return NULL;
 364         }
 365
 366         return &this->public;
 367 }
 368