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, void(*cb)(void*,char*,size_t),
  92                                    void *data, char *command, ...)
  93 {
  94         mconsole_request request;
  95         mconsole_reply reply;
  96         int len, flags = 0;
  97         va_list args;
  98
  99         memset(&request, 0, sizeof(request));
 100         request.magic = MCONSOLE_MAGIC;
 101         request.version = MCONSOLE_VERSION;
 102         va_start(args, command);
 103         request.len = vsnprintf(request.data, sizeof(request.data), command, args);
 104         va_end(args);
 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                 DBG1(DBG_LIB, "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                         DBG1(DBG_LIB, "receiving from mconsole failed: %m");
 140                         return -1;
 141                 }
 142                 if (len > 0)
 143                 {
 144                         if (cb)
 145                         {
 146                                 cb(data, reply.data, reply.len);
 147                         }
 148                         else if (reply.err)
 149                         {
 150                                 if (reply.len && *reply.data)
 151                                 {
 152                                         DBG1(DBG_LIB, "received mconsole error %d: %.*s",
 153                                                  reply.err, reply.len, reply.data);
 154                                 }
 155                                 break;
 156                         }
 157                 }
 158         }
 159         while (reply.more);
 160
 161         return reply.err;
 162 }
 163
 164 /**
 165  * ignore error message
 166  */
 167 static void ignore(void *data, char *buf, size_t len)
 168 {
 169 }
 170
 171 /**
 172  * Implementation of mconsole_t.add_iface.
 173  */
 174 static bool add_iface(private_mconsole_t *this, char *guest, char *host)
 175 {
 176         int tries = 0;
 177
 178         while (tries++ < 5)
 179         {
 180                 if (request(this, ignore, NULL, "config %s=tuntap,%s", guest, host) == 0)
 181                 {
 182                         return TRUE;
 183                 }
 184                 usleep(10000 * tries * tries);
 185         }
 186         return FALSE;
 187 }
 188
 189 /**
 190  * Implementation of mconsole_t.del_iface.
 191  */
 192 static bool del_iface(private_mconsole_t *this, char *guest)
 193 {
 194         if (request(this, NULL, NULL, "remove %s", guest) != 0)
 195         {
 196                 return FALSE;
 197         }
 198         return TRUE;
 199 }
 200
 201 /**
 202  * Implementation of mconsole_t.exec
 203  */
 204 static int exec(private_mconsole_t *this, void(*cb)(void*,char*,size_t),
 205                                 void *data, char *cmd)
 206 {
 207         return request(this, cb, data, "%s", cmd);
 208 }
 209
 210 /**
 211  * Poll until guest is ready
 212  */
 213 static void wait_bootup(private_mconsole_t *this)
 214 {
 215         /* wait for init process to appear */
 216         while (request(this, ignore, NULL, "exec ps -p 1 > /dev/null"))
 217         {
 218                 if (this->idle)
 219                 {
 220                         this->idle();
 221                 }
 222                 usleep(100000);
 223         }
 224 }
 225
 226 /**
 227  * Implementation of mconsole_t.destroy.
 228  */
 229 static void destroy(private_mconsole_t *this)
 230 {
 231         close(this->console);
 232         close(this->notify);
 233         free(this);
 234 }
 235
 236 /**
 237  * setup the mconsole notify connection and wait for its readiness
 238  */
 239 static bool wait_for_notify(private_mconsole_t *this, char *nsock)
 240 {
 241         struct sockaddr_un addr;
 242         mconsole_notify notify;
 243         int len, flags = 0;
 244
 245         this->notify = socket(AF_UNIX, SOCK_DGRAM, 0);
 246         if (this->notify < 0)
 247         {
 248                 DBG1(DBG_LIB, "opening mconsole notify socket failed: %m");
 249                 return FALSE;
 250         }
 251         memset(&addr, 0, sizeof(addr));
 252         addr.sun_family = AF_UNIX;
 253         strncpy(addr.sun_path, nsock, sizeof(addr.sun_path));
 254         if (bind(this->notify, (struct sockaddr*)&addr, sizeof(addr)) < 0)
 255         {
 256                 DBG1(DBG_LIB, "binding mconsole notify socket to '%s' failed: %m",
 257                          nsock);
 258                 close(this->notify);
 259                 return FALSE;
 260         }
 261         if (this->idle)
 262         {
 263                 flags = MSG_DONTWAIT;
 264         }
 265         do
 266         {
 267                 if (this->idle)
 268                 {
 269                         this->idle();
 270                 }
 271                 len = recvfrom(this->notify, &notify, sizeof(notify), flags, NULL, 0);
 272         }
 273         while (len < 0 && (errno == EINTR || errno == EAGAIN));
 274
 275         if (len < 0 || len >= sizeof(notify))
 276         {
 277                 DBG1(DBG_LIB, "reading from mconsole notify socket failed: %m");
 278                 close(this->notify);
 279                 unlink(nsock);
 280                 return FALSE;
 281         }
 282         if (notify.magic != MCONSOLE_MAGIC ||
 283                 notify.version != MCONSOLE_VERSION ||
 284                 notify.type != MCONSOLE_SOCKET)
 285         {
 286                 DBG1(DBG_LIB, "received unexpected message from mconsole notify"
 287                          " socket: %b", &notify, sizeof(notify));
 288                 close(this->notify);
 289                 unlink(nsock);
 290                 return FALSE;
 291         }
 292         memset(&this->uml, 0, sizeof(this->uml));
 293         this->uml.sun_family = AF_UNIX;
 294         strncpy(this->uml.sun_path, (char*)&notify.data, sizeof(this->uml.sun_path));
 295         return TRUE;
 296 }
 297
 298 /**
 299  * setup the mconsole console connection
 300  */
 301 static bool setup_console(private_mconsole_t *this)
 302 {
 303         struct sockaddr_un addr;
 304
 305         this->console = socket(AF_UNIX, SOCK_DGRAM, 0);
 306         if (this->console < 0)
 307         {
 308                 DBG1(DBG_LIB, "opening mconsole socket failed: %m");
 309                 return FALSE;
 310         }
 311         memset(&addr, 0, sizeof(addr));
 312         addr.sun_family = AF_UNIX;
 313         snprintf(&addr.sun_path[1], sizeof(addr.sun_path)-1, "%5d-%d",
 314                          getpid(), this->console);
 315         if (bind(this->console, (struct sockaddr*)&addr, sizeof(addr)) < 0)
 316         {
 317                 DBG1(DBG_LIB, "binding mconsole socket to '%s' failed: %m",
 318                          &addr.sun_path[1]);
 319                 close(this->console);
 320                 return FALSE;
 321         }
 322         return TRUE;
 323 }
 324
 325 /**
 326  * create the mconsole instance
 327  */
 328 mconsole_t *mconsole_create(char *notify, void(*idle)(void))
 329 {
 330         private_mconsole_t *this = malloc_thing(private_mconsole_t);
 331
 332         this->public.add_iface = (bool(*)(mconsole_t*, char *guest, char *host))add_iface;
 333         this->public.del_iface = (bool(*)(mconsole_t*, char *guest))del_iface;
 334         this->public.exec = (int(*)(mconsole_t*,  void(*cb)(void*,char*,size_t), void *data, char *cmd))exec;
 335         this->public.destroy = (void*)destroy;
 336
 337         this->idle = idle;
 338
 339         if (!wait_for_notify(this, notify))
 340         {
 341                 free(this);
 342                 return NULL;
 343         }
 344
 345         if (!setup_console(this))
 346         {
 347                 close(this->notify);
 348                 unlink(notify);
 349                 free(this);
 350                 return NULL;
 351         }
 352         unlink(notify);
 353
 354         wait_bootup(this);
 355
 356         return &this->public;
 357 }
 358