1
0
mirror of https://gitlab.com/libvirt/libvirt.git synced 2024-12-22 17:34:18 +03:00
libvirt/src/virsh.c

2081 lines
51 KiB
C
Raw Normal View History

/*
* virsh.c: a Xen shell used to exercise the libvir API
*
* Copyright (C) 2005 Red Hat, Inc.
*
* See COPYING.LIB for the License of this software
*
* Daniel Veillard <veillard@redhat.com>
2005-12-08 17:22:52 +03:00
* Karel Zak <kzak@redhat.com>
*
* $Id$
*/
#define _GNU_SOURCE /* isblank() */
2005-12-08 13:23:34 +03:00
#include "libvirt.h"
#include "virterror.h"
#include <stdio.h>
2005-12-08 13:23:34 +03:00
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <unistd.h>
2005-12-08 13:23:34 +03:00
#include <getopt.h>
#include <sys/types.h>
2005-12-08 17:22:52 +03:00
#include <sys/time.h>
2005-12-08 13:23:34 +03:00
#include <ctype.h>
#include <fcntl.h>
2005-12-08 13:23:34 +03:00
#include <readline/readline.h>
#include <readline/history.h>
#include "config.h"
#include "internal.h"
2005-12-08 13:23:34 +03:00
static char *progname;
#ifndef TRUE
#define TRUE 1
#define FALSE 0
#endif
#define VSH_PROMPT_RW "virsh # "
#define VSH_PROMPT_RO "virsh > "
#define GETTIMEOFDAY(T) gettimeofday(T, NULL)
#define DIFF_MSEC(T, U) \
((((int) ((T)->tv_sec - (U)->tv_sec)) * 1000000.0 + \
((int) ((T)->tv_usec - (U)->tv_usec))) / 1000.0)
typedef enum {
VSH_MESG, /* standard output */
VSH_HEADER, /* header for standard output */
VSH_FOOTER, /* timing, last command state, or whatever */
VSH_DEBUG1, /* debugN where 'N' = level */
2005-12-08 13:23:34 +03:00
VSH_DEBUG2,
VSH_DEBUG3,
VSH_DEBUG4,
VSH_DEBUG5
} vshOutType;
/*
* The error handler for virtsh
*/
static void
virshErrorHandler(void *unused, virErrorPtr error)
{
if ((unused != NULL) || (error == NULL))
return;
/* Suppress the VIR_ERR_NO_XEN error which fails as non-root */
if ((error->code == VIR_ERR_NO_XEN) || (error->code == VIR_ERR_OK))
return;
virDefaultErrorFunc(error);
}
2005-12-08 13:23:34 +03:00
/*
* virsh command line grammar:
*
* command_line = <command>\n | <command>; <command>; ...
*
* command = <keyword> <option> <data>
*
* option = <bool_option> | <int_option> | <string_option>
* data = <string>
*
* bool_option = --optionname
* int_option = --optionname <number>
* string_option = --optionname <string>
*
2006-01-25 12:46:22 +03:00
* keyword = [a-zA-Z]
* number = [0-9]+
* string = [^[:blank:]] | "[[:alnum:]]"$
2005-12-08 13:23:34 +03:00
*
*/
/*
* vshCmdOptType - command option type
*/
2005-12-08 13:23:34 +03:00
typedef enum {
VSH_OT_NONE = 0, /* none */
VSH_OT_BOOL, /* boolean option */
VSH_OT_STRING, /* string option */
VSH_OT_INT, /* int option */
VSH_OT_DATA /* string data (as non-option) */
2005-12-08 13:23:34 +03:00
} vshCmdOptType;
/*
* Command Option Flags
*/
#define VSH_OFLAG_NONE 0 /* without flags */
#define VSH_OFLAG_REQ (1 << 1) /* option required */
2005-12-08 13:23:34 +03:00
/* dummy */
typedef struct __vshControl vshControl;
typedef struct __vshCmd vshCmd;
/*
* vshCmdInfo -- information about command
*/
typedef struct {
const char *name; /* name of information */
const char *data; /* information */
2005-12-08 13:23:34 +03:00
} vshCmdInfo;
/*
* vshCmdOptDef - command option definition
*/
typedef struct {
const char *name; /* the name of option */
vshCmdOptType type; /* option type */
int flag; /* flags */
const char *help; /* help string */
2005-12-08 13:23:34 +03:00
} vshCmdOptDef;
/*
* vshCmdOpt - command options
*/
typedef struct vshCmdOpt {
vshCmdOptDef *def; /* pointer to relevant option */
char *data; /* allocated data */
struct vshCmdOpt *next;
2005-12-08 13:23:34 +03:00
} vshCmdOpt;
/*
* vshCmdDef - command definition
*/
typedef struct {
const char *name;
int (*handler) (vshControl *, vshCmd *); /* command handler */
vshCmdOptDef *opts; /* definition of command options */
vshCmdInfo *info; /* details about command */
2005-12-08 13:23:34 +03:00
} vshCmdDef;
/*
* vshCmd - parsed command
*/
typedef struct __vshCmd {
vshCmdDef *def; /* command definition */
vshCmdOpt *opts; /* list of command arguments */
struct __vshCmd *next; /* next command */
2005-12-08 13:23:34 +03:00
} __vshCmd;
/*
* vshControl
*/
typedef struct __vshControl {
virConnectPtr conn; /* connection to hypervisor */
vshCmd *cmd; /* the current command */
char *cmdstr; /* string with command */
uid_t uid; /* process owner */
int imode; /* interactive mode? */
int quiet; /* quiet mode */
int debug; /* print debug messages? */
int timing; /* print timing info? */
2005-12-08 13:23:34 +03:00
} __vshControl;
2005-12-08 13:23:34 +03:00
static vshCmdDef commands[];
static void vshError(vshControl * ctl, int doexit, const char *format,
...);
static int vshInit(vshControl * ctl);
static int vshDeinit(vshControl * ctl);
static void vshUsage(vshControl * ctl, const char *cmdname);
2005-12-08 13:23:34 +03:00
static int vshParseArgv(vshControl * ctl, int argc, char **argv);
2005-12-08 13:23:34 +03:00
static const char *vshCmddefGetInfo(vshCmdDef * cmd, const char *info);
2005-12-08 17:22:52 +03:00
static vshCmdDef *vshCmddefSearch(const char *cmdname);
static int vshCmddefHelp(vshControl * ctl, const char *name, int withprog);
2005-12-08 13:23:34 +03:00
static vshCmdOpt *vshCommandOpt(vshCmd * cmd, const char *name);
static int vshCommandOptInt(vshCmd * cmd, const char *name, int *found);
static char *vshCommandOptString(vshCmd * cmd, const char *name,
int *found);
static int vshCommandOptBool(vshCmd * cmd, const char *name);
static virDomainPtr vshCommandOptDomain(vshControl * ctl, vshCmd * cmd,
const char *optname, char **name);
2005-12-15 20:00:43 +03:00
2005-12-08 13:23:34 +03:00
static void vshPrint(vshControl * ctl, vshOutType out, const char *format,
...);
2005-12-08 13:23:34 +03:00
2005-12-08 17:22:52 +03:00
static const char *vshDomainStateToString(int state);
static int vshConnectionUsability(vshControl * ctl, virConnectPtr conn,
int showerror);
2005-12-08 13:23:34 +03:00
static void *_vshMalloc(vshControl * ctl, size_t sz, const char *filename, int line);
#define vshMalloc(_ctl, _sz) _vshMalloc(_ctl, _sz, __FILE__, __LINE__)
static void *_vshCalloc(vshControl * ctl, size_t nmemb, size_t sz, const char *filename, int line);
#define vshCalloc(_ctl, _nmemb, _sz) _vshCalloc(_ctl, _nmemb, _sz, __FILE__, __LINE__)
static char *_vshStrdup(vshControl * ctl, const char *s, const char *filename, int line);
#define vshStrdup(_ctl, _s) _vshStrdup(_ctl, _s, __FILE__, __LINE__)
2005-12-08 13:23:34 +03:00
/* ---------------
* Commands
* ---------------
*/
/*
* "help" command
*/
static vshCmdInfo info_help[] = {
{"syntax", "help [<command>]"},
{"help", "print help"},
{"desc", "Prints global help or command specific help."},
{"version", "Prints versionning informations."},
{NULL, NULL}
2005-12-08 13:23:34 +03:00
};
static vshCmdOptDef opts_help[] = {
{"command", VSH_OT_DATA, 0, "name of command"},
{NULL, 0, 0, NULL}
2005-12-08 13:23:34 +03:00
};
static int
cmdHelp(vshControl * ctl, vshCmd * cmd)
{
2005-12-08 17:22:52 +03:00
const char *cmdname = vshCommandOptString(cmd, "command", NULL);
2005-12-08 13:23:34 +03:00
if (!cmdname) {
vshCmdDef *def;
2005-12-08 13:23:34 +03:00
vshPrint(ctl, VSH_HEADER, "Commands:\n\n");
for (def = commands; def->name; def++)
vshPrint(ctl, VSH_MESG, " %-15s %s\n", def->name,
vshCmddefGetInfo(def, "help"));
2005-12-08 13:23:34 +03:00
return TRUE;
}
return vshCmddefHelp(ctl, cmdname, FALSE);
}
/*
* "connect" command
*/
static vshCmdInfo info_connect[] = {
{"syntax", "connect [--readonly]"},
{"help", "(re)connect to hypervisor"},
{"desc",
"Connect to local hypervisor. This is build-in command after shell start up."},
{NULL, NULL}
2005-12-08 13:23:34 +03:00
};
static vshCmdOptDef opts_connect[] = {
{"readonly", VSH_OT_BOOL, 0, "read-only connection"},
{NULL, 0, 0, NULL}
2005-12-08 13:23:34 +03:00
};
static int
cmdConnect(vshControl * ctl, vshCmd * cmd)
{
2005-12-08 13:23:34 +03:00
int ro = vshCommandOptBool(cmd, "readonly");
2005-12-08 13:23:34 +03:00
if (ctl->conn) {
if (virConnectClose(ctl->conn) != 0) {
vshError(ctl, FALSE,
"failed to disconnect from the hypervisor");
2005-12-08 13:23:34 +03:00
return FALSE;
}
ctl->conn = NULL;
}
if (!ro)
ctl->conn = virConnectOpen(NULL);
else
ctl->conn = virConnectOpenReadOnly(NULL);
if (!ctl->conn)
vshError(ctl, FALSE, "failed to connect to the hypervisor");
2005-12-08 13:23:34 +03:00
return ctl->conn ? TRUE : FALSE;
}
/*
* "list" command
*/
static vshCmdInfo info_list[] = {
{"syntax", "list"},
{"help", "list domains"},
{"desc", "Returns list of domains."},
{NULL, NULL}
2005-12-08 13:23:34 +03:00
};
static int
cmdList(vshControl * ctl, vshCmd * cmd ATTRIBUTE_UNUSED)
{
2005-12-08 13:23:34 +03:00
int *ids, maxid, i;
if (!vshConnectionUsability(ctl, ctl->conn, TRUE))
return FALSE;
2005-12-08 13:23:34 +03:00
maxid = virConnectNumOfDomains(ctl->conn);
if (maxid <= 0) {
/* strange, there should be at least dom0... */
vshError(ctl, FALSE, "failed to list active domains.");
return FALSE;
}
ids = vshMalloc(ctl, sizeof(int) * maxid);
2005-12-08 13:23:34 +03:00
virConnectListDomains(ctl->conn, &ids[0], maxid);
2005-12-08 13:23:34 +03:00
vshPrint(ctl, VSH_HEADER, "%3s %-20s %s\n", "Id", "Name", "State");
vshPrint(ctl, VSH_HEADER, "----------------------------------\n");
for (i = 0; i < maxid; i++) {
2005-12-08 13:23:34 +03:00
int ret;
virDomainInfo info;
virDomainPtr dom = virDomainLookupByID(ctl->conn, ids[i]);
/* this kind of work with domains is not atomic operation */
2005-12-08 13:23:34 +03:00
if (!dom)
continue;
ret = virDomainGetInfo(dom, &info);
vshPrint(ctl, VSH_MESG, "%3d %-20s %s\n",
virDomainGetID(dom),
virDomainGetName(dom),
ret <
0 ? "no state" : vshDomainStateToString(info.state));
virDomainFree(dom);
2005-12-08 13:23:34 +03:00
}
free(ids);
return TRUE;
}
/*
2006-04-05 01:52:31 +04:00
* "domstate" command
2005-12-08 13:23:34 +03:00
*/
2006-04-05 01:52:31 +04:00
static vshCmdInfo info_domstate[] = {
{"syntax", "domstate <domain>"},
{"help", "domain state"},
{"desc", "Returns state about a running domain."},
{NULL, NULL}
2005-12-08 13:23:34 +03:00
};
2006-04-05 01:52:31 +04:00
static vshCmdOptDef opts_domstate[] = {
{"domain", VSH_OT_DATA, VSH_OFLAG_REQ, "domain name or id"},
{NULL, 0, 0, NULL}
2005-12-08 13:23:34 +03:00
};
static int
2006-04-05 01:52:31 +04:00
cmdDomstate(vshControl * ctl, vshCmd * cmd)
{
virDomainInfo info;
2005-12-08 13:23:34 +03:00
virDomainPtr dom;
2005-12-15 20:00:43 +03:00
int ret = TRUE;
2005-12-08 13:23:34 +03:00
if (!vshConnectionUsability(ctl, ctl->conn, TRUE))
return FALSE;
2005-12-15 20:00:43 +03:00
if (!(dom = vshCommandOptDomain(ctl, cmd, "domain", NULL)))
2005-12-08 13:23:34 +03:00
return FALSE;
if (virDomainGetInfo(dom, &info) == 0)
vshPrint(ctl, VSH_MESG, "%s\n",
vshDomainStateToString(info.state));
2005-12-08 13:23:34 +03:00
else
ret = FALSE;
virDomainFree(dom);
return ret;
}
/*
* "suspend" command
*/
static vshCmdInfo info_suspend[] = {
{"syntax", "suspend <domain>"},
{"help", "suspend a domain"},
{"desc", "Suspend a running domain."},
{NULL, NULL}
};
static vshCmdOptDef opts_suspend[] = {
{"domain", VSH_OT_DATA, VSH_OFLAG_REQ, "domain name or id"},
{NULL, 0, 0, NULL}
};
static int
cmdSuspend(vshControl * ctl, vshCmd * cmd)
{
virDomainPtr dom;
2005-12-15 20:00:43 +03:00
char *name;
int ret = TRUE;
if (!vshConnectionUsability(ctl, ctl->conn, TRUE))
return FALSE;
2005-12-15 20:00:43 +03:00
if (!(dom = vshCommandOptDomain(ctl, cmd, "domain", &name)))
return FALSE;
if (virDomainSuspend(dom) == 0) {
2005-12-15 20:00:43 +03:00
vshPrint(ctl, VSH_MESG, "Domain %s suspended\n", name);
} else {
vshError(ctl, FALSE, "Failed to suspend domain\n");
ret = FALSE;
}
virDomainFree(dom);
return ret;
}
/*
* "create" command
*/
static vshCmdInfo info_create[] = {
{"syntax", "create a domain from an XML <file>"},
{"help", "create a domain from an XML file"},
{"desc", "Create a domain."},
{NULL, NULL}
};
static vshCmdOptDef opts_create[] = {
{"file", VSH_OT_DATA, VSH_OFLAG_REQ, "file conatining an XML domain description"},
{NULL, 0, 0, NULL}
};
static int
cmdCreate(vshControl * ctl, vshCmd * cmd)
{
virDomainPtr dom;
char *from;
int found;
int ret = TRUE;
char buffer[4096];
int fd, l;
if (!vshConnectionUsability(ctl, ctl->conn, TRUE))
return FALSE;
from = vshCommandOptString(cmd, "file", &found);
if (!found)
return FALSE;
fd = open(from, O_RDONLY);
if (fd < 0) {
vshError(ctl, FALSE, "Failed to read description file %s\n", from);
return(FALSE);
}
l = read(fd, &buffer[0], sizeof(buffer));
if ((l <= 0) || (l >= (int) sizeof(buffer))) {
vshError(ctl, FALSE, "Failed to read description file %s\n", from);
close(fd);
return(FALSE);
}
buffer[l] = 0;
dom = virDomainCreateLinux(ctl->conn, &buffer[0], 0);
if (dom != NULL) {
vshPrint(ctl, VSH_MESG, "Domain %s created from %s\n",
virDomainGetName(dom), from);
} else {
vshError(ctl, FALSE, "Failed to create domain\n");
ret = FALSE;
}
return ret;
}
/*
* "save" command
*/
static vshCmdInfo info_save[] = {
{"syntax", "save <domain> <file>"},
{"help", "save a domain state to a file"},
{"desc", "Save a running domain."},
{NULL, NULL}
};
static vshCmdOptDef opts_save[] = {
{"domain", VSH_OT_DATA, VSH_OFLAG_REQ, "domain name or id"},
{"file", VSH_OT_DATA, VSH_OFLAG_REQ, "where to save the data"},
{NULL, 0, 0, NULL}
};
static int
cmdSave(vshControl * ctl, vshCmd * cmd)
{
virDomainPtr dom;
char *name;
char *to;
int ret = TRUE;
if (!vshConnectionUsability(ctl, ctl->conn, TRUE))
return FALSE;
2006-01-25 12:46:22 +03:00
if (!(to = vshCommandOptString(cmd, "file", NULL)))
return FALSE;
if (!(dom = vshCommandOptDomain(ctl, cmd, "domain", &name)))
return FALSE;
if (virDomainSave(dom, to) == 0) {
vshPrint(ctl, VSH_MESG, "Domain %s saved\n", name);
} else {
vshError(ctl, FALSE, "Failed to save domain\n");
ret = FALSE;
}
virDomainFree(dom);
return ret;
}
/*
* "restore" command
*/
static vshCmdInfo info_restore[] = {
{"syntax", "restore a domain from <file>"},
{"help", "restore a domain from a saved state in a file"},
{"desc", "Restore a domain."},
{NULL, NULL}
};
static vshCmdOptDef opts_restore[] = {
{"file", VSH_OT_DATA, VSH_OFLAG_REQ, "the state to restore"},
{NULL, 0, 0, NULL}
};
static int
cmdRestore(vshControl * ctl, vshCmd * cmd)
{
char *from;
int found;
int ret = TRUE;
if (!vshConnectionUsability(ctl, ctl->conn, TRUE))
return FALSE;
from = vshCommandOptString(cmd, "file", &found);
if (!found)
return FALSE;
if (virDomainRestore(ctl->conn, from) == 0) {
vshPrint(ctl, VSH_MESG, "Domain restored from %s\n", from);
} else {
vshError(ctl, FALSE, "Failed to restore domain\n");
ret = FALSE;
}
return ret;
}
/*
* "resume" command
*/
static vshCmdInfo info_resume[] = {
{"syntax", "resume <domain>"},
{"help", "resume a domain"},
{"desc", "Resume a previously suspended domain."},
{NULL, NULL}
};
static vshCmdOptDef opts_resume[] = {
{"domain", VSH_OT_DATA, VSH_OFLAG_REQ, "domain name or id"},
{NULL, 0, 0, NULL}
};
static int
cmdResume(vshControl * ctl, vshCmd * cmd)
{
virDomainPtr dom;
2005-12-15 20:00:43 +03:00
int ret = TRUE;
char *name;
if (!vshConnectionUsability(ctl, ctl->conn, TRUE))
return FALSE;
2005-12-15 20:00:43 +03:00
if (!(dom = vshCommandOptDomain(ctl, cmd, "domain", &name)))
return FALSE;
if (virDomainResume(dom) == 0) {
2005-12-15 20:00:43 +03:00
vshPrint(ctl, VSH_MESG, "Domain %s resumed\n", name);
} else {
vshError(ctl, FALSE, "Failed to resume domain\n");
ret = FALSE;
}
virDomainFree(dom);
return ret;
}
/*
* "shutdown" command
*/
static vshCmdInfo info_shutdown[] = {
{"syntax", "shutdown <domain>"},
{"help", "gracefully shutdown a domain"},
{"desc", "Run shutdown in the targetted domain"},
{NULL, NULL}
};
static vshCmdOptDef opts_shutdown[] = {
{"domain", VSH_OT_DATA, VSH_OFLAG_REQ, "domain name or id"},
{NULL, 0, 0, NULL}
};
static int
cmdShutdown(vshControl * ctl, vshCmd * cmd)
{
virDomainPtr dom;
int ret = TRUE;
char *name;
if (!vshConnectionUsability(ctl, ctl->conn, TRUE))
return FALSE;
if (!(dom = vshCommandOptDomain(ctl, cmd, "domain", &name)))
return FALSE;
if (virDomainShutdown(dom) == 0) {
vshPrint(ctl, VSH_MESG, "Domain %s is being shutdown\n", name);
} else {
vshError(ctl, FALSE, "Failed to shutdown domain\n");
ret = FALSE;
}
virDomainFree(dom);
return ret;
}
/*
* "reboot" command
*/
static vshCmdInfo info_reboot[] = {
{"syntax", "reboot <domain>"},
{"help", "reboot a domain"},
{"desc", "Run a reboot command in the targetted domain"},
{NULL, NULL}
};
static vshCmdOptDef opts_reboot[] = {
{"domain", VSH_OT_DATA, VSH_OFLAG_REQ, "domain name or id"},
{NULL, 0, 0, NULL}
};
static int
cmdReboot(vshControl * ctl, vshCmd * cmd)
{
virDomainPtr dom;
int ret = TRUE;
char *name;
if (!vshConnectionUsability(ctl, ctl->conn, TRUE))
return FALSE;
if (!(dom = vshCommandOptDomain(ctl, cmd, "domain", &name)))
return FALSE;
if (virDomainReboot(dom, 0) == 0) {
vshPrint(ctl, VSH_MESG, "Domain %s is being rebooted\n", name);
} else {
vshError(ctl, FALSE, "Failed to reboot domain\n");
ret = FALSE;
}
virDomainFree(dom);
return ret;
}
/*
* "destroy" command
*/
static vshCmdInfo info_destroy[] = {
{"syntax", "destroy <domain>"},
{"help", "destroy a domain"},
{"desc", "Destroy a given domain."},
{NULL, NULL}
};
static vshCmdOptDef opts_destroy[] = {
{"domain", VSH_OT_DATA, VSH_OFLAG_REQ, "domain name or id"},
{NULL, 0, 0, NULL}
};
static int
cmdDestroy(vshControl * ctl, vshCmd * cmd)
{
virDomainPtr dom;
2005-12-15 20:00:43 +03:00
int ret = TRUE;
char *name;
if (!vshConnectionUsability(ctl, ctl->conn, TRUE))
return FALSE;
2005-12-15 20:00:43 +03:00
if (!(dom = vshCommandOptDomain(ctl, cmd, "domain", &name)))
return FALSE;
if (virDomainDestroy(dom) == 0) {
2005-12-15 20:00:43 +03:00
vshPrint(ctl, VSH_MESG, "Domain %s destroyed\n", name);
} else {
vshError(ctl, FALSE, "Failed to destroy domain\n");
ret = FALSE;
virDomainFree(dom);
}
2005-12-08 13:23:34 +03:00
return ret;
}
/*
* "dominfo" command
2005-12-08 13:23:34 +03:00
*/
static vshCmdInfo info_dominfo[] = {
{"syntax", "dominfo <domain>"},
{"help", "domain information"},
{"desc", "Returns basic information about the domain."},
{NULL, NULL}
2005-12-08 13:23:34 +03:00
};
static vshCmdOptDef opts_dominfo[] = {
{"domain", VSH_OT_DATA, VSH_OFLAG_REQ, "domain name or id"},
{NULL, 0, 0, NULL}
2005-12-08 13:23:34 +03:00
};
static int
cmdDominfo(vshControl * ctl, vshCmd * cmd)
{
2005-12-08 13:23:34 +03:00
virDomainInfo info;
virDomainPtr dom;
2005-12-15 20:00:43 +03:00
int ret = TRUE;
char *str;
2005-12-08 13:23:34 +03:00
if (!vshConnectionUsability(ctl, ctl->conn, TRUE))
return FALSE;
2005-12-15 20:00:43 +03:00
if (!(dom = vshCommandOptDomain(ctl, cmd, "domain", NULL)))
2005-12-08 13:23:34 +03:00
return FALSE;
vshPrint(ctl, VSH_MESG, "%-15s %d\n", "Id:", virDomainGetID(dom));
vshPrint(ctl, VSH_MESG, "%-15s %s\n", "Name:", virDomainGetName(dom));
if ((str = virDomainGetOSType(dom))) {
vshPrint(ctl, VSH_MESG, "%-15s %s\n", "OS Type:", str);
free(str);
}
if (virDomainGetInfo(dom, &info) == 0) {
vshPrint(ctl, VSH_MESG, "%-15s %s\n", "State:",
vshDomainStateToString(info.state));
vshPrint(ctl, VSH_MESG, "%-15s %d\n", "CPU(s):", info.nrVirtCpu);
if (info.cpuTime != 0) {
2005-12-15 20:00:43 +03:00
float cpuUsed = info.cpuTime;
2005-12-15 20:00:43 +03:00
cpuUsed /= 1000000000;
2005-12-15 20:00:43 +03:00
vshPrint(ctl, VSH_MESG, "%-15s %.1fs\n", "CPU time:", cpuUsed);
2005-12-08 13:23:34 +03:00
}
2005-12-08 13:23:34 +03:00
vshPrint(ctl, VSH_MESG, "%-15s %lu kB\n", "Max memory:",
info.maxMem);
2005-12-08 13:23:34 +03:00
vshPrint(ctl, VSH_MESG, "%-15s %lu kB\n", "Used memory:",
info.memory);
2005-12-08 13:23:34 +03:00
} else {
ret = FALSE;
}
virDomainFree(dom);
2005-12-08 13:23:34 +03:00
return ret;
}
/*
* "nodeinfo" command
*/
static vshCmdInfo info_nodeinfo[] = {
{"syntax", "nodeinfo"},
{"help", "node information"},
{"desc", "Returns basic information about the node."},
{NULL, NULL}
};
static int
cmdNodeinfo(vshControl * ctl, vshCmd * cmd ATTRIBUTE_UNUSED)
{
virNodeInfo info;
if (!vshConnectionUsability(ctl, ctl->conn, TRUE))
return FALSE;
if (virNodeGetInfo(ctl->conn, &info) < 0) {
vshError(ctl, FALSE, "failed to get node information");
return FALSE;
}
vshPrint(ctl, VSH_MESG, "%-20s %s\n", "CPU model:", info.model);
vshPrint(ctl, VSH_MESG, "%-20s %d\n", "CPU(s):", info.cpus);
vshPrint(ctl, VSH_MESG, "%-20s %d MHz\n", "CPU frequency:", info.mhz);
vshPrint(ctl, VSH_MESG, "%-20s %d\n", "CPU socket(s):", info.sockets);
vshPrint(ctl, VSH_MESG, "%-20s %d\n", "Core(s) per socket:", info.cores);
vshPrint(ctl, VSH_MESG, "%-20s %d\n", "Thread(s) per core:", info.threads);
vshPrint(ctl, VSH_MESG, "%-20s %d\n", "NUMA cell(s):", info.nodes);
vshPrint(ctl, VSH_MESG, "%-20s %lu kB\n", "Memory size:", info.memory);
return TRUE;
}
/*
* "dumpxml" command
*/
static vshCmdInfo info_dumpxml[] = {
{"syntax", "dumpxml <name>"},
{"help", "domain information in XML"},
{"desc", "Ouput the domain informations as an XML dump to stdout"},
{NULL, NULL}
};
static vshCmdOptDef opts_dumpxml[] = {
{"domain", VSH_OT_DATA, VSH_OFLAG_REQ, "domain name or id"},
{NULL, 0, 0, NULL}
};
static int
cmdDumpXML(vshControl * ctl, vshCmd * cmd)
{
virDomainPtr dom;
2005-12-15 20:00:43 +03:00
int ret = TRUE;
char *dump;
if (!vshConnectionUsability(ctl, ctl->conn, TRUE))
return FALSE;
2005-12-15 20:00:43 +03:00
if (!(dom = vshCommandOptDomain(ctl, cmd, "domain", NULL)))
return FALSE;
dump = virDomainGetXMLDesc(dom, 0);
if (dump != NULL) {
printf("%s", dump);
free(dump);
} else {
ret = FALSE;
}
virDomainFree(dom);
return ret;
}
2005-12-08 13:23:34 +03:00
/*
2006-04-05 01:52:31 +04:00
* "domname" command
2005-12-08 13:23:34 +03:00
*/
2006-04-05 01:52:31 +04:00
static vshCmdInfo info_domname[] = {
{"syntax", "domname <id>"},
{"help", "convert a domain Id to domain name"},
{NULL, NULL}
2005-12-08 13:23:34 +03:00
};
2006-04-05 01:52:31 +04:00
static vshCmdOptDef opts_domname[] = {
{"id", VSH_OT_DATA, VSH_OFLAG_REQ, "domain Id"},
{NULL, 0, 0, NULL}
2005-12-08 13:23:34 +03:00
};
static int
2006-04-05 01:52:31 +04:00
cmdDomname(vshControl * ctl, vshCmd * cmd)
{
2005-12-08 13:23:34 +03:00
int found;
int id = vshCommandOptInt(cmd, "id", &found);
virDomainPtr dom;
if (!vshConnectionUsability(ctl, ctl->conn, TRUE))
return FALSE;
if (!found)
return FALSE;
2005-12-08 13:23:34 +03:00
dom = virDomainLookupByID(ctl->conn, id);
if (dom) {
vshPrint(ctl, VSH_MESG, "%s\n", virDomainGetName(dom));
virDomainFree(dom);
2005-12-08 13:23:34 +03:00
} else {
vshError(ctl, FALSE, "failed to get domain '%d'", id);
return FALSE;
}
return TRUE;
}
/*
2006-04-05 01:52:31 +04:00
* "domid" command
2005-12-08 13:23:34 +03:00
*/
2006-04-05 01:52:31 +04:00
static vshCmdInfo info_domid[] = {
{"syntax", "domid <name>"},
{"help", "convert a domain name to domain Id"},
{NULL, NULL}
2005-12-08 13:23:34 +03:00
};
2006-04-05 01:52:31 +04:00
static vshCmdOptDef opts_domid[] = {
{"name", VSH_OT_DATA, VSH_OFLAG_REQ, "domain name"},
{NULL, 0, 0, NULL}
2005-12-08 13:23:34 +03:00
};
static int
2006-04-05 01:52:31 +04:00
cmdDomid(vshControl * ctl, vshCmd * cmd)
{
2005-12-08 13:23:34 +03:00
char *name = vshCommandOptString(cmd, "name", NULL);
virDomainPtr dom;
2005-12-08 13:23:34 +03:00
if (!vshConnectionUsability(ctl, ctl->conn, TRUE))
return FALSE;
if (!name)
return FALSE;
2005-12-08 13:23:34 +03:00
dom = virDomainLookupByName(ctl->conn, name);
if (dom) {
vshPrint(ctl, VSH_MESG, "%d\n", virDomainGetID(dom));
virDomainFree(dom);
2005-12-08 13:23:34 +03:00
} else {
vshError(ctl, FALSE, "failed to get domain '%s'", name);
return FALSE;
}
return TRUE;
}
/*
* "version" command
*/
static vshCmdInfo info_version[] = {
{"syntax", "version"},
{"help", "show versions"},
{"desc", "Display the version informations available"},
{NULL, NULL}
};
static int
cmdVersion(vshControl * ctl, vshCmd * cmd ATTRIBUTE_UNUSED)
{
unsigned long hvVersion;
const char *hvType;
unsigned long libVersion;
unsigned long includeVersion;
unsigned long apiVersion;
int ret;
unsigned int major;
unsigned int minor;
unsigned int rel;
if (!vshConnectionUsability(ctl, ctl->conn, TRUE))
return FALSE;
hvType = virConnectGetType(ctl->conn);
if (hvType == NULL) {
2005-12-08 17:22:52 +03:00
vshError(ctl, FALSE, "failed to get hypervisor type\n");
return FALSE;
}
includeVersion = LIBVIR_VERSION_NUMBER;
major = includeVersion / 1000000;
includeVersion %= 1000000;
minor = includeVersion / 1000;
rel = includeVersion % 1000;
vshPrint(ctl, VSH_MESG, "Compiled against library: libvir %d.%d.%d\n",
major, minor, rel);
ret = virGetVersion(&libVersion, hvType, &apiVersion);
if (ret < 0) {
vshError(ctl, FALSE, "failed to get the library version");
return FALSE;
}
major = libVersion / 1000000;
libVersion %= 1000000;
minor = libVersion / 1000;
rel = libVersion % 1000;
vshPrint(ctl, VSH_MESG, "Using library: libvir %d.%d.%d\n",
major, minor, rel);
major = apiVersion / 1000000;
apiVersion %= 1000000;
minor = apiVersion / 1000;
rel = apiVersion % 1000;
vshPrint(ctl, VSH_MESG, "Using API: %s %d.%d.%d\n", hvType,
major, minor, rel);
ret = virConnectGetVersion(ctl->conn, &hvVersion);
if (ret < 0) {
vshError(ctl, FALSE, "failed to get the hypervisor version");
return FALSE;
}
if (hvVersion == 0) {
vshPrint(ctl, VSH_MESG,
"cannot extract running %s hypervisor version\n", hvType);
} else {
major = hvVersion / 1000000;
hvVersion %= 1000000;
minor = hvVersion / 1000;
rel = hvVersion % 1000;
vshPrint(ctl, VSH_MESG, "Running hypervisor: %s %d.%d.%d\n",
hvType, major, minor, rel);
}
return TRUE;
}
2005-12-08 13:23:34 +03:00
/*
* "quit" command
*/
static vshCmdInfo info_quit[] = {
{"syntax", "quit"},
{"help", "quit this interactive terminal"},
{NULL, NULL}
2005-12-08 13:23:34 +03:00
};
static int
cmdQuit(vshControl * ctl, vshCmd * cmd ATTRIBUTE_UNUSED)
{
2005-12-08 13:23:34 +03:00
ctl->imode = FALSE;
return TRUE;
}
/*
* Commands
*/
static vshCmdDef commands[] = {
{"connect", cmdConnect, opts_connect, info_connect},
{"create", cmdCreate, opts_create, info_create},
2006-04-05 01:52:31 +04:00
{"destroy", cmdDestroy, opts_destroy, info_destroy},
{"domid", cmdDomid, opts_domid, info_domid},
{"dominfo", cmdDominfo, opts_dominfo, info_dominfo},
2006-04-05 01:52:31 +04:00
{"domname", cmdDomname, opts_domname, info_domname},
{"domstate", cmdDomstate, opts_domstate, info_domstate},
{"dumpxml", cmdDumpXML, opts_dumpxml, info_dumpxml},
2006-04-05 01:52:31 +04:00
{"help", cmdHelp, opts_help, info_help},
{"list", cmdList, NULL, info_list},
{"nodeinfo", cmdNodeinfo, NULL, info_nodeinfo},
{"quit", cmdQuit, NULL, info_quit},
{"reboot", cmdReboot, opts_reboot, info_reboot},
{"restore", cmdRestore, opts_restore, info_restore},
{"resume", cmdResume, opts_resume, info_resume},
{"save", cmdSave, opts_save, info_save},
{"shutdown", cmdShutdown, opts_shutdown, info_shutdown},
2006-04-05 01:52:31 +04:00
{"suspend", cmdSuspend, opts_suspend, info_suspend},
{"version", cmdVersion, NULL, info_version},
{NULL, NULL, NULL, NULL}
2005-12-08 13:23:34 +03:00
};
/* ---------------
* Utils for work with command definition
* ---------------
*/
2005-12-08 17:22:52 +03:00
static const char *
vshCmddefGetInfo(vshCmdDef * cmd, const char *name)
{
2005-12-08 13:23:34 +03:00
vshCmdInfo *info;
2005-12-08 13:23:34 +03:00
for (info = cmd->info; info && info->name; info++) {
if (strcmp(info->name, name) == 0)
2005-12-08 13:23:34 +03:00
return info->data;
}
return NULL;
}
static vshCmdOptDef *
vshCmddefGetOption(vshCmdDef * cmd, const char *name)
{
2005-12-08 13:23:34 +03:00
vshCmdOptDef *opt;
2005-12-08 13:23:34 +03:00
for (opt = cmd->opts; opt && opt->name; opt++)
if (strcmp(opt->name, name) == 0)
2005-12-08 13:23:34 +03:00
return opt;
return NULL;
}
static vshCmdOptDef *
vshCmddefGetData(vshCmdDef * cmd, int data_ct)
{
2005-12-08 13:23:34 +03:00
vshCmdOptDef *opt;
2006-01-25 12:46:22 +03:00
for (opt = cmd->opts; opt && opt->name; opt++) {
if (opt->type == VSH_OT_DATA) {
if (data_ct == 0)
2006-01-25 12:46:22 +03:00
return opt;
else
data_ct--;
}
}
2005-12-08 13:23:34 +03:00
return NULL;
}
2006-01-25 12:46:22 +03:00
/*
* Checks for required options
*/
static int
vshCommandCheckOpts(vshControl * ctl, vshCmd * cmd)
2006-01-25 12:46:22 +03:00
{
vshCmdDef *def = cmd->def;
vshCmdOptDef *d;
int err = 0;
2006-01-25 12:46:22 +03:00
for (d = def->opts; d && d->name; d++) {
if (d->flag & VSH_OFLAG_REQ) {
vshCmdOpt *o = cmd->opts;
int ok = 0;
while (o && ok == 0) {
2006-01-25 12:46:22 +03:00
if (o->def == d)
ok = 1;
2006-01-25 12:46:22 +03:00
o = o->next;
}
if (!ok) {
vshError(ctl, FALSE,
d->type == VSH_OT_DATA ?
"command '%s' requires <%s> option" :
"command '%s' requires --%s option",
def->name, d->name);
2006-01-25 12:46:22 +03:00
err = 1;
}
2006-01-25 12:46:22 +03:00
}
}
return !err;
}
2005-12-08 13:23:34 +03:00
static vshCmdDef *
vshCmddefSearch(const char *cmdname)
{
2005-12-08 13:23:34 +03:00
vshCmdDef *c;
2005-12-08 13:23:34 +03:00
for (c = commands; c->name; c++)
if (strcmp(c->name, cmdname) == 0)
2005-12-08 13:23:34 +03:00
return c;
return NULL;
}
static int
vshCmddefHelp(vshControl * ctl, const char *cmdname, int withprog)
{
2005-12-08 13:23:34 +03:00
vshCmdDef *def = vshCmddefSearch(cmdname);
2005-12-08 13:23:34 +03:00
if (!def) {
vshError(ctl, FALSE, "command '%s' doesn't exist", cmdname);
return FALSE;
} else {
2005-12-08 13:23:34 +03:00
vshCmdOptDef *opt;
2005-12-08 17:22:52 +03:00
const char *desc = vshCmddefGetInfo(def, "desc");
const char *help = vshCmddefGetInfo(def, "help");
const char *syntax = vshCmddefGetInfo(def, "syntax");
2005-12-08 13:23:34 +03:00
fputs(" NAME\n", stdout);
fprintf(stdout, " %s - %s\n", def->name, help);
2005-12-08 13:23:34 +03:00
if (syntax) {
fputs("\n SYNOPSIS\n", stdout);
if (!withprog)
fprintf(stdout, " %s\n", syntax);
else
fprintf(stdout, " %s %s\n", progname, syntax);
}
if (desc) {
fputs("\n DESCRIPTION\n", stdout);
fprintf(stdout, " %s\n", desc);
}
if (def->opts) {
fputs("\n OPTIONS\n", stdout);
for (opt = def->opts; opt->name; opt++) {
2005-12-08 13:23:34 +03:00
char buf[256];
if (opt->type == VSH_OT_BOOL)
2005-12-08 13:23:34 +03:00
snprintf(buf, sizeof(buf), "--%s", opt->name);
else if (opt->type == VSH_OT_INT)
2005-12-08 13:23:34 +03:00
snprintf(buf, sizeof(buf), "--%s <number>", opt->name);
else if (opt->type == VSH_OT_STRING)
2005-12-08 13:23:34 +03:00
snprintf(buf, sizeof(buf), "--%s <string>", opt->name);
else if (opt->type == VSH_OT_DATA)
2005-12-08 13:23:34 +03:00
snprintf(buf, sizeof(buf), "<%s>", opt->name);
2005-12-08 13:23:34 +03:00
fprintf(stdout, " %-15s %s\n", buf, opt->help);
}
2005-12-08 13:23:34 +03:00
}
fputc('\n', stdout);
}
return TRUE;
}
/* ---------------
* Utils for work with runtime commands data
* ---------------
*/
static void
vshCommandOptFree(vshCmdOpt * arg)
{
2005-12-08 13:23:34 +03:00
vshCmdOpt *a = arg;
while (a) {
2005-12-08 13:23:34 +03:00
vshCmdOpt *tmp = a;
2005-12-08 13:23:34 +03:00
a = a->next;
if (tmp->data)
free(tmp->data);
free(tmp);
}
}
static void
vshCommandFree(vshCmd * cmd)
{
2005-12-08 13:23:34 +03:00
vshCmd *c = cmd;
while (c) {
2005-12-08 13:23:34 +03:00
vshCmd *tmp = c;
2005-12-08 13:23:34 +03:00
c = c->next;
if (tmp->opts)
vshCommandOptFree(tmp->opts);
free(tmp);
}
}
/*
* Returns option by name
*/
static vshCmdOpt *
vshCommandOpt(vshCmd * cmd, const char *name)
{
2005-12-08 13:23:34 +03:00
vshCmdOpt *opt = cmd->opts;
while (opt) {
if (opt->def && strcmp(opt->def->name, name) == 0)
2005-12-08 13:23:34 +03:00
return opt;
opt = opt->next;
}
return NULL;
}
/*
* Returns option as INT
*/
static int
vshCommandOptInt(vshCmd * cmd, const char *name, int *found)
{
2005-12-08 13:23:34 +03:00
vshCmdOpt *arg = vshCommandOpt(cmd, name);
int res = 0;
2005-12-08 13:23:34 +03:00
if (arg)
res = atoi(arg->data);
if (found)
*found = arg ? TRUE : FALSE;
return res;
}
/*
* Returns option as STRING
*/
static char *
vshCommandOptString(vshCmd * cmd, const char *name, int *found)
{
2005-12-08 13:23:34 +03:00
vshCmdOpt *arg = vshCommandOpt(cmd, name);
2005-12-08 13:23:34 +03:00
if (found)
*found = arg ? TRUE : FALSE;
2006-01-25 12:46:22 +03:00
return arg && arg->data && *arg->data ? arg->data : NULL;
2005-12-08 13:23:34 +03:00
}
/*
* Returns TRUE/FALSE if the option exists
*/
static int
vshCommandOptBool(vshCmd * cmd, const char *name)
{
2005-12-08 13:23:34 +03:00
return vshCommandOpt(cmd, name) ? TRUE : FALSE;
}
2006-01-25 12:46:22 +03:00
2005-12-15 20:00:43 +03:00
static virDomainPtr
vshCommandOptDomain(vshControl * ctl, vshCmd * cmd, const char *optname,
char **name)
{
2005-12-15 20:00:43 +03:00
virDomainPtr dom = NULL;
char *n, *end = NULL;
int id;
2005-12-15 20:00:43 +03:00
if (!(n = vshCommandOptString(cmd, optname, NULL))) {
vshError(ctl, FALSE, "undefined domain name or id");
return NULL;
2005-12-15 20:00:43 +03:00
}
vshPrint(ctl, VSH_DEBUG5, "%s: found option <%s>: %s\n",
cmd->def->name, optname, n);
2005-12-15 20:00:43 +03:00
if (name)
*name = n;
2005-12-15 20:00:43 +03:00
/* try it by ID */
id = (int) strtol(n, &end, 10);
if (id >= 0 && end && *end == '\0') {
vshPrint(ctl, VSH_DEBUG5, "%s: <%s> seems like domain ID\n",
cmd->def->name, optname);
2005-12-15 20:00:43 +03:00
dom = virDomainLookupByID(ctl->conn, id);
2006-01-25 12:46:22 +03:00
}
2005-12-15 20:00:43 +03:00
/* try it by NAME */
2006-01-25 12:46:22 +03:00
if (!dom) {
vshPrint(ctl, VSH_DEBUG5, "%s: <%s> tring as domain NAME\n",
cmd->def->name, optname);
2005-12-15 20:00:43 +03:00
dom = virDomainLookupByName(ctl->conn, n);
2006-01-25 12:46:22 +03:00
}
if (!dom)
2005-12-15 20:00:43 +03:00
vshError(ctl, FALSE, "failed to get domain '%s'", n);
2005-12-15 20:00:43 +03:00
return dom;
}
2005-12-08 13:23:34 +03:00
/*
* Executes command(s) and returns return code from last command
*/
static int
vshCommandRun(vshControl * ctl, vshCmd * cmd)
{
2005-12-08 13:23:34 +03:00
int ret = TRUE;
while (cmd) {
2005-12-08 13:23:34 +03:00
struct timeval before, after;
2005-12-08 13:23:34 +03:00
if (ctl->timing)
GETTIMEOFDAY(&before);
2005-12-08 13:23:34 +03:00
ret = cmd->def->handler(ctl, cmd);
if (ctl->timing)
GETTIMEOFDAY(&after);
if (strcmp(cmd->def->name, "quit") == 0) /* hack ... */
2005-12-08 13:23:34 +03:00
return ret;
if (ctl->timing)
vshPrint(ctl, VSH_MESG, "\n(Time: %.3f ms)\n\n",
DIFF_MSEC(&after, &before));
else
2005-12-08 13:23:34 +03:00
vshPrint(ctl, VSH_FOOTER, "\n");
cmd = cmd->next;
}
return ret;
}
/* ---------------
* Command string parsing
* ---------------
*/
#define VSH_TK_ERROR -1
#define VSH_TK_NONE 0
#define VSH_TK_OPTION 1
#define VSH_TK_DATA 2
#define VSH_TK_END 3
static int
vshCommandGetToken(vshControl * ctl, char *str, char **end, char **res)
{
2005-12-08 13:23:34 +03:00
int tk = VSH_TK_NONE;
int quote = FALSE;
int sz = 0;
char *p = str;
char *tkstr = NULL;
2005-12-08 13:23:34 +03:00
*end = NULL;
while (p && *p && isblank((unsigned char) *p))
2005-12-08 13:23:34 +03:00
p++;
if (p == NULL || *p == '\0')
2005-12-08 13:23:34 +03:00
return VSH_TK_END;
if (*p == ';') {
*end = ++p; /* = \0 or begi of next command */
2005-12-08 13:23:34 +03:00
return VSH_TK_END;
}
while (*p) {
2005-12-08 13:23:34 +03:00
/* end of token is blank space or ';' */
if ((quote == FALSE && isblank((unsigned char) *p)) || *p == ';')
2005-12-08 13:23:34 +03:00
break;
2006-01-25 12:46:22 +03:00
/* end of option name could be '=' */
if (tk == VSH_TK_OPTION && *p == '=') {
p++; /* skip '=' */
2006-01-25 12:46:22 +03:00
break;
}
if (tk == VSH_TK_NONE) {
if (*p == '-' && *(p + 1) == '-' && *(p + 2)
&& isalnum((unsigned char) *(p + 2))) {
2005-12-08 13:23:34 +03:00
tk = VSH_TK_OPTION;
p += 2;
2005-12-08 13:23:34 +03:00
} else {
tk = VSH_TK_DATA;
if (*p == '"') {
quote = TRUE;
2005-12-08 13:23:34 +03:00
p++;
} else {
quote = FALSE;
}
}
tkstr = p; /* begin of token */
} else if (quote && *p == '"') {
2005-12-08 13:23:34 +03:00
quote = FALSE;
p++;
break; /* end of "..." token */
2005-12-08 13:23:34 +03:00
}
p++;
sz++;
}
if (quote) {
vshError(ctl, FALSE, "missing \"");
return VSH_TK_ERROR;
}
if (tkstr == NULL || *tkstr == '\0' || p == NULL)
2005-12-08 13:23:34 +03:00
return VSH_TK_END;
if (sz == 0)
2005-12-08 13:23:34 +03:00
return VSH_TK_END;
*res = vshMalloc(ctl, sz + 1);
2005-12-08 13:23:34 +03:00
memcpy(*res, tkstr, sz);
*(*res + sz) = '\0';
2005-12-08 13:23:34 +03:00
*end = p;
return tk;
}
static int
vshCommandParse(vshControl * ctl, char *cmdstr)
{
2005-12-08 13:23:34 +03:00
char *str;
char *tkdata = NULL;
vshCmd *clast = NULL;
vshCmdOpt *first = NULL;
2005-12-08 13:23:34 +03:00
if (ctl->cmd) {
vshCommandFree(ctl->cmd);
ctl->cmd = NULL;
}
if (cmdstr == NULL || *cmdstr == '\0')
2005-12-08 13:23:34 +03:00
return FALSE;
2005-12-08 13:23:34 +03:00
str = cmdstr;
while (str && *str) {
2005-12-08 13:23:34 +03:00
vshCmdOpt *last = NULL;
vshCmdDef *cmd = NULL;
int tk = VSH_TK_NONE;
2006-01-25 12:46:22 +03:00
int data_ct = 0;
2005-12-08 13:23:34 +03:00
first = NULL;
while (tk != VSH_TK_END) {
2005-12-08 13:23:34 +03:00
char *end = NULL;
vshCmdOptDef *opt = NULL;
2005-12-08 13:23:34 +03:00
tkdata = NULL;
2005-12-08 13:23:34 +03:00
/* get token */
tk = vshCommandGetToken(ctl, str, &end, &tkdata);
2005-12-08 13:23:34 +03:00
str = end;
if (tk == VSH_TK_END)
2005-12-08 13:23:34 +03:00
break;
if (tk == VSH_TK_ERROR)
2005-12-08 13:23:34 +03:00
goto syntaxError;
if (cmd == NULL) {
2005-12-08 13:23:34 +03:00
/* first token must be command name */
if (tk != VSH_TK_DATA) {
vshError(ctl, FALSE,
"unexpected token (command name): '%s'",
tkdata);
2005-12-08 13:23:34 +03:00
goto syntaxError;
}
if (!(cmd = vshCmddefSearch(tkdata))) {
vshError(ctl, FALSE, "unknown command: '%s'", tkdata);
goto syntaxError; /* ... or ignore this command only? */
2005-12-08 13:23:34 +03:00
}
free(tkdata);
} else if (tk == VSH_TK_OPTION) {
2005-12-08 13:23:34 +03:00
if (!(opt = vshCmddefGetOption(cmd, tkdata))) {
vshError(ctl, FALSE,
"command '%s' doesn't support option --%s",
cmd->name, tkdata);
2005-12-08 13:23:34 +03:00
goto syntaxError;
}
free(tkdata); /* option name */
2005-12-08 13:23:34 +03:00
tkdata = NULL;
if (opt->type != VSH_OT_BOOL) {
/* option data */
tk = vshCommandGetToken(ctl, str, &end, &tkdata);
str = end;
if (tk == VSH_TK_ERROR)
2005-12-08 13:23:34 +03:00
goto syntaxError;
if (tk != VSH_TK_DATA) {
2005-12-08 13:23:34 +03:00
vshError(ctl, FALSE,
"expected syntax: --%s <%s>",
opt->name,
opt->type ==
VSH_OT_INT ? "number" : "string");
2005-12-08 13:23:34 +03:00
goto syntaxError;
}
}
} else if (tk == VSH_TK_DATA) {
2006-01-25 12:46:22 +03:00
if (!(opt = vshCmddefGetData(cmd, data_ct++))) {
vshError(ctl, FALSE, "unexpected data '%s'", tkdata);
2005-12-08 13:23:34 +03:00
goto syntaxError;
}
}
if (opt) {
/* save option */
vshCmdOpt *arg = vshMalloc(ctl, sizeof(vshCmdOpt));
2005-12-08 13:23:34 +03:00
arg->def = opt;
arg->data = tkdata;
arg->next = NULL;
tkdata = NULL;
2005-12-08 13:23:34 +03:00
if (!first)
first = arg;
if (last)
last->next = arg;
last = arg;
2005-12-08 13:23:34 +03:00
vshPrint(ctl, VSH_DEBUG4, "%s: %s(%s): %s\n",
cmd->name,
opt->name,
tk == VSH_TK_OPTION ? "OPTION" : "DATA",
arg->data);
2005-12-08 13:23:34 +03:00
}
if (!str)
break;
}
2005-12-08 13:23:34 +03:00
/* commad parsed -- allocate new struct for the command */
if (cmd) {
vshCmd *c = vshMalloc(ctl, sizeof(vshCmd));
2005-12-08 13:23:34 +03:00
c->opts = first;
c->def = cmd;
c->next = NULL;
2006-01-25 12:46:22 +03:00
if (!vshCommandCheckOpts(ctl, c))
goto syntaxError;
2005-12-08 13:23:34 +03:00
if (!ctl->cmd)
ctl->cmd = c;
if (clast)
clast->next = c;
clast = c;
}
}
2005-12-08 13:23:34 +03:00
return TRUE;
syntaxError:
2005-12-08 13:23:34 +03:00
if (ctl->cmd)
vshCommandFree(ctl->cmd);
if (first)
vshCommandOptFree(first);
if (tkdata)
free(tkdata);
return FALSE;
2005-12-08 13:23:34 +03:00
}
/* ---------------
* Misc utils
* ---------------
*/
2005-12-08 17:22:52 +03:00
static const char *
vshDomainStateToString(int state)
{
2005-12-08 13:23:34 +03:00
switch (state) {
case VIR_DOMAIN_RUNNING:
return "running ";
2005-12-08 13:23:34 +03:00
case VIR_DOMAIN_BLOCKED:
return "blocked ";
case VIR_DOMAIN_PAUSED:
return "paused ";
case VIR_DOMAIN_SHUTDOWN:
return "in shutdown";
case VIR_DOMAIN_SHUTOFF:
return "shut off";
default:
return "no state"; /* = dom0 state */
2005-12-08 13:23:34 +03:00
}
return NULL;
}
static int
vshConnectionUsability(vshControl * ctl, virConnectPtr conn, int showerror)
{
2005-12-08 13:23:34 +03:00
/* TODO: use something like virConnectionState() to
* check usability of the connection
*/
if (!conn) {
if (showerror)
vshError(ctl, FALSE, "no valid connection.");
return FALSE;
}
return TRUE;
}
static int
vshWantedDebug(vshOutType type, int mode)
{
switch (type) {
2005-12-08 13:23:34 +03:00
case VSH_DEBUG5:
if (mode < 5)
return FALSE;
return TRUE;
case VSH_DEBUG4:
if (mode < 4)
return FALSE;
return TRUE;
case VSH_DEBUG3:
if (mode < 3)
return FALSE;
return TRUE;
case VSH_DEBUG2:
if (mode < 2)
return FALSE;
return TRUE;
case VSH_DEBUG1:
if (mode < 1)
return FALSE;
return TRUE;
default:
/* it's right, all others types have to pass */
return TRUE;
}
return FALSE;
}
static void
vshPrint(vshControl * ctl, vshOutType type, const char *format, ...)
{
2005-12-08 13:23:34 +03:00
va_list ap;
if (ctl->quiet == TRUE && (type == VSH_HEADER || type == VSH_FOOTER))
2005-12-08 13:23:34 +03:00
return;
if (!vshWantedDebug(type, ctl->debug))
return;
2005-12-08 13:23:34 +03:00
va_start(ap, format);
vfprintf(stdout, format, ap);
2005-12-08 13:23:34 +03:00
va_end(ap);
}
static void
vshError(vshControl * ctl, int doexit, const char *format, ...)
{
2005-12-08 13:23:34 +03:00
va_list ap;
2005-12-08 13:23:34 +03:00
if (doexit)
fprintf(stderr, "%s: error: ", progname);
else
fputs("error: ", stderr);
2005-12-08 13:23:34 +03:00
va_start(ap, format);
vfprintf(stderr, format, ap);
va_end(ap);
fputc('\n', stderr);
2005-12-08 13:23:34 +03:00
if (doexit) {
if (ctl)
vshDeinit(ctl);
2005-12-08 13:23:34 +03:00
exit(EXIT_FAILURE);
}
}
static void *
_vshMalloc(vshControl * ctl, size_t size, const char *filename, int line)
{
void *x;
if ((x = malloc(size)))
return x;
vshError(ctl, TRUE, "%s: %d: failed to allocate %d bytes\n",
filename, line, (int) size);
return NULL;
}
static void *
_vshCalloc(vshControl * ctl, size_t nmemb, size_t size, const char *filename, int line)
{
void *x;
if ((x = calloc(nmemb, size)))
return x;
vshError(ctl, TRUE, "%s: %d: failed to allocate %d bytes\n",
filename, line, (int) (size*nmemb));
return NULL;
}
static char *
_vshStrdup(vshControl * ctl, const char *s, const char *filename, int line)
{
char *x;
if ((x = strdup(s)))
return x;
vshError(ctl, TRUE, "%s: %d: failed to allocate %d bytes\n",
filename, line, strlen(s));
return NULL;
}
2005-12-08 13:23:34 +03:00
/*
* Initialize vistsh
*/
static int
vshInit(vshControl * ctl)
{
2005-12-08 13:23:34 +03:00
if (ctl->conn)
return FALSE;
ctl->uid = getuid();
/* set up the library error handler */
virSetErrorFunc(NULL, virshErrorHandler);
2005-12-08 13:23:34 +03:00
/* basic connection to hypervisor */
if (ctl->uid == 0)
ctl->conn = virConnectOpen(NULL);
else
ctl->conn = virConnectOpenReadOnly(NULL);
2005-12-08 13:23:34 +03:00
if (!ctl->conn)
vshError(ctl, TRUE, "failed to connect to the hypervisor");
return TRUE;
}
/* -----------------
* Readline stuff
* -----------------
*/
/*
* Generator function for command completion. STATE lets us
* know whether to start from scratch; without any state
* (i.e. STATE == 0), then we start at the top of the list.
*/
static char *
vshReadlineCommandGenerator(const char *text, int state)
{
2005-12-08 13:23:34 +03:00
static int list_index, len;
2005-12-08 17:22:52 +03:00
const char *name;
2005-12-08 13:23:34 +03:00
/* If this is a new word to complete, initialize now. This
* includes saving the length of TEXT for efficiency, and
* initializing the index variable to 0.
*/
if (!state) {
list_index = 0;
len = strlen(text);
2005-12-08 13:23:34 +03:00
}
/* Return the next name which partially matches from the
* command list.
*/
2005-12-08 17:22:52 +03:00
while ((name = commands[list_index].name)) {
2005-12-08 13:23:34 +03:00
list_index++;
if (strncmp(name, text, len) == 0)
return vshStrdup(NULL, name);
2005-12-08 13:23:34 +03:00
}
/* If no names matched, then return NULL. */
return NULL;
}
static char *
vshReadlineOptionsGenerator(const char *text, int state)
{
2005-12-08 13:23:34 +03:00
static int list_index, len;
static vshCmdDef *cmd = NULL;
2005-12-08 17:22:52 +03:00
const char *name;
2005-12-08 13:23:34 +03:00
if (!state) {
/* determine command name */
char *p;
char *cmdname;
if (!(p = strchr(rl_line_buffer, ' ')))
return NULL;
cmdname = vshCalloc(NULL, (p - rl_line_buffer) + 1, 1);
memcpy(cmdname, rl_line_buffer, p - rl_line_buffer);
2005-12-08 13:23:34 +03:00
cmd = vshCmddefSearch(cmdname);
list_index = 0;
len = strlen(text);
2005-12-08 13:23:34 +03:00
free(cmdname);
}
if (!cmd)
return NULL;
2005-12-08 17:22:52 +03:00
while ((name = cmd->opts[list_index].name)) {
2005-12-08 13:23:34 +03:00
vshCmdOptDef *opt = &cmd->opts[list_index];
char *res;
2005-12-08 13:23:34 +03:00
list_index++;
2005-12-08 17:22:52 +03:00
if (opt->type == VSH_OT_DATA)
2005-12-08 13:23:34 +03:00
/* ignore non --option */
continue;
2005-12-08 13:23:34 +03:00
if (len > 2) {
if (strncmp(name, text + 2, len - 2))
2005-12-08 13:23:34 +03:00
continue;
}
res = vshMalloc(NULL, strlen(name) + 3);
2005-12-08 13:23:34 +03:00
sprintf(res, "--%s", name);
return res;
}
/* If no names matched, then return NULL. */
return NULL;
}
static char **
vshReadlineCompletion(const char *text, int start,
int end ATTRIBUTE_UNUSED)
{
2005-12-08 13:23:34 +03:00
char **matches = (char **) NULL;
if (start == 0)
2005-12-08 13:23:34 +03:00
/* command name generator */
matches = rl_completion_matches(text, vshReadlineCommandGenerator);
2005-12-08 13:23:34 +03:00
else
/* commands options */
matches = rl_completion_matches(text, vshReadlineOptionsGenerator);
2005-12-08 13:23:34 +03:00
return matches;
}
static void
vshReadlineInit(void)
{
2005-12-08 13:23:34 +03:00
/* Allow conditional parsing of the ~/.inputrc file. */
rl_readline_name = "virsh";
/* Tell the completer that we want a crack first. */
rl_attempted_completion_function = vshReadlineCompletion;
}
/*
* Deinitliaze virsh
*/
static int
vshDeinit(vshControl * ctl)
{
2005-12-08 13:23:34 +03:00
if (ctl->conn) {
if (virConnectClose(ctl->conn) != 0) {
ctl->conn = NULL; /* prevent recursive call from vshError() */
vshError(ctl, TRUE,
"failed to disconnect from the hypervisor");
2005-12-08 13:23:34 +03:00
}
}
return TRUE;
}
2005-12-08 13:23:34 +03:00
/*
* Print usage
*/
static void
vshUsage(vshControl * ctl, const char *cmdname)
{
2005-12-08 13:23:34 +03:00
vshCmdDef *cmd;
2005-12-08 13:23:34 +03:00
/* global help */
if (!cmdname) {
fprintf(stdout, "\n%s [options] [commands]\n\n"
" options:\n"
" -d | --debug <num> debug level [0-5]\n"
" -h | --help this help\n"
" -q | --quiet quiet mode\n"
" -t | --timing print timing information\n"
" -v | --version program version\n\n"
" commands (non interactive mode):\n", progname);
for (cmd = commands; cmd->name; cmd++)
fprintf(stdout,
" %-15s %s\n", cmd->name, vshCmddefGetInfo(cmd,
"help"));
fprintf(stdout,
"\n (specify --help <command> for details about the command)\n\n");
2005-12-08 13:23:34 +03:00
return;
}
if (!vshCmddefHelp(ctl, cmdname, TRUE))
exit(EXIT_FAILURE);
}
/*
* argv[]: virsh [options] [command]
*
*/
static int
vshParseArgv(vshControl * ctl, int argc, char **argv)
{
2005-12-08 13:23:34 +03:00
char *last = NULL;
int i, end = 0, help = 0;
int arg, idx = 0;
2005-12-08 13:23:34 +03:00
struct option opt[] = {
{"debug", 1, 0, 'd'},
{"help", 0, 0, 'h'},
{"quiet", 0, 0, 'q'},
{"timing", 0, 0, 't'},
{"version", 0, 0, 'v'},
2005-12-08 13:23:34 +03:00
{0, 0, 0, 0}
};
2005-12-08 13:23:34 +03:00
if (argc < 2)
2005-12-08 17:22:52 +03:00
return TRUE;
2006-01-25 12:46:22 +03:00
/* look for begin of the command, for example:
2005-12-08 13:23:34 +03:00
* ./virsh --debug 5 -q command --cmdoption
* <--- ^ --->
* getopt() stuff | command suff
*/
for (i = 1; i < argc; i++) {
2005-12-08 13:23:34 +03:00
if (*argv[i] != '-') {
int valid = FALSE;
2005-12-08 13:23:34 +03:00
/* non "--option" argv, is it command? */
if (last) {
struct option *o;
int sz = strlen(last);
for (o = opt; o->name; o++) {
if (sz == 2 && *(last + 1) == o->val)
2005-12-08 13:23:34 +03:00
/* valid virsh short option */
valid = TRUE;
else if (sz > 2 && strcmp(o->name, last + 2) == 0)
2005-12-08 13:23:34 +03:00
/* valid virsh long option */
valid = TRUE;
}
}
if (!valid) {
end = i;
break;
}
}
last = argv[i];
}
end = end ? : argc;
2005-12-08 13:23:34 +03:00
/* standard (non-command) options */
while ((arg = getopt_long(end, argv, "d:hqtv", opt, &idx)) != -1) {
switch (arg) {
2005-12-08 13:23:34 +03:00
case 'd':
ctl->debug = atoi(optarg);
break;
case 'h':
help = 1;
break;
case 'q':
ctl->quiet = TRUE;
break;
case 't':
ctl->timing = TRUE;
break;
case 'v':
fprintf(stdout, "%s\n", VERSION);
exit(EXIT_SUCCESS);
default:
vshError(ctl, TRUE,
"unsupported option '-%c'. See --help.", arg);
2005-12-08 13:23:34 +03:00
break;
}
}
if (help) {
/* global or command specific help */
vshUsage(ctl, argc > end ? argv[end] : NULL);
exit(EXIT_SUCCESS);
}
2005-12-08 13:23:34 +03:00
if (argc > end) {
/* parse command */
char *cmdstr;
int sz = 0, ret;
2005-12-08 13:23:34 +03:00
ctl->imode = FALSE;
for (i = end; i < argc; i++)
sz += strlen(argv[i]) + 1; /* +1 is for blank space between items */
cmdstr = vshCalloc(ctl, sz + 1, 1);
for (i = end; i < argc; i++) {
2005-12-08 13:23:34 +03:00
strncat(cmdstr, argv[i], sz);
sz -= strlen(argv[i]);
strncat(cmdstr, " ", sz--);
}
vshPrint(ctl, VSH_DEBUG2, "command: \"%s\"\n", cmdstr);
ret = vshCommandParse(ctl, cmdstr);
2005-12-08 13:23:34 +03:00
free(cmdstr);
return ret;
}
return TRUE;
}
int
main(int argc, char **argv)
{
vshControl _ctl, *ctl = &_ctl;
2005-12-08 13:23:34 +03:00
int ret = TRUE;
if (!(progname = strrchr(argv[0], '/')))
2005-12-08 13:23:34 +03:00
progname = argv[0];
else
progname++;
2005-12-08 13:23:34 +03:00
memset(ctl, 0, sizeof(vshControl));
ctl->imode = TRUE; /* default is interactive mode */
2005-12-08 13:23:34 +03:00
if (!vshParseArgv(ctl, argc, argv))
exit(EXIT_FAILURE);
2005-12-08 13:23:34 +03:00
if (!vshInit(ctl))
exit(EXIT_FAILURE);
2005-12-08 13:23:34 +03:00
if (!ctl->imode) {
ret = vshCommandRun(ctl, ctl->cmd);
} else {
2005-12-08 13:23:34 +03:00
/* interactive mode */
if (!ctl->quiet) {
vshPrint(ctl, VSH_MESG,
"Welcome to %s, the virtualization interactive terminal.\n\n",
progname);
vshPrint(ctl, VSH_MESG,
"Type: 'help' for help with commands\n"
" 'quit' to quit\n\n");
2005-12-08 13:23:34 +03:00
}
2005-12-08 17:22:52 +03:00
vshReadlineInit();
2005-12-08 13:23:34 +03:00
do {
ctl->cmdstr =
readline(ctl->uid == 0 ? VSH_PROMPT_RW : VSH_PROMPT_RO);
if (ctl->cmdstr == NULL)
break; /* EOF */
2005-12-08 13:23:34 +03:00
if (*ctl->cmdstr) {
add_history(ctl->cmdstr);
if (vshCommandParse(ctl, ctl->cmdstr))
vshCommandRun(ctl, ctl->cmd);
}
free(ctl->cmdstr);
ctl->cmdstr = NULL;
} while (ctl->imode);
2005-12-08 13:23:34 +03:00
if (ctl->cmdstr == NULL)
fputc('\n', stdout); /* line break after alone prompt */
2005-12-08 13:23:34 +03:00
}
2005-12-08 13:23:34 +03:00
vshDeinit(ctl);
exit(ret ? EXIT_SUCCESS : EXIT_FAILURE);
}
2005-12-08 13:23:34 +03:00
/*
* vim: set tabstop=4:
* vim: set shiftwidth=4:
* vim: set expandtab:
*/