action.cpp

/*
 vdev: a virtual device manager for *nix
 Copyright (C) 2014 Jude Nelson

 This program is dual-licensed: you can redistribute it and/or modify
 it under the terms of the GNU General Public License version 3 or later as 
 published by the Free Software Foundation. For the terms of this 
 license, see LICENSE.LGPLv3+ or <http://www.gnu.org/licenses/>.

 You are free to use this program under the terms of the GNU General
 Public License, but WITHOUT ANY WARRANTY; without even the implied 
 warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 See the GNU General Public License for more details.

 Alternatively, you are free to use this program under the terms of the 
 Internet Software Consortium License, but WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 For the terms of this license, see LICENSE.ISC or 
 <http://www.isc.org/downloads/software-support-policy/isc-license/>.
*/
#include "action.h"
#include "match.h"

#define INI_MAX_LINE 4096
#define INI_STOP_ON_FIRST_ERROR 1

#include "ini.h"

// initialize an action 
int vdev_action_init( struct vdev_action* act, vdev_device_request_t trigger, char* path, char* command, bool async ) {
 
 int rc = 0;
 memset( act, 0, sizeof(struct vdev_action) );
 
 act->dev_params = new (nothrow) vdev_device_params_t();
 
 if( act->dev_params == NULL ) {
 return -ENOMEM;
 }
 
 act->trigger = trigger;
 act->path = vdev_strdup_or_null( path );
 act->command = vdev_strdup_or_null( command );
 act->async = async;
 
 if( act->path != NULL ) {
 
 rc = vdev_match_regex_init( &act->path_regex, path );
 
 if( rc != 0 ) {
 
 vdev_error("vdev_match_regex_init('%s') rc = %d\n", path );
 vdev_action_free( act );
 return rc;
 }
 }
 
 return 0;
}

// add a device parameter to match on 
int vdev_action_add_param( struct vdev_action* act, char const* name, char const* value ) {
 
 try {
 (*act->dev_params)[ string(name) ] = string(value);
 return 0;
 }
 catch( bad_alloc& ba ) {
 return -ENOMEM;
 }
}

// free an action 
int vdev_action_free( struct vdev_action* act ) {
 
 if( act->command != NULL ) {
 
 free( act->command );
 act->command = NULL;
 }
 
 if( act->rename_command != NULL ) {
 
 free( act->rename_command );
 act->rename_command = NULL;
 }
 
 if( act->dev_params != NULL ) {
 
 delete act->dev_params;
 act->dev_params = NULL;
 }
 
 if( act->path != NULL ) {
 
 free( act->path );
 act->path = NULL;
 
 
 regfree( &act->path_regex );
 }
 
 return 0;
}


// convert an action into a device request 
vdev_device_request_t vdev_action_parse_trigger( char const* type ) {
 
 if( strcmp(type, VDEV_ACTION_EVENT_ADD) == 0 ) {
 return VDEV_DEVICE_ADD;
 }
 else if( strcmp(type, VDEV_ACTION_EVENT_REMOVE) == 0 ) {
 return VDEV_DEVICE_REMOVE;
 }
 else if( strcmp(type, VDEV_ACTION_EVENT_ANY) == 0 ) {
 return VDEV_DEVICE_ANY;
 }
 
 return VDEV_DEVICE_INVALID;
}

