1 #include <stdlib.h>

     2 #include <unistd.h>

     3 #include <sys/types.h>

     4 #include <stdio.h>

     5 #include <string.h>

     6 #include <err.h>

     7 #include <ctype.h>

     8 #include <pwd.h>

     9 #include <errno.h>

    10 

    11 #ifndef XMSH_PATH

    12 #error must define XMSH_PATH

    13 #endif

    14 

    15 #define STRINGIFY(x) XSTRINGIFY(x)

    16 #define XSTRINGIFY(x) #x

    17 

    18 #define USERNAME_MAX 64

    19 #define VMNAME_MAX 64

    20 

    21 #define USERFILE_PATH_FMT (STRINGIFY(XMSH_PATH) "/users/%s")

    22 #define USERFILE_PATH_MAX 64 + USERNAME_MAX

    23 

    24 #define XM_PATH "/usr/sbin/xm"

    25 

    26 /*

    27  * Parse command:

    28  *  xmsh <cmd>

    29  *  xmsh -c <cmd>

    30  */

    31 char *parse_command (int argc, char **argv) {

    32     if (argc == 2)

    33         return argv[1];

    34 

    35     else if (argc == 3 && strcmp(argv[1], "-c") == 0)

    36         return argv[2];

    37     

    38     // fail

    39     errx(EXIT_FAILURE, "usage: ssh [-t] <dom0> (list|reboot|console)");

    40 }

    41 

    42 /*

    43  * Validate that the given command is legal

    44  */

    45 void validate_command (const char *command) {

    46     // strcmp against whitelist of commands

    47     if (0

    48         ||  (strcmp(command, "list") == 0)

    49         ||  (strcmp(command, "reboot") == 0)

    50         ||  (strcmp(command, "console") == 0)

    51     )

    52         return;

    53     

    54     // else fail

    55     err(EXIT_FAILURE, "invalid command: %s", command);

    56 }

    57 

    58 /*

    59  * Validate that the username is sane

    60  */

    61 void validate_username (const char *c) {

    62     if (!(*c))

    63         errx(EXIT_FAILURE, "username length");

    64 

    65     for (; *c; c++) {

    66         if (!isalpha(*c) && *c != '-') {

    67             break;

    68         }

    69     }

    70 

    71     if (*c)

    72         errx(EXIT_FAILURE, "username non-alpha");

    73 

    74 }   

    75 

    76 void validate_vmname (const char *c) {

    77     if (!(*c))

    78         errx(EXIT_FAILURE, "vmname length");

    79 

    80     for (; *c; c++) {

    81         if (!isprint(*c) || isspace(*c)) {

    82             break;

    83         }

    84     }

    85 

    86     if (*c)

    87         errx(EXIT_FAILURE, "vmname non-print/space");

    88 }

    89 

    90 /*

    91  * Get the real uid's username - i.e. the user who executed this file.

    92  */

    93 void get_username (char buf[USERNAME_MAX]) {

    94     uid_t uid;

    95     struct passwd *passwd;

    96 

    97     // get the real uid

    98     uid = getuid();

    99     

   100     // get the passwd entry

   101     if ((passwd = getpwuid(uid)) == NULL)

   102         err(EXIT_FAILURE, "getpwuid");

   103 

   104     if (passwd->pw_name == NULL)

   105         errx(EXIT_FAILURE, "passwd->pw_name");

   106 

   107     // fail too-long usernames

   108     if (strlen(passwd->pw_name) >= USERNAME_MAX)

   109         errx(EXIT_FAILURE, "strlen(passwd->pw_name) >= USERNAME_MAX");

   110     

   111     // copy the username to buf

   112     strncpy(buf, passwd->pw_name, USERNAME_MAX);

   113 

   114     // force zero-terminate

   115     buf[USERNAME_MAX - 1] = '\0';

   116     

   117     // sanity-check username to be all-alpha

   118     validate_username(buf);

   119 }

   120 

   121 /*

   122  * Get the virtual machine name for the current user

   123  */

   124 void get_vmname (const char *username, char buf[VMNAME_MAX]) {

   125     // the path to the userfile

   126     char path[USERFILE_PATH_MAX], *nl;

   127     FILE *fh;

   128     

   129     // format the userfile path

   130     if (snprintf(path, USERFILE_PATH_MAX, USERFILE_PATH_FMT, username) >= USERFILE_PATH_MAX)

   131         errx(EXIT_FAILURE, "USERFILE_PATH_MAX");

   132     

   133     // open the userfile

   134     if ((fh = fopen(path, "r")) == NULL) {

   135         if (errno == ENOENT)

   136             errx(EXIT_FAILURE, "no vm defined for user: %s", username);

   137         else

   138             err(EXIT_FAILURE, "fopen: %s", path);

   139     }

   140 

   141     // read the vmname

   142     if (fgets(buf, VMNAME_MAX, fh) == NULL)

   143         err(EXIT_FAILURE, "fgets: %s", path);

   144     

   145     // kill the newline

   146     if ((nl = index(buf, '\n')))

   147         *nl = '\0';

   148     

   149     // sanity-check the vmname

   150     validate_vmname(buf);

   151 

   152     // good

   153 }

   154 

   155 void __attribute__ ((noreturn)) xm_exec (const char *vmname, const char *command) {

   156     const char *env[] = { NULL };

   157     

   158     // setuid to root

   159     if (setuid(0))

   160         err(EXIT_FAILURE, "setuid: 0");

   161 

   162     // exec

   163     execle(XM_PATH, "xm", command, vmname, NULL, env);

   164 

   165     // if we're still here, an error has occured

   166     err(EXIT_FAILURE, "%s: %s %s", XM_PATH, command, vmname);

   167 }

   168 

   169 int main (int argc, char **argv) {

   170     char username[USERNAME_MAX], vmname[VMNAME_MAX], *command;

   171 

   172     // get command

   173     command = parse_command(argc, argv);

   174 

   175     // get username

   176     get_username(username);

   177 

   178     // get vmname

   179     get_vmname(username, vmname);

   180 

   181     // execute xm

   182     xm_exec(vmname, command);

   183 }

   184