src/lxc/lxc_start.c

   1 /*
   2  * lxc: linux Container library
   3  *
   4  * (C) Copyright IBM Corp. 2007, 2008
   5  *
   6  * Authors:
   7  * Daniel Lezcano <dlezcano at fr.ibm.com>
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  22  */
  23 #define _GNU_SOURCE
  24 #include <stdio.h>
  25 #undef _GNU_SOURCE
  26 #include <libgen.h>
  27 #include <stdlib.h>
  28 #include <unistd.h>
  29 #include <string.h>
  30 #include <termios.h>
  31 #include <errno.h>
  32 #include <fcntl.h>
  33 #include <signal.h>
  34 #include <sys/param.h>
  35 #include <sys/utsname.h>
  36 #include <sys/types.h>
  37 #include <sys/socket.h>
  38 #include <sys/stat.h>
  39 #include <arpa/inet.h>
  40 #include <netinet/in.h>
  41 #include <net/if.h>
  42
  43 #include "log.h"
  44 #include "lxc.h"
  45 #include "conf.h"
  46 #include "utils.h"
  47 #include "config.h"
  48 #include "confile.h"
  49 #include "arguments.h"
  50
  51 lxc_log_define(lxc_start, lxc);
  52
  53 static int my_parser(struct lxc_arguments* args, int c, char* arg)
  54 {
  55         switch (c) {
  56         case 'd': args->daemonize = 1; break;
  57         case 'f': args->rcfile = arg; break;
  58         }
  59         return 0;
  60 }
  61
  62 static const struct option my_longopts[] = {
  63         {"daemon", no_argument, 0, 'd'},
  64         {"rcfile", required_argument, 0, 'f'},
  65         LXC_COMMON_OPTIONS
  66 };
  67
  68 static struct lxc_arguments my_args = {
  69         .progname = "lxc-start",
  70         .help     = "\
  71 --name=NAME -- COMMAND\n\
  72 \n\
  73 lxc-start start COMMAND in specified container NAME\n\
  74 \n\
  75 Options :\n\
  76   -n, --name=NAME      NAME for name of the container\n\
  77   -d, --daemon         daemonize the container\n\
  78   -f, --rcfile=FILE    Load configuration file FILE\n",
  79         .options   = my_longopts,
  80         .parser    = my_parser,
  81         .checker   = NULL,
  82         .daemonize = 0,
  83 };
  84
  85 static int save_tty(struct termios *tios)
  86 {
  87         if (!isatty(0))
  88                 return 0;
  89
  90         if (tcgetattr(0, tios))
  91                 WARN("failed to get current terminal settings : %s",
  92                      strerror(errno));
  93
  94         return 0;
  95 }
  96
  97 static int restore_tty(struct termios *tios)
  98 {
  99         struct termios current_tios;
 100         void (*oldhandler)(int);
 101         int ret;
 102
 103         if (!isatty(0))
 104                 return 0;
 105
 106         if (tcgetattr(0, &current_tios)) {
 107                 ERROR("failed to get current terminal settings : %s",
 108                       strerror(errno));
 109                 return -1;
 110         }
 111
 112         if (!memcmp(tios, &current_tios, sizeof(*tios)))
 113                 return 0;
 114
 115         oldhandler = signal(SIGTTOU, SIG_IGN);
 116         ret = tcsetattr(0, TCSADRAIN, tios);
 117         if (ret)
 118                 ERROR("failed to restore terminal attributes");
 119         signal(SIGTTOU, oldhandler);
 120
 121         return ret;
 122 }
 123
 124 int main(int argc, char *argv[])
 125 {
 126         char *const *args;
 127         int err = -1;
 128         struct termios tios;
 129
 130         char *const default_args[] = {
 131                 "/sbin/init",
 132                 '\0',
 133         };
 134
 135         char *rcfile = NULL;
 136         struct lxc_conf *conf;
 137
 138         if (lxc_arguments_parse(&my_args, argc, argv))
 139                 return err;
 140
 141         if (!my_args.argc)
 142                 args = default_args;
 143         else
 144                 args = my_args.argv;
 145
 146         if (lxc_log_init(my_args.log_file, my_args.log_priority,
 147                          my_args.progname, my_args.quiet))
 148                 return err;
 149
 150         /* rcfile is specified in the cli option */
 151         if (my_args.rcfile)
 152                 rcfile = (char *)my_args.rcfile;
 153         else {
 154                 if (!asprintf(&rcfile, LXCPATH "/%s/config", my_args.name)) {
 155                         SYSERROR("failed to allocate memory");
 156                         return err;
 157                 }
 158
 159                 /* container configuration does not exist */
 160                 if (access(rcfile, F_OK)) {
 161                         free(rcfile);
 162                         rcfile = NULL;
 163                 }
 164         }
 165
 166         conf = lxc_conf_init();
 167         if (!conf) {
 168                 ERROR("failed to initialize configuration");
 169                 return err;
 170         }
 171
 172         if (rcfile && lxc_config_read(rcfile, conf)) {
 173                 ERROR("failed to read configuration file");
 174                 return err;
 175         }
 176
 177         if (!rcfile && !strcmp("/sbin/init", args[0])) {
 178                 ERROR("no configuration file for '/sbin/init' (may crash the host)");
 179                 return err;
 180         }
 181
 182         if (my_args.daemonize) {
 183
 184                 /* do not chdir as we want to open the log file,
 185                  * change the directory right after.
 186                  * do not close 0, 1, 2, we want to do that
 187                  * ourself because we don't want /dev/null
 188                  * being reopened.
 189                  */
 190                 if (daemon(1, 1)) {
 191                         SYSERROR("failed to daemonize '%s'", my_args.name);
 192                         return err;
 193                 }
 194
 195                 lxc_close_inherited_fd(0);
 196                 lxc_close_inherited_fd(1);
 197                 lxc_close_inherited_fd(2);
 198
 199                 if (my_args.log_file) {
 200                         open(my_args.log_file, O_WRONLY | O_CLOEXEC);
 201                         open(my_args.log_file, O_RDONLY | O_CLOEXEC);
 202                         open(my_args.log_file, O_RDONLY | O_CLOEXEC);
 203                 }
 204         }
 205
 206         save_tty(&tios);
 207
 208         err = lxc_start(my_args.name, args, conf);
 209
 210         restore_tty(&tios);
 211
 212         return err;
 213 }
 214