// parse an action from an ini file 
// return 1 for parsed
// return 0 for not parsed
static int vdev_action_ini_parser( void* userdata, char const* section, char const* name, char const* value ) {
 
 struct vdev_action* act = (struct vdev_action*)userdata;
 int rc = 0;
 
 if( strcmp(section, VDEV_ACTION_NAME) == 0 ) {
 
 if( strcmp(name, VDEV_ACTION_NAME_PATH) == 0 ) {
 // path?
 if( act->path != NULL ) {
 
 free( act->path );
 }
 
 act->path = vdev_strdup_or_null( value );
 
 if( act->path == NULL ) {
 // EOM
 return 0;
 } 
 else {
 rc = vdev_match_regex_init( &act->path_regex, act->path );
 
 if( rc != 0 ) {
 
 vdev_error("vdev_match_regex_init('%s') rc = %d\n", act->path );
 return 0;
 }
 }
 return 1;
 }
 
 if( strcmp(name, VDEV_ACTION_NAME_RENAME) == 0 ) {
 
 // rename command 
 if( act->rename_command != NULL ) {
 
 free( act->rename_command );
 }
 
 act->rename_command = vdev_strdup_or_null( value );
 return 1;
 }
 
 if( strcmp(name, VDEV_ACTION_NAME_EVENT) == 0 ) {
 
 // event?
 act->trigger = vdev_action_parse_trigger( value );
 
 if( act->trigger == VDEV_DEVICE_INVALID ) {
 
 fprintf(stderr, "Invalid event type '%s'\n", value);
 return 0;
 }
 else {
 return 1;
 }
 }
 
 if( strcmp(name, VDEV_ACTION_NAME_SHELL) == 0 ) {
 
 // shell command 
 if( act->command != NULL ) {
 
 free( act->command );
 }
 
 act->command = vdev_strdup_or_null( value );
 return 1;
 }
 
 if( strcmp(name, VDEV_ACTION_NAME_ASYNC) == 0 ) {
 
 // async?
 if( strcasecmp(value, "true") == 0 || strcmp(value, "1") == 0 ) {
 
 act->async = true;
 return 1;
 }
 else if( strcasecmp(value, "false") == 0 || strcmp(value, "0") == 0 ) {
 
 act->async = false;
 return 1;
 }
 else {
 
 fprintf(stderr, "Invalid async value '%s'\n", value);
 return 0;
 }
 }
 
 
 if( strncmp(name, VDEV_ACTION_NAME_OS_PREFIX, strlen(VDEV_ACTION_NAME_OS_PREFIX)) == 0 ) {
 
 // OS-specific param 
 rc = vdev_action_add_param( act, name + strlen(VDEV_ACTION_NAME_OS_PREFIX), value );
 
 if( rc == 0 ) {
 return 1;
 }
 else {
 vdev_error("vdev_action_add_param( '%s', '%s' ) rc = %d\n", name, value, rc );
 return 0;
 }
 }
 
 fprintf(stderr, "Unknown field '%s' in section '%s'\n", name, section );
 return 0;
 }
 
 fprintf(stderr, "Unknown section '%s'\n", section);
 return 0;
}

// sanity check an action 
// return 0 on success
// return negative on invalid 
int vdev_action_sanity_check( struct vdev_action* act ) {
 
 int rc = 0;
 
 if( act->command == NULL && act->rename_command == NULL ) {
 
 fprintf(stderr, "Action is missing 'command=' or 'rename_command='\n");
 rc = -EINVAL;
 }
 
 if( act->trigger == VDEV_DEVICE_INVALID ) {
 
 fprintf(stderr, "Action is missing 'event='\n");
 rc = -EINVAL;
 }
 
 return rc;
}

// load an action from a path
int vdev_action_load( char const* path, struct vdev_action* act ) {
 
 int rc = 0;
 FILE* f = NULL;
 
 rc = vdev_action_init( act, VDEV_DEVICE_INVALID, NULL, NULL, false );
 if( rc != 0 ) {
 
 vdev_error("vdev_action_init('%s') rc = %d\n", path );
 return rc;
 }
 
 f = fopen( path, "r" );
 if( f == NULL ) {
 
 vdev_action_free( act );
 rc = -errno;
 
 return rc;
 }
 
 rc = vdev_action_load_file( f, act );
 
 fclose( f );
 
 if( rc == -EINVAL ) {
 
 vdev_action_free( act );
 vdev_error("Invalid action '%s'\n", path );
 }
 
 return rc;
}


// load an action from a file
int vdev_action_load_file( FILE* f, struct vdev_action* act ) {
 
 int rc = 0;
 
 rc = ini_parse_file( f, vdev_action_ini_parser, act );
 if( rc != 0 ) {
 vdev_error("ini_parse_file(action) rc = %d\n", rc );
 }
 else {
 rc = vdev_action_sanity_check( act );
 }
 
 return rc;
}

// free a vector of actions
static void vdev_action_free_vector( vector<struct vdev_action>* acts ) {
 
 for( unsigned int i = 0; i < acts->size(); i++ ) {
 
 vdev_action_free( &acts->at(i) );
 }
 
 acts->clear();
}

// free a C-style list of actions (including the list itself)
int vdev_action_free_all( struct vdev_action* act_list, size_t num_acts ) {
 
 int rc = 0;
 
 for( unsigned int i = 0; i < num_acts; i++ ) {
 
 rc = vdev_action_free( &act_list[i] );
 if( rc != 0 ) {
 return rc;
 }
 }
 
 free( act_list );
 
 return rc;
}


// action loader 
int vdev_action_loader( char const* path, void* cls ) {
 
 int rc = 0;
 struct vdev_action act;
 struct stat sb;
 
 // skip if not a regular file 
 rc = stat( path, &sb );
 if( rc != 0 ) {
 
 rc = -errno;
 vdev_error("stat(%s) rc = %d\n", path, rc );
 return rc;
 }
 
 if( !S_ISREG( sb.st_mode ) ) {
 
 return 0;
 }
 
 vdev_debug("Load Action %s\n", path );
 
 vector<struct vdev_action>* acts = (vector<struct vdev_action>*)cls;

 memset( &act, 0, sizeof(struct vdev_action) );
 
 rc = vdev_action_load( path, &act );
 if( rc != 0 ) {
 
 vdev_error("vdev_acl_load(%s) rc = %d\n", path, rc );
 return rc;
 }
 
 // save this action 
 try {
 acts->push_back( act );
 }
 catch( bad_alloc& ba ) {
 
 return -ENOMEM;
 }
 
 return 0;
}


