/* mod_del_cmd
*
* inputs - command name
* output - none
* side effects - unload this one command name
*/
void
mod_del_cmd(struct Message *msg)
{
struct MessageHash *ptr;
struct MessageHash *last_ptr = NULL;
int msgindex;
s_assert(msg != NULL);
if(msg == NULL)
return;
msgindex = cmd_hash(msg->cmd);
for (ptr = msg_hash_table[msgindex]; ptr; ptr = ptr->next)
{
if(strcasecmp(msg->cmd, ptr->cmd) == 0)
{
MyFree(ptr->cmd);
if(last_ptr != NULL)
last_ptr->next = ptr->next;
else
msg_hash_table[msgindex] = ptr->next;
MyFree(ptr);
return;
}
last_ptr = ptr;
}
}
/* hash_parse
*
* inputs - command name
* output - pointer to struct Message
* side effects -
*/
static struct Message *
hash_parse(const char *cmd)
{
struct MessageHash *ptr;
int msgindex;
msgindex = cmd_hash(cmd);
for (ptr = msg_hash_table[msgindex]; ptr; ptr = ptr->next)
{
if(strcasecmp(cmd, ptr->cmd) == 0)
return (ptr->msg);
}
return NULL;
}
/* mod_add_cmd
*
* inputs - command name
* - pointer to struct Message
* output - none
* side effects - load this one command name
* msg->count msg->bytes is modified in place, in
* modules address space. Might not want to do that...
*/
void
mod_add_cmd(struct Message *msg)
{
struct MessageHash *ptr;
struct MessageHash *last_ptr = NULL;
struct MessageHash *new_ptr;
int msgindex;
s_assert(msg != NULL);
if(msg == NULL)
return;
msgindex = cmd_hash(msg->cmd);
for (ptr = msg_hash_table[msgindex]; ptr; ptr = ptr->next)
{
if(strcasecmp(msg->cmd, ptr->cmd) == 0)
return; /* Its already added */
last_ptr = ptr;
}
new_ptr = (struct MessageHash *) MyMalloc(sizeof(struct MessageHash));
new_ptr->next = NULL;
DupString(new_ptr->cmd, msg->cmd);
new_ptr->msg = msg;
msg->count = 0;
msg->rcount = 0;
msg->bytes = 0;
if(last_ptr == NULL)
msg_hash_table[msgindex] = new_ptr;
else
last_ptr->next = new_ptr;
}
int
main(int ac, char **av)
{
const char *sel_path = NULL;
const char *uuid_str = NULL;
const char *arg;
int pfs_type = HAMMER2_PFSTYPE_NONE;
int all_opt = 0;
int ecode = 0;
int ch;
srandomdev();
signal(SIGPIPE, SIG_IGN);
dmsg_crypto_setup();
/*
* Core options
*/
while ((ch = getopt(ac, av, "adfrqs:t:u:v")) != -1) {
switch(ch) {
case 'a':
all_opt = 1;
break;
case 'd':
DebugOpt = 1;
break;
case 'f':
ForceOpt = 1;
break;
case 'r':
RecurseOpt = 1;
break;
case 's':
sel_path = optarg;
break;
case 't':
/*
* set node type for mkpfs
*/
if (strcasecmp(optarg, "ADMIN") == 0) {
pfs_type = HAMMER2_PFSTYPE_ADMIN;
} else if (strcasecmp(optarg, "CACHE") == 0) {
pfs_type = HAMMER2_PFSTYPE_CACHE;
} else if (strcasecmp(optarg, "COPY") == 0) {
pfs_type = HAMMER2_PFSTYPE_COPY;
} else if (strcasecmp(optarg, "SLAVE") == 0) {
pfs_type = HAMMER2_PFSTYPE_SLAVE;
} else if (strcasecmp(optarg, "SOFT_SLAVE") == 0) {
pfs_type = HAMMER2_PFSTYPE_SOFT_SLAVE;
} else if (strcasecmp(optarg, "SOFT_MASTER") == 0) {
pfs_type = HAMMER2_PFSTYPE_SOFT_MASTER;
} else if (strcasecmp(optarg, "MASTER") == 0) {
pfs_type = HAMMER2_PFSTYPE_MASTER;
} else {
fprintf(stderr, "-t: Unrecognized node type\n");
usage(1);
}
break;
case 'u':
/*
* set uuid for mkpfs, else one will be generated
* (required for all except the MASTER node_type)
*/
uuid_str = optarg;
break;
case 'v':
if (QuietOpt)
--QuietOpt;
else
++VerboseOpt;
break;
case 'q':
if (VerboseOpt)
--VerboseOpt;
else
++QuietOpt;
break;
default:
fprintf(stderr, "Unknown option: %c\n", ch);
usage(1);
/* not reached */
break;
}
}
/*
* Adjust, then process the command
*/
ac -= optind;
av += optind;
if (ac < 1) {
fprintf(stderr, "Missing command\n");
usage(1);
/* not reached */
}
if (strcmp(av[0], "connect") == 0) {
/*
* Add cluster connection
*/
if (ac < 2) {
fprintf(stderr, "connect: missing argument\n");
usage(1);
}
ecode = cmd_remote_connect(sel_path, av[1]);
} else if (strcmp(av[0], "chaindump") == 0) {
if (ac < 2)
ecode = cmd_chaindump(".");
else
ecode = cmd_chaindump(av[1]);
} else if (strcmp(av[0], "debugspan") == 0) {
/*
* Debug connection to the target hammer2 service and run
* the CONN/SPAN protocol.
*/
if (ac < 2) {
fprintf(stderr, "debugspan: requires hostname\n");
usage(1);
}
ecode = cmd_debugspan(av[1]);
} else if (strcmp(av[0], "disconnect") == 0) {
/*
* Remove cluster connection
*/
if (ac < 2) {
fprintf(stderr, "disconnect: missing argument\n");
usage(1);
}
ecode = cmd_remote_disconnect(sel_path, av[1]);
} else if (strcmp(av[0], "hash") == 0) {
ecode = cmd_hash(ac - 1, (const char **)(void *)&av[1]);
} else if (strcmp(av[0], "status") == 0) {
/*
* Get status of PFS and its connections (-a for all PFSs)
*/
ecode = cmd_remote_status(sel_path, all_opt);
} else if (strcmp(av[0], "pfs-clid") == 0) {
/*
* Print cluster id (uuid) for specific PFS
*/
if (ac < 2) {
fprintf(stderr, "pfs-clid: requires name\n");
usage(1);
}
ecode = cmd_pfs_getid(sel_path, av[1], 0);
} else if (strcmp(av[0], "pfs-fsid") == 0) {
/*
* Print private id (uuid) for specific PFS
*/
if (ac < 2) {
fprintf(stderr, "pfs-fsid: requires name\n");
usage(1);
}
ecode = cmd_pfs_getid(sel_path, av[1], 1);
} else if (strcmp(av[0], "pfs-list") == 0) {
/*
* List all PFSs
*/
ecode = cmd_pfs_list(sel_path);
} else if (strcmp(av[0], "pfs-create") == 0) {
/*
* Create new PFS using pfs_type
*/
if (ac < 2) {
fprintf(stderr, "pfs-create: requires name\n");
usage(1);
}
ecode = cmd_pfs_create(sel_path, av[1], pfs_type, uuid_str);
} else if (strcmp(av[0], "pfs-delete") == 0) {
/*
* Delete a PFS by name
*/
if (ac < 2) {
fprintf(stderr, "pfs-delete: requires name\n");
usage(1);
}
ecode = cmd_pfs_delete(sel_path, av[1]);
} else if (strcmp(av[0], "snapshot") == 0) {
/*
* Create snapshot with optional pfs-type and optional
* label override.
*/
if (ac > 2) {
fprintf(stderr, "pfs-snapshot: too many arguments\n");
usage(1);
}
if (ac != 2)
ecode = cmd_pfs_snapshot(sel_path, NULL);
else
ecode = cmd_pfs_snapshot(sel_path, av[1]);
} else if (strcmp(av[0], "service") == 0) {
/*
* Start the service daemon. This daemon accepts
* connections from local and remote clients, handles
* the security handshake, and manages the core messaging
* protocol.
*/
ecode = cmd_service();
} else if (strcmp(av[0], "stat") == 0) {
ecode = cmd_stat(ac - 1, (const char **)(void *)&av[1]);
} else if (strcmp(av[0], "leaf") == 0) {
/*
* Start the management daemon for a specific PFS.
*
* This will typically connect to the local master node
* daemon, register the PFS, and then pass its side of
* the socket descriptor to the kernel HAMMER2 VFS via an
* ioctl(). The process and/or thread context remains in the
* kernel until the PFS is unmounted or the connection is
* lost, then returns from the ioctl.
*
* It is possible to connect directly to a remote master node
* instead of the local master node in situations where
* encryption is not desired or no local master node is
* desired. This is not recommended because it represents
* a single point of failure for the PFS's communications.
*
* Direct kernel<->kernel communication between HAMMER2 VFSs
* is theoretically possible for directly-connected
* registrations (i.e. where the spanning tree is degenerate),
* but not recommended. We specifically try to reduce the
* complexity of the HAMMER2 VFS kernel code.
*/
ecode = cmd_leaf(sel_path);
} else if (strcmp(av[0], "shell") == 0) {
/*
* Connect to the command line monitor in the hammer2 master
* node for the machine using HAMMER2_DBG_SHELL messages.
*/
ecode = cmd_shell((ac < 2) ? NULL : av[1]);
} else if (strcmp(av[0], "rsainit") == 0) {
/*
* Initialize a RSA keypair. If no target directory is
* specified we default to "/etc/hammer2".
*/
arg = (ac < 2) ? HAMMER2_DEFAULT_DIR : av[1];
ecode = cmd_rsainit(arg);
} else if (strcmp(av[0], "rsaenc") == 0) {
/*
* Encrypt the input symmetrically by running it through
* the specified public and/or private key files.
*
* If no key files are specified data is encoded using
* "/etc/hammer2/rsa.pub".
*
* WARNING: no padding is added, data stream must contain
* random padding for this to be secure.
*
* Used for debugging only
*/
if (ac == 1) {
const char *rsapath = HAMMER2_DEFAULT_DIR "/rsa.pub";
ecode = cmd_rsaenc(&rsapath, 1);
} else {
ecode = cmd_rsaenc((const char **)(void *)&av[1],
ac - 1);
}
} else if (strcmp(av[0], "rsadec") == 0) {
/*
* Decrypt the input symmetrically by running it through
* the specified public and/or private key files.
*
* If no key files are specified data is decoded using
* "/etc/hammer2/rsa.prv".
*
* WARNING: no padding is added, data stream must contain
* random padding for this to be secure.
*
* Used for debugging only
*/
if (ac == 1) {
const char *rsapath = HAMMER2_DEFAULT_DIR "/rsa.prv";
ecode = cmd_rsadec(&rsapath, 1);
} else {
ecode = cmd_rsadec((const char **)(void *)&av[1],
ac - 1);
}
} else if (strcmp(av[0], "show") == 0) {
/*
* Raw dump of filesystem. Use -v to check all crc's, and
* -vv to dump bulk file data.
*/
if (ac != 2) {
fprintf(stderr, "show: requires device path\n");
usage(1);
} else {
cmd_show(av[1], 0);
}
} else if (strcmp(av[0], "freemap") == 0) {
/*
* Raw dump of freemap. Use -v to check all crc's, and
* -vv to dump bulk file data.
*/
if (ac != 2) {
fprintf(stderr, "freemap: requires device path\n");
usage(1);
} else {
cmd_show(av[1], 1);
}
} else if (strcmp(av[0], "setcomp") == 0) {
if (ac < 3) {
/*
* Missing compression method and at least one
* path.
*/
fprintf(stderr,
"setcomp: requires compression method and"
"directory/file path\n");
usage(1);
} else {
/*
* Multiple paths may be specified
*/
ecode = cmd_setcomp(av[1], &av[2]);
}
} else if (strcmp(av[0], "printinode") == 0) {
if (ac != 2) {
fprintf(stderr,
"printinode: requires directory/file path\n");
usage(1);
}
else
print_inode(av[1]);
} else {
fprintf(stderr, "Unrecognized command: %s\n", av[0]);
usage(1);
}
/*
* In DebugMode we may wind up starting several pthreads in the
* original process, in which case we have to let them run and
* not actually exit.
*/
if (NormalExit) {
return (ecode);
} else {
pthread_exit(NULL);
_exit(2); /* NOT REACHED */
}
}