// load all actions in a directory
// return 0 on success
// return negative on error
int vdev_action_load_all( char const* dir_path, struct vdev_action** ret_acts, size_t* ret_num_acts ) {
 
 int rc = 0;
 vector<struct vdev_action> acts;
 
 rc = vdev_load_all( dir_path, vdev_action_loader, &acts );
 
 if( rc != 0 ) {
 
 vdev_action_free_vector( &acts );
 return rc;
 }
 else {
 
 if( acts.size() == 0 ) {
 
 // nothing 
 *ret_acts = NULL;
 *ret_num_acts = 0;
 }
 else {
 
 // extract values
 struct vdev_action* act_list = VDEV_CALLOC( struct vdev_action, acts.size() );
 if( act_list == NULL ) {
 
 vdev_action_free_vector( &acts );
 return -ENOMEM; 
 }
 
 // NOTE: vectors are contiguous in memory 
 memcpy( act_list, &acts[0], sizeof(struct vdev_action) * acts.size() );
 
 *ret_acts = act_list;
 *ret_num_acts = acts.size();
 }
 }
 
 return 0;
}


// carry out a command, synchronously, using an environment given by vreq.
// return the exit status on success (non-negative)
// return negative on error
int vdev_action_run_sync( struct vdev_device_request* vreq, char const* command, char** output, size_t max_output ) {
 
 int rc = 0;
 int exit_status = 0;
 char** req_env = NULL;
 size_t num_env = 0;
 
 // convert to environment variables
 rc = vdev_device_request_to_env( vreq, &req_env, &num_env );
 if( rc != 0 ) {
 
 vdev_error("vdev_device_request_to_env(%s) rc = %d\n", vreq->path, rc );
 return rc;
 }
 
 vdev_debug("run command: '%s'\n", command );
 
 for( unsigned int i = 0; i < num_env; i++ ) {
 vdev_debug("command env: '%s'\n", req_env[i] );
 }
 
 rc = vdev_subprocess( command, req_env, output, max_output, &exit_status );
 
 if( output != NULL && *output != NULL ) {
 
 vdev_debug("command output: '%s'\n", *output );
 }
 
 VDEV_FREE_LIST( req_env );
 
 if( rc != 0 ) {
 
 vdev_error("vdev_subprocess('%s') rc = %d\n", command, rc );
 
 return rc;
 }
 
 if( exit_status != 0 ) {
 
 vdev_error("vdev_subprocess('%s') exit status = %d\n", command, exit_status );
 }
 
 return exit_status;
}


// carry out an action, asynchronously.
// return 0 if we were able to fork 
int vdev_action_run_async( struct vdev_device_request* req, char const* command ) {
 
 int rc = 0;
 pid_t pid = 0;
 int max_fd = 0;
 
 pid = fork();
 
 if( pid == 0 ) {
 
 // child 
 max_fd = sysconf(_SC_OPEN_MAX);
 
 // close everything 
 for( int i = 0; i < max_fd; i++ ) {
 close( i );
 }
 
 clearenv();
 
 // generate the environment 
 char** env = NULL;
 size_t num_env = 0;
 
 rc = vdev_device_request_to_env( req, &env, &num_env );
 if( rc != 0 ) {
 
 vdev_error("vdev_device_request_to_env('%s') rc = %d\n", req->path, rc );
 exit(1);
 }
 
 // run the command 
 execle( "/bin/sh", "sh", "-c", command, (char*)0, env );
 
 // keep gcc happy 
 return 0;
 }
 else if( pid > 0 ) {
 
 // parent; succeeded
 return 0;
 }
 else {
 
 // error 
 rc = -errno;
 vdev_error("fork() rc = %d\n", rc);
 
 return rc;
 }
}


// match device request against action
// return 1 if match
// return 0 if not match 
int vdev_action_match( struct vdev_device_request* vreq, struct vdev_action* act ) {
 
 int rc = 0;
 
 // action match?
 if( act->trigger != vreq->type && act->trigger != VDEV_DEVICE_ANY ) {
 return 0;
 }
 
 // path match?
 if( act->path != NULL ) {
 
 rc = vdev_match_regex( vreq->path, &act->path_regex );
 if( rc == 0 ) {
 
 // no match 
 return 0;
 }
 if( rc < 0 ) {
 
 // some error
 return rc;
 }
 }
 
 // OS parameter match?
 if( act->dev_params != NULL ) {
 
 for( vdev_device_params_t::iterator itr = act->dev_params->begin(); itr != act->dev_params->end(); itr++ ) {
 
 const string& act_param_name = itr->first;
 
 vdev_device_params_t::iterator vreq_itr = vreq->params->find( act_param_name );
 
 if( vreq_itr != vreq->params->end() ) {
 
 // vreq has this parameter
 char const* vreq_param_value = vreq_itr->second.c_str();
 char const* act_param_value = itr->second.c_str();
 
 // if the action has no value (value of length 0), then it matches any vreq value 
 if( strlen( vreq_param_value ) == 0 ) {
 continue;
 }
 
 // otherwise, compare the values
 if( strcmp( vreq_param_value, act_param_value ) != 0 ) {
 
 // values don't match 
 return 0;
 }
 }
 else {
 
 // vreq does not have this parameter, so no match 
 return 0;
 }
 }
 }
 
 // match!
 return 1;
}

// find the next action in a list of actions to run, given the path 
// return the index into acts of the next match, if found 
// return num_acts if not found 
// return negative on error
int vdev_action_find_next( struct vdev_device_request* vreq, struct vdev_action* acts, size_t num_acts ) {
 
 int rc = 0;
 int i = 0;
 
 for( i = 0; (unsigned)i < num_acts; i++ ) {
 
 rc = vdev_action_match( vreq, &acts[i] );
 
 if( rc > 0 ) {
 return i;
 }
 else if( rc < 0 ) {
 return rc;
 }
 }
 
 return num_acts;
}


// find the path to create for the given device request.
// *path will be filled in with path to the device node, relative to the mountpoint. *path must be NULL on call.
// return 0 on success
// return negative on failure 
int vdev_action_create_path( struct vdev_device_request* vreq, struct vdev_action* acts, size_t num_acts, char** path ) {
 
 int rc = 0;
 int act_offset = 0;
 int i = 0;
 char* new_path = NULL;
 
 if( *path != NULL ) {
 return -EINVAL;
 }
 
 while( act_offset < (signed)num_acts ) {
 
 // skip this action if there is no rename command 
 if( acts[act_offset].rename_command == NULL ) {
 act_offset++;
 continue;
 }
 
 // find the next action that matches this path
 rc = vdev_action_find_next( vreq, acts + act_offset, num_acts - act_offset );
 
 if( rc == (signed)(num_acts - act_offset) ) {
 
 // not found 
 rc = 0;
 break;
 }
 else if( rc < 0 ) {
 
 // error
 vdev_error("vdev_action_find_next(%s, offset = %d) rc = %d\n", vreq->path, act_offset, rc );
 break;
 }
 else {
 
 // matched! advance offset to next action
 i = act_offset + rc;
 act_offset += rc + 1;
 
 if( acts[i].rename_command == NULL ) {
 continue;
 }
 
 // generate the new name
 rc = vdev_action_run_sync( vreq, acts[i].rename_command, &new_path, PATH_MAX + 1 );
 if( rc < 0 ) {
 
 vdev_error("vdev_action_run_sync('%s') rc = %d\n", acts[i].rename_command, rc );
 break;
 }
 else {
 
 if( *path != NULL ) {
 free( *path );
 }
 
 *path = new_path;
 new_path = NULL;
 }
 }
 
 rc = 0;
 }
 
 return rc;
}


// run all actions for a device, sequentially, in lexographic order
// return 0 on success
// return negative on failure
int vdev_action_run_commands( struct vdev_device_request* vreq, struct vdev_action* acts, size_t num_acts ) {
 
 int rc = 0;
 int act_offset = 0;
 int i = 0;
 char const* method = NULL;
 
 while( act_offset < (signed)num_acts ) {
 
 // skip this action if there is no command 
 if( acts[act_offset].command == NULL ) {
 act_offset++;
 continue;
 }
 
 // find the next action that matches this path 
 rc = vdev_action_find_next( vreq, acts + act_offset, num_acts - act_offset );
 
 if( rc == (signed)(num_acts - act_offset) ) {
 
 // not found 
 rc = 0;
 break;
 }
 else if( rc < 0 ) {
 
 vdev_error("vdev_action_find_next(%s, offset = %d) rc = %d\n", vreq->path, act_offset, rc );
 break;
 }
 else {
 
 // matched! advance offset to next action
 i = act_offset + rc;
 act_offset += rc + 1;
 
 rc = 0;
 
 if( acts[i].command == NULL ) {
 continue;
 }
 
 // what kind of action?
 if( acts[i].async ) {
 
 method = "vdev_action_run_async";
 rc = vdev_action_run_async( vreq, acts[i].command );
 }
 else {
 
 method = "vdev_action_run_sync";
 rc = vdev_action_run_sync( vreq, acts[i].command, NULL, 0 );
 }
 
 if( rc != 0 ) {
 
 vdev_error("%s('%s') rc = %d\n", method, acts[i].command, rc );
 return rc;
 }
 }
 }
 
 return rc;
}