static enum cmd_status cmd_mqtt_subscribe_exec(char *cmd) { int32_t cnt; uint32_t i; char *tmp; uint32_t qos; int rc; /* get param */ cnt = cmd_sscanf(cmd, "qos=%u", &qos); if ((tmp = cmd_strrchr(cmd, '\"')) == NULL) return CMD_STATUS_INVALID_ARG; *tmp = '\0'; if ((tmp = cmd_strchr(cmd, '\"')) == NULL) return CMD_STATUS_INVALID_ARG; tmp++; /* check param */ if (cnt != 1) { CMD_ERR("invalid param number %d\n", cnt); return CMD_STATUS_INVALID_ARG; } if (qos > 2) { CMD_ERR("invalid qos %d\n", qos); return CMD_STATUS_INVALID_ARG; } i = 0; while (sub_topic[i] != NULL) { i++; if (i >= MAX_SUB_TOPICS) { CMD_WRN("Subscribe topics is max\n"); return CMD_STATUS_FAIL; } } sub_topic[i] = cmd_malloc(cmd_strlen(tmp) + 1); cmd_memcpy(sub_topic[i], tmp, cmd_strlen(tmp) + 1); if (OS_MutexLock(&lock, 60000) == OS_E_TIMEOUT) return CMD_STATUS_FAIL; if ((rc = MQTTSubscribe(&client, sub_topic[i], qos, mqtt_msg_cb)) != 0) { CMD_ERR("Return code from MQTT subscribe is %d\n", rc); return CMD_STATUS_FAIL; } OS_MutexUnlock(&lock); return CMD_STATUS_OK; }
static enum cmd_status cmd_mqtt_connect_exec(char *cmd) { int32_t cnt; char addr_str[15]; uint32_t port; int32_t rc; uint32_t i; /* get param */ cnt = cmd_sscanf(cmd, "server=%15s port=%u", addr_str, &port); /* check param */ if (cnt != 2) { CMD_ERR("invalid param number %d\n", cnt); return CMD_STATUS_INVALID_ARG; } i = 10; char* address = addr_str; while ((rc = ConnectNetwork(&network, address, port)) != 0) { CMD_WRN("Return code from network connect is %d\n", rc); cmd_msleep(2000); if (!(i--)) return CMD_STATUS_FAIL; } if ((rc = MQTTConnect(&client, &connectData)) != 0) { CMD_ERR("Return code from MQTT connect is %d\n", rc); return CMD_STATUS_FAIL; } else CMD_DBG("MQTT Connected\n"); if (OS_ThreadCreate(&mqtt_bg_thread, "", cmd_mqtt_bg, NULL, OS_PRIORITY_NORMAL, CMD_MQTT_BG_THREAD_STACK_SIZE) != OS_OK) { CMD_ERR("create mqtt background failed\n"); return CMD_STATUS_FAIL; } return CMD_STATUS_OK; }
int cli_resource_print_attribute(const char *rsc, const char *attr, pe_working_set_t * data_set) { int rc = -ENXIO; node_t *current = NULL; GHashTable *params = NULL; resource_t *the_rsc = find_rsc_or_clone(rsc, data_set); const char *value = NULL; if (the_rsc == NULL) { return -ENXIO; } if (g_list_length(the_rsc->running_on) == 1) { current = the_rsc->running_on->data; } else if (g_list_length(the_rsc->running_on) > 1) { CMD_ERR("%s is active on more than one node," " returning the default value for %s", the_rsc->id, crm_str(value)); } params = g_hash_table_new_full(crm_str_hash, g_str_equal, g_hash_destroy_str, g_hash_destroy_str); if (safe_str_eq(attr_set_type, XML_TAG_ATTR_SETS)) { get_rsc_attributes(params, the_rsc, current, data_set); } else if (safe_str_eq(attr_set_type, XML_TAG_META_SETS)) { /* No need to redirect to the parent */ get_meta_attributes(params, the_rsc, current, data_set); } else { unpack_instance_attributes(data_set->input, the_rsc->xml, XML_TAG_UTILIZATION, NULL, params, NULL, FALSE, data_set->now); } crm_debug("Looking up %s in %s", attr, the_rsc->id); value = g_hash_table_lookup(params, attr); if (value != NULL) { fprintf(stdout, "%s\n", value); rc = 0; } else { CMD_ERR("Attribute '%s' not found for '%s'", attr, the_rsc->id); } g_hash_table_destroy(params); return rc; }
static int default_action_third(char *cmd) { int ret; ret = convert_command_tbl(cmd); switch(ret) { case CMD_LS: ls_type = 1; return IS_LS; break; case CMD_FIND: find_type = FIND_DEFAULT; //find . -name argv[2]; return IS_FIND; break; case CMD_GREP: return IS_GREP; break; default: CMD_ERR(cmd,"%s","This command may not support by ncurses"); } return -1; }
static enum cmd_status cmd_mqtt_disconnect_exec(char *cmd) { int32_t cnt; uint32_t tcponly; int rc; uint32_t i; /* get param */ cnt = cmd_sscanf(cmd, "tcponly=%u", &tcponly); /* check param */ if (cnt != 1) { CMD_ERR("invalid param number %d\n", cnt); return CMD_STATUS_INVALID_ARG; } if (tcponly > 1) { CMD_ERR("invalid tcponly %d\n", tcponly); return CMD_STATUS_INVALID_ARG; } OS_ThreadDelete(&mqtt_bg_thread); i = 0; while (i < MAX_SUB_TOPICS) { if (sub_topic[i] != NULL) { cmd_free(sub_topic[i]); sub_topic[i] = NULL; } i++; } if (tcponly == 0) { if ((rc = MQTTDisconnect(&client)) != 0){ CMD_ERR("Return code from MQTT disconnect is %d\n", rc); network.disconnect(&network); return CMD_STATUS_FAIL; } } else { network.disconnect(&network); } return CMD_STATUS_OK; }
int sntp_start() { if (OS_ThreadIsValid(&g_sntp_thread)) { CMD_ERR("sntp task is running\n"); return -1; } if (OS_ThreadCreate(&g_sntp_thread, "", sntp_run, NULL, OS_THREAD_PRIO_APP, SNTP_THREAD_STACK_SIZE) != OS_OK) { CMD_ERR("sntp task create failed\n"); return -1; } return 0; }
int cli_resource_print_attribute(resource_t *rsc, const char *attr, pe_working_set_t * data_set) { int rc = -ENXIO; unsigned int count = 0; GHashTable *params = NULL; const char *value = NULL; node_t *current = pe__find_active_on(rsc, &count, NULL); if (count > 1) { CMD_ERR("%s is active on more than one node," " returning the default value for %s", rsc->id, crm_str(attr)); current = NULL; } params = crm_str_table_new(); if (safe_str_eq(attr_set_type, XML_TAG_ATTR_SETS)) { get_rsc_attributes(params, rsc, current, data_set); } else if (safe_str_eq(attr_set_type, XML_TAG_META_SETS)) { /* No need to redirect to the parent */ get_meta_attributes(params, rsc, current, data_set); } else { unpack_instance_attributes(data_set->input, rsc->xml, XML_TAG_UTILIZATION, NULL, params, NULL, FALSE, data_set->now); } crm_debug("Looking up %s in %s", attr, rsc->id); value = g_hash_table_lookup(params, attr); if (value != NULL) { fprintf(stdout, "%s\n", value); rc = 0; } else { CMD_ERR("Attribute '%s' not found for '%s'", attr, rsc->id); } g_hash_table_destroy(params); return rc; }
static int cmd_wpas_parse_int(const char *value, int min, int max, int *dst) { int val; char *end; val = cmd_strtol(value, &end, 0); if (*end) { CMD_ERR("Invalid number '%s'", value); return -1; } if (val < min || val > max) { CMD_ERR("out of range value %d (%s), range is [%d, %d]\n", val, value, min, max); return -1; } *dst = val; return 0; }
static char * parse_cli_lifetime(const char *input) { char *later_s = NULL; crm_time_t *now = NULL; crm_time_t *later = NULL; crm_time_t *duration = NULL; if (input == NULL) { return NULL; } duration = crm_time_parse_duration(move_lifetime); if (duration == NULL) { CMD_ERR("Invalid duration specified: %s", move_lifetime); CMD_ERR("Please refer to" " http://en.wikipedia.org/wiki/ISO_8601#Durations" " for examples of valid durations"); return NULL; } now = crm_time_new(NULL); later = crm_time_add(now, duration); crm_time_log(LOG_INFO, "now ", now, crm_time_log_date | crm_time_log_timeofday | crm_time_log_with_timezone); crm_time_log(LOG_INFO, "later ", later, crm_time_log_date | crm_time_log_timeofday | crm_time_log_with_timezone); crm_time_log(LOG_INFO, "duration", duration, crm_time_log_date | crm_time_log_timeofday); later_s = crm_time_as_string(later, crm_time_log_date | crm_time_log_timeofday | crm_time_log_with_timezone); printf("Migration will take effect until: %s\n", later_s); crm_time_free(duration); crm_time_free(later); crm_time_free(now); return later_s; }
static enum cmd_status cmd_mqtt_unsubscribe_exec(char *cmd) { uint32_t i; char *tmp; int rc; /* get param */ if ((tmp = cmd_strrchr(cmd, '\"')) == NULL) return CMD_STATUS_INVALID_ARG; *tmp = '\0'; if ((tmp = cmd_strchr(cmd, '\"')) == NULL) return CMD_STATUS_INVALID_ARG; tmp++; i = 0; while (i < MAX_SUB_TOPICS) { if ((sub_topic[i] != NULL) && (!cmd_memcmp(sub_topic[i], tmp, cmd_strlen(tmp) + 1))) break; i++; } if (OS_MutexLock(&lock, 60000) == OS_E_TIMEOUT) return CMD_STATUS_FAIL; if ((rc = MQTTUnsubscribe(&client, tmp/*sub_topic[i]*/)) != 0) { CMD_ERR("Return code from MQTT unsubscribe is %d\n", rc); return CMD_STATUS_FAIL; } if (i == MAX_SUB_TOPICS) CMD_WRN("Unsubscribe topics is inexist\n"); else { cmd_free(sub_topic[i]); sub_topic[i] = NULL; } OS_MutexUnlock(&lock); return CMD_STATUS_OK; }
/** *This function is involed when the argc == 2, *We just action the basement of the command *may some commands need argument,so here will *make a dicision */ static int default_action(char *cmd) { int ret; ret = convert_command_tbl(cmd); switch(ret) { case CMD_LS: ls_type = 0; return IS_LS; break; case CMD_FIND: show_find_usage(); break; case CMD_GREP: CMD_LOG("grep","%s\n","argument is needed"); break; default: CMD_ERR(cmd,"%s","This command may not show output by ncurses"); } return -1; }
int cli_resource_ban(const char *rsc_id, const char *host, GListPtr allnodes, cib_t * cib_conn) { char *later_s = NULL; int rc = pcmk_ok; xmlNode *fragment = NULL; xmlNode *location = NULL; if(host == NULL) { GListPtr n = allnodes; for(; n && rc == pcmk_ok; n = n->next) { node_t *target = n->data; rc = cli_resource_ban(rsc_id, target->details->uname, NULL, cib_conn); } return rc; } later_s = parse_cli_lifetime(move_lifetime); if(move_lifetime && later_s == NULL) { return -EINVAL; } fragment = create_xml_node(NULL, XML_CIB_TAG_CONSTRAINTS); location = create_xml_node(fragment, XML_CONS_TAG_RSC_LOCATION); crm_xml_set_id(location, "cli-ban-%s-on-%s", rsc_id, host); if (BE_QUIET == FALSE) { CMD_ERR("WARNING: Creating rsc_location constraint '%s'" " with a score of -INFINITY for resource %s" " on %s.", ID(location), rsc_id, host); CMD_ERR("\tThis will prevent %s from %s on %s until the constraint " "is removed using the clear option or by editing the CIB " "with an appropriate tool", rsc_id, (scope_master? "being promoted" : "running"), host); CMD_ERR("\tThis will be the case even if %s is" " the last node in the cluster", host); } crm_xml_add(location, XML_LOC_ATTR_SOURCE, rsc_id); if(scope_master) { crm_xml_add(location, XML_RULE_ATTR_ROLE, RSC_ROLE_MASTER_S); } else { crm_xml_add(location, XML_RULE_ATTR_ROLE, RSC_ROLE_STARTED_S); } if (later_s == NULL) { /* Short form */ crm_xml_add(location, XML_CIB_TAG_NODE, host); crm_xml_add(location, XML_RULE_ATTR_SCORE, CRM_MINUS_INFINITY_S); } else { xmlNode *rule = create_xml_node(location, XML_TAG_RULE); xmlNode *expr = create_xml_node(rule, XML_TAG_EXPRESSION); crm_xml_set_id(rule, "cli-ban-%s-on-%s-rule", rsc_id, host); crm_xml_add(rule, XML_RULE_ATTR_SCORE, CRM_MINUS_INFINITY_S); crm_xml_add(rule, XML_RULE_ATTR_BOOLEAN_OP, "and"); crm_xml_set_id(expr, "cli-ban-%s-on-%s-expr", rsc_id, host); crm_xml_add(expr, XML_EXPR_ATTR_ATTRIBUTE, CRM_ATTR_UNAME); crm_xml_add(expr, XML_EXPR_ATTR_OPERATION, "eq"); crm_xml_add(expr, XML_EXPR_ATTR_VALUE, host); crm_xml_add(expr, XML_EXPR_ATTR_TYPE, "string"); expr = create_xml_node(rule, "date_expression"); crm_xml_set_id(expr, "cli-ban-%s-on-%s-lifetime", rsc_id, host); crm_xml_add(expr, "operation", "lt"); crm_xml_add(expr, "end", later_s); } crm_log_xml_notice(fragment, "Modify"); rc = cib_conn->cmds->update(cib_conn, XML_CIB_TAG_CONSTRAINTS, fragment, cib_options); free_xml(fragment); free(later_s); return rc; }
static enum cmd_status cmd_mqtt_init_exec(char *cmd) { int32_t cnt; uint32_t buf_size; uint32_t alive_interval; uint32_t clean; char *tmp; /* get param */ cnt = cmd_sscanf(cmd, "bufsize=%u alive=%u clean=%u", &buf_size, &alive_interval, &clean); /* check param */ if (cnt != 3) { CMD_ERR("invalid param number %d\n", cnt); return CMD_STATUS_INVALID_ARG; } if (clean > 1) { CMD_ERR("invalid clean %d\n", clean); return CMD_STATUS_INVALID_ARG; } if (OS_MutexCreate(&lock) != OS_OK) return CMD_STATUS_FAIL;; if ((tmp = cmd_strrchr(cmd, '\"')) == NULL) return CMD_STATUS_INVALID_ARG; *tmp = '\0'; if ((tmp = cmd_strchr(cmd, '\"')) == NULL) return CMD_STATUS_INVALID_ARG; tmp++; client_name = cmd_malloc(cmd_strlen(tmp) + 1); cmd_memcpy(client_name, tmp, cmd_strlen(tmp) + 1); CMD_DBG("client name = %s\n", client_name); connectData.clientID.cstring = client_name; connectData.keepAliveInterval = alive_interval; connectData.cleansession = clean; send_buf = cmd_malloc(buf_size); if (send_buf == NULL) { CMD_ERR("no memory\n"); OS_MutexDelete(&lock); return CMD_STATUS_FAIL; } recv_buf = cmd_malloc(buf_size); if (recv_buf == NULL) { cmd_free(send_buf); CMD_ERR("no memory\n"); OS_MutexDelete(&lock); return CMD_STATUS_FAIL; } NewNetwork(&network); MQTTClient(&client, &network, 6000, send_buf, buf_size, recv_buf, buf_size); return CMD_STATUS_OK; }
int main(int argc, char **argv) { char rsc_cmd = 'L'; const char *v_class = NULL; const char *v_agent = NULL; const char *v_provider = NULL; char *name = NULL; char *value = NULL; GHashTable *validate_options = NULL; const char *rsc_id = NULL; const char *host_uname = NULL; const char *prop_name = NULL; const char *prop_value = NULL; const char *rsc_type = NULL; const char *prop_id = NULL; const char *prop_set = NULL; const char *rsc_long_cmd = NULL; const char *longname = NULL; const char *operation = NULL; const char *interval_spec = NULL; const char *cib_file = getenv("CIB_file"); GHashTable *override_params = NULL; char *xml_file = NULL; crm_ipc_t *crmd_channel = NULL; pe_working_set_t *data_set = NULL; xmlNode *cib_xml_copy = NULL; cib_t *cib_conn = NULL; resource_t *rsc = NULL; bool recursive = FALSE; char *our_pid = NULL; bool validate_cmdline = FALSE; /* whether we are just validating based on command line options */ bool require_resource = TRUE; /* whether command requires that resource be specified */ bool require_dataset = TRUE; /* whether command requires populated dataset instance */ bool require_crmd = FALSE; // whether command requires controller connection bool clear_expired = FALSE; int rc = pcmk_ok; int is_ocf_rc = 0; int option_index = 0; int timeout_ms = 0; int argerr = 0; int flag; int find_flags = 0; // Flags to use when searching for resource crm_exit_t exit_code = CRM_EX_OK; crm_log_cli_init("crm_resource"); crm_set_options(NULL, "(query|command) [options]", long_options, "Perform tasks related to cluster resources.\nAllows resources to be queried (definition and location), modified, and moved around the cluster.\n"); validate_options = crm_str_table_new(); while (1) { flag = crm_get_option_long(argc, argv, &option_index, &longname); if (flag == -1) break; switch (flag) { case 0: /* long options with no short equivalent */ if (safe_str_eq("master", longname)) { scope_master = TRUE; } else if(safe_str_eq(longname, "recursive")) { recursive = TRUE; } else if (safe_str_eq("wait", longname)) { rsc_cmd = flag; rsc_long_cmd = longname; require_resource = FALSE; require_dataset = FALSE; } else if ( safe_str_eq("validate", longname) || safe_str_eq("restart", longname) || safe_str_eq("force-demote", longname) || safe_str_eq("force-stop", longname) || safe_str_eq("force-start", longname) || safe_str_eq("force-promote", longname) || safe_str_eq("force-check", longname)) { rsc_cmd = flag; rsc_long_cmd = longname; find_flags = pe_find_renamed|pe_find_anon; crm_log_args(argc, argv); } else if (safe_str_eq("list-ocf-providers", longname) || safe_str_eq("list-ocf-alternatives", longname) || safe_str_eq("list-standards", longname)) { const char *text = NULL; lrmd_list_t *list = NULL; lrmd_list_t *iter = NULL; lrmd_t *lrmd_conn = lrmd_api_new(); if (safe_str_eq("list-ocf-providers", longname) || safe_str_eq("list-ocf-alternatives", longname)) { rc = lrmd_conn->cmds->list_ocf_providers(lrmd_conn, optarg, &list); text = "OCF providers"; } else if (safe_str_eq("list-standards", longname)) { rc = lrmd_conn->cmds->list_standards(lrmd_conn, &list); text = "standards"; } if (rc > 0) { for (iter = list; iter != NULL; iter = iter->next) { printf("%s\n", iter->val); } lrmd_list_freeall(list); } else if (optarg) { fprintf(stderr, "No %s found for %s\n", text, optarg); exit_code = CRM_EX_NOSUCH; } else { fprintf(stderr, "No %s found\n", text); exit_code = CRM_EX_NOSUCH; } lrmd_api_delete(lrmd_conn); crm_exit(exit_code); } else if (safe_str_eq("show-metadata", longname)) { char *standard = NULL; char *provider = NULL; char *type = NULL; char *metadata = NULL; lrmd_t *lrmd_conn = lrmd_api_new(); rc = crm_parse_agent_spec(optarg, &standard, &provider, &type); if (rc == pcmk_ok) { rc = lrmd_conn->cmds->get_metadata(lrmd_conn, standard, provider, type, &metadata, 0); } else { fprintf(stderr, "'%s' is not a valid agent specification\n", optarg); rc = -ENXIO; } if (metadata) { printf("%s\n", metadata); } else { fprintf(stderr, "Metadata query for %s failed: %s\n", optarg, pcmk_strerror(rc)); exit_code = crm_errno2exit(rc); } lrmd_api_delete(lrmd_conn); crm_exit(exit_code); } else if (safe_str_eq("list-agents", longname)) { lrmd_list_t *list = NULL; lrmd_list_t *iter = NULL; char *provider = strchr (optarg, ':'); lrmd_t *lrmd_conn = lrmd_api_new(); if (provider) { *provider++ = 0; } rc = lrmd_conn->cmds->list_agents(lrmd_conn, &list, optarg, provider); if (rc > 0) { for (iter = list; iter != NULL; iter = iter->next) { printf("%s\n", iter->val); } lrmd_list_freeall(list); } else { fprintf(stderr, "No agents found for standard=%s, provider=%s\n", optarg, (provider? provider : "*")); exit_code = CRM_EX_NOSUCH; } lrmd_api_delete(lrmd_conn); crm_exit(exit_code); } else if (safe_str_eq("class", longname)) { if (!(pcmk_get_ra_caps(optarg) & pcmk_ra_cap_params)) { if (BE_QUIET == FALSE) { fprintf(stdout, "Standard %s does not support parameters\n", optarg); } crm_exit(exit_code); } else { v_class = optarg; } validate_cmdline = TRUE; require_resource = FALSE; } else if (safe_str_eq("agent", longname)) { validate_cmdline = TRUE; require_resource = FALSE; v_agent = optarg; } else if (safe_str_eq("provider", longname)) { validate_cmdline = TRUE; require_resource = FALSE; v_provider = optarg; } else if (safe_str_eq("option", longname)) { crm_info("Scanning: --option %s", optarg); rc = pcmk_scan_nvpair(optarg, &name, &value); if (rc != 2) { fprintf(stderr, "Invalid option: --option %s: %s", optarg, pcmk_strerror(rc)); argerr++; } else { crm_info("Got: '%s'='%s'", name, value); } g_hash_table_replace(validate_options, name, value); } else { crm_err("Unhandled long option: %s", longname); } break; case 'V': resource_verbose++; crm_bump_log_level(argc, argv); break; case '$': case '?': crm_help(flag, CRM_EX_OK); break; case 'x': xml_file = strdup(optarg); break; case 'Q': BE_QUIET = TRUE; break; case 'm': attr_set_type = XML_TAG_META_SETS; break; case 'z': attr_set_type = XML_TAG_UTILIZATION; break; case 'u': move_lifetime = strdup(optarg); break; case 'f': do_force = TRUE; crm_log_args(argc, argv); break; case 'i': prop_id = optarg; break; case 's': prop_set = optarg; break; case 'r': rsc_id = optarg; break; case 'v': prop_value = optarg; break; case 't': rsc_type = optarg; break; case 'T': timeout_ms = crm_get_msec(optarg); break; case 'e': clear_expired = TRUE; require_resource = FALSE; break; case 'C': case 'R': crm_log_args(argc, argv); require_resource = FALSE; if (cib_file == NULL) { require_crmd = TRUE; } rsc_cmd = flag; find_flags = pe_find_renamed|pe_find_anon; break; case 'n': operation = optarg; break; case 'I': interval_spec = optarg; break; case 'D': require_dataset = FALSE; crm_log_args(argc, argv); rsc_cmd = flag; find_flags = pe_find_renamed|pe_find_any; break; case 'F': require_crmd = TRUE; crm_log_args(argc, argv); rsc_cmd = flag; break; case 'U': case 'B': case 'M': crm_log_args(argc, argv); rsc_cmd = flag; find_flags = pe_find_renamed|pe_find_anon; break; case 'c': case 'L': case 'l': case 'O': case 'o': require_resource = FALSE; rsc_cmd = flag; break; case 'Y': require_resource = FALSE; rsc_cmd = flag; find_flags = pe_find_renamed|pe_find_anon; break; case 'q': case 'w': rsc_cmd = flag; find_flags = pe_find_renamed|pe_find_any; break; case 'W': case 'A': case 'a': rsc_cmd = flag; find_flags = pe_find_renamed|pe_find_anon; break; case 'S': require_dataset = FALSE; crm_log_args(argc, argv); prop_name = optarg; rsc_cmd = flag; find_flags = pe_find_renamed|pe_find_any; break; case 'p': case 'd': crm_log_args(argc, argv); prop_name = optarg; rsc_cmd = flag; find_flags = pe_find_renamed|pe_find_any; break; case 'G': case 'g': prop_name = optarg; rsc_cmd = flag; find_flags = pe_find_renamed|pe_find_any; break; case 'H': case 'N': crm_trace("Option %c => %s", flag, optarg); host_uname = optarg; break; default: CMD_ERR("Argument code 0%o (%c) is not (?yet?) supported", flag, flag); ++argerr; break; } } // Catch the case where the user didn't specify a command if (rsc_cmd == 'L') { require_resource = FALSE; } // --expired without --clear/-U doesn't make sense if (clear_expired == TRUE && rsc_cmd != 'U') { CMD_ERR("--expired requires --clear or -U"); argerr++; } if (optind < argc && argv[optind] != NULL && rsc_cmd == 0 && rsc_long_cmd) { override_params = crm_str_table_new(); while (optind < argc && argv[optind] != NULL) { char *name = calloc(1, strlen(argv[optind])); char *value = calloc(1, strlen(argv[optind])); int rc = sscanf(argv[optind], "%[^=]=%s", name, value); if(rc == 2) { g_hash_table_replace(override_params, name, value); } else { CMD_ERR("Error parsing '%s' as a name=value pair for --%s", argv[optind], rsc_long_cmd); free(value); free(name); argerr++; } optind++; } } else if (optind < argc && argv[optind] != NULL && rsc_cmd == 0) { CMD_ERR("non-option ARGV-elements: "); while (optind < argc && argv[optind] != NULL) { CMD_ERR("[%d of %d] %s ", optind, argc, argv[optind]); optind++; argerr++; } } if (optind > argc) { ++argerr; } // Sanity check validating from command line parameters. If everything checks out, // go ahead and run the validation. This way we don't need a CIB connection. if (validate_cmdline == TRUE) { // -r cannot be used with any of --class, --agent, or --provider if (rsc_id != NULL) { CMD_ERR("--resource cannot be used with --class, --agent, and --provider"); argerr++; // If --class, --agent, or --provider are given, --validate must also be given. } else if (!safe_str_eq(rsc_long_cmd, "validate")) { CMD_ERR("--class, --agent, and --provider require --validate"); argerr++; // Not all of --class, --agent, and --provider need to be given. Not all // classes support the concept of a provider. Check that what we were given // is valid. } else if (crm_str_eq(v_class, "stonith", TRUE)) { if (v_provider != NULL) { CMD_ERR("stonith does not support providers"); argerr++; } else if (stonith_agent_exists(v_agent, 0) == FALSE) { CMD_ERR("%s is not a known stonith agent", v_agent ? v_agent : ""); argerr++; } } else if (resources_agent_exists(v_class, v_provider, v_agent) == FALSE) { CMD_ERR("%s:%s:%s is not a known resource", v_class ? v_class : "", v_provider ? v_provider : "", v_agent ? v_agent : ""); argerr++; } if (argerr == 0) { rc = cli_resource_execute_from_params("test", v_class, v_provider, v_agent, "validate-all", validate_options, override_params, timeout_ms); exit_code = crm_errno2exit(rc); return crm_exit(exit_code); } } if (argerr) { CMD_ERR("Invalid option(s) supplied, use --help for valid usage"); crm_exit(CRM_EX_USAGE); } our_pid = crm_getpid_s(); if (do_force) { crm_debug("Forcing..."); cib_options |= cib_quorum_override; } if (require_resource && !rsc_id) { CMD_ERR("Must supply a resource id with -r"); rc = -ENXIO; goto bail; } if (find_flags && rsc_id) { require_dataset = TRUE; } /* Establish a connection to the CIB manager */ cib_conn = cib_new(); rc = cib_conn->cmds->signon(cib_conn, crm_system_name, cib_command); if (rc != pcmk_ok) { CMD_ERR("Error connecting to the CIB manager: %s", pcmk_strerror(rc)); goto bail; } /* Populate working set from XML file if specified or CIB query otherwise */ if (require_dataset) { if (xml_file != NULL) { cib_xml_copy = filename2xml(xml_file); } else { rc = cib_conn->cmds->query(cib_conn, NULL, &cib_xml_copy, cib_scope_local | cib_sync_call); } if(rc != pcmk_ok) { goto bail; } /* Populate the working set instance */ data_set = pe_new_working_set(); if (data_set == NULL) { rc = -ENOMEM; goto bail; } rc = update_working_set_xml(data_set, &cib_xml_copy); if (rc != pcmk_ok) { goto bail; } cluster_status(data_set); } // If command requires that resource exist if specified, find it if (find_flags && rsc_id) { rsc = pe_find_resource_with_flags(data_set->resources, rsc_id, find_flags); if (rsc == NULL) { CMD_ERR("Resource '%s' not found", rsc_id); rc = -ENXIO; goto bail; } } // Establish a connection to the controller if needed if (require_crmd) { xmlNode *xml = NULL; mainloop_io_t *source = mainloop_add_ipc_client(CRM_SYSTEM_CRMD, G_PRIORITY_DEFAULT, 0, NULL, &crm_callbacks); crmd_channel = mainloop_get_ipc_client(source); if (crmd_channel == NULL) { CMD_ERR("Error connecting to the controller"); rc = -ENOTCONN; goto bail; } xml = create_hello_message(our_pid, crm_system_name, "0", "1"); crm_ipc_send(crmd_channel, xml, 0, 0, NULL); free_xml(xml); } /* Handle rsc_cmd appropriately */ if (rsc_cmd == 'L') { rc = pcmk_ok; cli_resource_print_list(data_set, FALSE); } else if (rsc_cmd == 'l') { int found = 0; GListPtr lpc = NULL; rc = pcmk_ok; for (lpc = data_set->resources; lpc != NULL; lpc = lpc->next) { rsc = (resource_t *) lpc->data; found++; cli_resource_print_raw(rsc); } if (found == 0) { printf("NO resources configured\n"); rc = -ENXIO; } } else if (rsc_cmd == 0 && rsc_long_cmd && safe_str_eq(rsc_long_cmd, "restart")) { /* We don't pass data_set because rsc needs to stay valid for the entire * lifetime of cli_resource_restart(), but it will reset and update the * working set multiple times, so it needs to use its own copy. */ rc = cli_resource_restart(rsc, host_uname, timeout_ms, cib_conn); } else if (rsc_cmd == 0 && rsc_long_cmd && safe_str_eq(rsc_long_cmd, "wait")) { rc = wait_till_stable(timeout_ms, cib_conn); } else if (rsc_cmd == 0 && rsc_long_cmd) { // validate, force-(stop|start|demote|promote|check) rc = cli_resource_execute(rsc, rsc_id, rsc_long_cmd, override_params, timeout_ms, cib_conn, data_set); if (rc >= 0) { is_ocf_rc = 1; } } else if (rsc_cmd == 'A' || rsc_cmd == 'a') { GListPtr lpc = NULL; xmlNode *cib_constraints = get_object_root(XML_CIB_TAG_CONSTRAINTS, data_set->input); unpack_constraints(cib_constraints, data_set); // Constraints apply to group/clone, not member/instance rsc = uber_parent(rsc); for (lpc = data_set->resources; lpc != NULL; lpc = lpc->next) { resource_t *r = (resource_t *) lpc->data; clear_bit(r->flags, pe_rsc_allocating); } cli_resource_print_colocation(rsc, TRUE, rsc_cmd == 'A', 1); fprintf(stdout, "* %s\n", rsc->id); cli_resource_print_location(rsc, NULL); for (lpc = data_set->resources; lpc != NULL; lpc = lpc->next) { resource_t *r = (resource_t *) lpc->data; clear_bit(r->flags, pe_rsc_allocating); } cli_resource_print_colocation(rsc, FALSE, rsc_cmd == 'A', 1); } else if (rsc_cmd == 'c') { GListPtr lpc = NULL; rc = pcmk_ok; for (lpc = data_set->resources; lpc != NULL; lpc = lpc->next) { rsc = (resource_t *) lpc->data; cli_resource_print_cts(rsc); } cli_resource_print_cts_constraints(data_set); } else if (rsc_cmd == 'F') { rc = cli_resource_fail(crmd_channel, host_uname, rsc_id, data_set); if (rc == pcmk_ok) { start_mainloop(); } } else if (rsc_cmd == 'O') { rc = cli_resource_print_operations(rsc_id, host_uname, TRUE, data_set); } else if (rsc_cmd == 'o') { rc = cli_resource_print_operations(rsc_id, host_uname, FALSE, data_set); } else if (rsc_cmd == 'W') { rc = cli_resource_search(rsc, rsc_id, data_set); if (rc >= 0) { rc = pcmk_ok; } } else if (rsc_cmd == 'q') { rc = cli_resource_print(rsc, data_set, TRUE); } else if (rsc_cmd == 'w') { rc = cli_resource_print(rsc, data_set, FALSE); } else if (rsc_cmd == 'Y') { node_t *dest = NULL; if (host_uname) { dest = pe_find_node(data_set->nodes, host_uname); if (dest == NULL) { rc = -pcmk_err_node_unknown; goto bail; } } cli_resource_why(cib_conn, data_set->resources, rsc, dest); rc = pcmk_ok; } else if (rsc_cmd == 'U') { GListPtr before = NULL; GListPtr after = NULL; GListPtr remaining = NULL; GListPtr ele = NULL; node_t *dest = NULL; if (BE_QUIET == FALSE) { before = build_constraint_list(data_set->input); } if (clear_expired == TRUE) { rc = cli_resource_clear_all_expired(data_set->input, cib_conn, rsc_id, host_uname, scope_master); } else if (host_uname) { dest = pe_find_node(data_set->nodes, host_uname); if (dest == NULL) { rc = -pcmk_err_node_unknown; if (BE_QUIET == FALSE) { g_list_free(before); } goto bail; } rc = cli_resource_clear(rsc_id, dest->details->uname, NULL, cib_conn, TRUE); } else { rc = cli_resource_clear(rsc_id, NULL, data_set->nodes, cib_conn, TRUE); } if (BE_QUIET == FALSE) { rc = cib_conn->cmds->query(cib_conn, NULL, &cib_xml_copy, cib_scope_local | cib_sync_call); if (rc != pcmk_ok) { CMD_ERR("Could not get modified CIB: %s\n", pcmk_strerror(rc)); g_list_free(before); goto bail; } data_set->input = cib_xml_copy; cluster_status(data_set); after = build_constraint_list(data_set->input); remaining = subtract_lists(before, after, (GCompareFunc) strcmp); for (ele = remaining; ele != NULL; ele = ele->next) { printf("Removing constraint: %s\n", (char *) ele->data); } g_list_free(before); g_list_free(after); g_list_free(remaining); } } else if (rsc_cmd == 'M' && host_uname) { rc = cli_resource_move(rsc, rsc_id, host_uname, cib_conn, data_set); } else if (rsc_cmd == 'B' && host_uname) { node_t *dest = pe_find_node(data_set->nodes, host_uname); if (dest == NULL) { rc = -pcmk_err_node_unknown; goto bail; } rc = cli_resource_ban(rsc_id, dest->details->uname, NULL, cib_conn); } else if (rsc_cmd == 'B' || rsc_cmd == 'M') { pe_node_t *current = NULL; unsigned int nactive = 0; current = pe__find_active_requires(rsc, &nactive); if (nactive == 1) { rc = cli_resource_ban(rsc_id, current->details->uname, NULL, cib_conn); } else if (is_set(rsc->flags, pe_rsc_promotable)) { int count = 0; GListPtr iter = NULL; current = NULL; for(iter = rsc->children; iter; iter = iter->next) { resource_t *child = (resource_t *)iter->data; enum rsc_role_e child_role = child->fns->state(child, TRUE); if(child_role == RSC_ROLE_MASTER) { count++; current = pe__current_node(child); } } if(count == 1 && current) { rc = cli_resource_ban(rsc_id, current->details->uname, NULL, cib_conn); } else { rc = -EINVAL; exit_code = CRM_EX_USAGE; CMD_ERR("Resource '%s' not moved: active in %d locations (promoted in %d).", rsc_id, nactive, count); CMD_ERR("To prevent '%s' from running on a specific location, " "specify a node.", rsc_id); CMD_ERR("To prevent '%s' from being promoted at a specific " "location, specify a node and the master option.", rsc_id); } } else { rc = -EINVAL; exit_code = CRM_EX_USAGE; CMD_ERR("Resource '%s' not moved: active in %d locations.", rsc_id, nactive); CMD_ERR("To prevent '%s' from running on a specific location, " "specify a node.", rsc_id); } } else if (rsc_cmd == 'G') { rc = cli_resource_print_property(rsc, prop_name, data_set); } else if (rsc_cmd == 'S') { xmlNode *msg_data = NULL; if ((rsc_type == NULL) || !strlen(rsc_type)) { CMD_ERR("Must specify -t with resource type"); rc = -ENXIO; goto bail; } else if ((prop_value == NULL) || !strlen(prop_value)) { CMD_ERR("Must supply -v with new value"); rc = -EINVAL; goto bail; } CRM_LOG_ASSERT(prop_name != NULL); msg_data = create_xml_node(NULL, rsc_type); crm_xml_add(msg_data, XML_ATTR_ID, rsc_id); crm_xml_add(msg_data, prop_name, prop_value); rc = cib_conn->cmds->modify(cib_conn, XML_CIB_TAG_RESOURCES, msg_data, cib_options); free_xml(msg_data); } else if (rsc_cmd == 'g') { rc = cli_resource_print_attribute(rsc, prop_name, data_set); } else if (rsc_cmd == 'p') { if (prop_value == NULL || strlen(prop_value) == 0) { CMD_ERR("You need to supply a value with the -v option"); rc = -EINVAL; goto bail; } /* coverity[var_deref_model] False positive */ rc = cli_resource_update_attribute(rsc, rsc_id, prop_set, prop_id, prop_name, prop_value, recursive, cib_conn, data_set); } else if (rsc_cmd == 'd') { /* coverity[var_deref_model] False positive */ rc = cli_resource_delete_attribute(rsc, rsc_id, prop_set, prop_id, prop_name, cib_conn, data_set); } else if ((rsc_cmd == 'C') && rsc) { if (do_force == FALSE) { rsc = uber_parent(rsc); } crmd_replies_needed = 0; crm_debug("Erasing failures of %s (%s requested) on %s", rsc->id, rsc_id, (host_uname? host_uname: "all nodes")); rc = cli_resource_delete(crmd_channel, host_uname, rsc, operation, interval_spec, TRUE, data_set); if ((rc == pcmk_ok) && !BE_QUIET) { // Show any reasons why resource might stay stopped cli_resource_check(cib_conn, rsc); } if (rc == pcmk_ok) { start_mainloop(); } } else if (rsc_cmd == 'C') { rc = cli_cleanup_all(crmd_channel, host_uname, operation, interval_spec, data_set); if (rc == pcmk_ok) { start_mainloop(); } } else if ((rsc_cmd == 'R') && rsc) { if (do_force == FALSE) { rsc = uber_parent(rsc); } crmd_replies_needed = 0; crm_debug("Re-checking the state of %s (%s requested) on %s", rsc->id, rsc_id, (host_uname? host_uname: "all nodes")); rc = cli_resource_delete(crmd_channel, host_uname, rsc, NULL, 0, FALSE, data_set); if ((rc == pcmk_ok) && !BE_QUIET) { // Show any reasons why resource might stay stopped cli_resource_check(cib_conn, rsc); } if (rc == pcmk_ok) { start_mainloop(); } } else if (rsc_cmd == 'R') { const char *router_node = host_uname; xmlNode *msg_data = NULL; xmlNode *cmd = NULL; int attr_options = attrd_opt_none; if (host_uname) { node_t *node = pe_find_node(data_set->nodes, host_uname); if (node && is_remote_node(node)) { node = pe__current_node(node->details->remote_rsc); if (node == NULL) { CMD_ERR("No cluster connection to Pacemaker Remote node %s detected", host_uname); rc = -ENXIO; goto bail; } router_node = node->details->uname; attr_options |= attrd_opt_remote; } } if (crmd_channel == NULL) { printf("Dry run: skipping clean-up of %s due to CIB_file\n", host_uname? host_uname : "all nodes"); rc = pcmk_ok; goto bail; } msg_data = create_xml_node(NULL, "crm-resource-reprobe-op"); crm_xml_add(msg_data, XML_LRM_ATTR_TARGET, host_uname); if (safe_str_neq(router_node, host_uname)) { crm_xml_add(msg_data, XML_LRM_ATTR_ROUTER_NODE, router_node); } cmd = create_request(CRM_OP_REPROBE, msg_data, router_node, CRM_SYSTEM_CRMD, crm_system_name, our_pid); free_xml(msg_data); crm_debug("Re-checking the state of all resources on %s", host_uname?host_uname:"all nodes"); rc = attrd_clear_delegate(NULL, host_uname, NULL, NULL, NULL, NULL, attr_options); if (crm_ipc_send(crmd_channel, cmd, 0, 0, NULL) > 0) { start_mainloop(); } free_xml(cmd); } else if (rsc_cmd == 'D') { xmlNode *msg_data = NULL; if (rsc_type == NULL) { CMD_ERR("You need to specify a resource type with -t"); rc = -ENXIO; goto bail; } msg_data = create_xml_node(NULL, rsc_type); crm_xml_add(msg_data, XML_ATTR_ID, rsc_id); rc = cib_conn->cmds->remove(cib_conn, XML_CIB_TAG_RESOURCES, msg_data, cib_options); free_xml(msg_data); } else { CMD_ERR("Unknown command: %c", rsc_cmd); } bail: free(our_pid); pe_free_working_set(data_set); if (cib_conn != NULL) { cib_conn->cmds->signoff(cib_conn); cib_delete(cib_conn); } if (is_ocf_rc) { exit_code = rc; } else if (rc != pcmk_ok) { CMD_ERR("Error performing operation: %s", pcmk_strerror(rc)); if (rc == -pcmk_err_no_quorum) { CMD_ERR("To ignore quorum, use the force option"); } if (exit_code == CRM_EX_OK) { exit_code = crm_errno2exit(rc); } } return crm_exit(exit_code); }
static enum cmd_status cmd_mqtt_publish_exec(char *cmd) { int32_t cnt; MQTTMessage message; char *topic; uint8_t *buf; char *tmp; uint32_t qos; uint32_t retain; uint32_t size; int rc; /* get param */ cnt = cmd_sscanf(cmd, "qos=%u retain=%u", &qos, &retain); if ((tmp = cmd_strrchr(cmd, '\"')) == NULL) return CMD_STATUS_INVALID_ARG; *tmp = '\0'; cnt += cmd_sscanf(tmp + 2, "size=%u", &size); if ((tmp = cmd_strchr(cmd, '\"')) == NULL) return CMD_STATUS_INVALID_ARG; tmp++; /* check param */ if (cnt != 3) { CMD_ERR("invalid param number %d\n", cnt); return CMD_STATUS_INVALID_ARG; } if (qos > 2) { CMD_ERR("invalid qos %d\n", qos); return CMD_STATUS_INVALID_ARG; } if (retain > 1) { CMD_ERR("invalid retain %d\n", retain); return CMD_STATUS_INVALID_ARG; } topic = tmp; CMD_DBG("topic name = %s\n", topic); buf = cmd_malloc(size); if (buf == NULL) { CMD_ERR("no memory\n"); return CMD_STATUS_FAIL; } cmd_write_respond(CMD_STATUS_OK, "OK"); cmd_raw_mode_enable(); cmd_raw_mode_read(buf, size, 30000); message.qos = qos; message.retained = retain; message.payload = buf; message.payloadlen = size; if (OS_MutexLock(&lock, 60000) == OS_E_TIMEOUT) return CMD_STATUS_FAIL; if ((rc = MQTTPublish(&client, topic, &message)) != 0) CMD_ERR("Return code from MQTT publish is %d\n", rc); else CMD_DBG("MQTT publish is success\n"); OS_MutexUnlock(&lock); cmd_raw_mode_write((uint8_t *)&rc, sizeof(rc)); cmd_raw_mode_disable(); cmd_free(buf); return CMD_STATUS_ACKED; }
/* @return * -2: CMD_STATUS_INVALID_ARG * -1: CMD_STATUS_FAIL * 0: CMD_STATUS_OK */ static int cmd_wlan_sta_set(char *cmd) { char *value; wlan_sta_config_t config; value = cmd_strchr(cmd, ' '); if (value == NULL) return -2; *value++ = '\0'; config.field = WLAN_STA_FIELD_NUM; if (cmd_strcmp(cmd, "ssid") == 0) { uint8_t ssid_len = cmd_strlen(value); if ((ssid_len >= 1) && (ssid_len <= 32)) { config.field = WLAN_STA_FIELD_SSID; cmd_memcpy(config.u.ssid.ssid, value, ssid_len); config.u.ssid.ssid_len = ssid_len; } } else if (cmd_strcmp(cmd, "psk") == 0) { config.field = WLAN_STA_FIELD_PSK; cmd_strlcpy((char *)config.u.psk, value, sizeof(config.u.psk)); } else if (cmd_strcmp(cmd, "wep_key0") == 0) { config.field = WLAN_STA_FIELD_WEP_KEY0; cmd_strlcpy((char *)config.u.wep_key, value, sizeof(config.u.wep_key)); } else if (cmd_strcmp(cmd, "wep_key1") == 0) { config.field = WLAN_STA_FIELD_WEP_KEY1; cmd_strlcpy((char *)config.u.wep_key, value, sizeof(config.u.wep_key)); } else if (cmd_strcmp(cmd, "wep_key2") == 0) { config.field = WLAN_STA_FIELD_WEP_KEY2; cmd_strlcpy((char *)config.u.wep_key, value, sizeof(config.u.wep_key)); } else if (cmd_strcmp(cmd, "wep_key3") == 0) { config.field = WLAN_STA_FIELD_WEP_KEY3; cmd_strlcpy((char *)config.u.wep_key, value, sizeof(config.u.wep_key)); } else if (cmd_strcmp(cmd, "wep_key_index") == 0) { int index; if (cmd_wpas_parse_int(value, 0, 3, &index) == 0) { config.field = WLAN_STA_FIELD_WEP_KEY_INDEX; config.u.wep_tx_keyidx = index; } } else if (cmd_strcmp(cmd, "key_mgmt") == 0) { int key_mgmt = cmd_wpas_parse_key_mgmt(value); if (key_mgmt > 0) { config.field = WLAN_STA_FIELD_KEY_MGMT; config.u.key_mgmt = key_mgmt; } } else if (cmd_strcmp(cmd, "pairwise") == 0) { int pairwise_cipher = cmd_wpas_parse_cipher(value); if (pairwise_cipher > 0) { config.field = WLAN_STA_FIELD_PAIRWISE_CIPHER; config.u.pairwise_cipher = pairwise_cipher; } } else if (cmd_strcmp(cmd, "group") == 0) { int group_cipher = cmd_wpas_parse_cipher(value); if (group_cipher > 0) { config.field = WLAN_STA_FIELD_GROUP_CIPHER; config.u.group_cipher = group_cipher; } } else if (cmd_strcmp(cmd, "proto") == 0) { int proto = cmd_wpas_parse_proto(value); if (proto >= 0) { config.field = WLAN_STA_FIELD_PROTO; config.u.proto = proto; } } else if (cmd_strcmp(cmd, "auth_alg") == 0) { int auth_alg = cmd_wpas_parse_auth_alg(value); if (auth_alg > 0) { config.field = WLAN_STA_FIELD_AUTH_ALG; config.u.auth_alg = auth_alg; } } else if (cmd_strcmp(cmd, "ptk_rekey") == 0) { int sec; if (cmd_wpas_parse_int(value, 0, INT32_MAX, &sec) == 0) { config.field = WLAN_STA_FIELD_WPA_PTK_REKEY; config.u.wpa_ptk_rekey = sec; } } else if (cmd_strcmp(cmd, "scan_ssid") == 0) { int enable; if (cmd_wpas_parse_int(value, 0, 1, &enable) == 0) { config.field = WLAN_STA_FIELD_SCAN_SSID; config.u.scan_ssid = enable; } } if (config.field < WLAN_STA_FIELD_NUM) return wlan_sta_set_config(&config); CMD_ERR("%s: invalid arg '%s %s'\n", __func__, cmd, value); return -2; }
static enum cmd_status cmd_mqtt_will_exec(char *cmd) { int32_t cnt; char *topic; uint8_t *buf; char *tmp; uint32_t qos; uint32_t retain; uint32_t size; /* get param */ cnt = cmd_sscanf(cmd, "qos=%u retain=%u", &qos, &retain); if ((tmp = cmd_strrchr(cmd, '\"')) == NULL) return CMD_STATUS_INVALID_ARG; *tmp = '\0'; cnt += cmd_sscanf(tmp + 2, "size=%u", &size); if ((tmp = cmd_strchr(cmd, '\"')) == NULL) return CMD_STATUS_INVALID_ARG; tmp++; /* check param */ if (cnt != 3) { CMD_ERR("invalid param number %d\n", cnt); return CMD_STATUS_INVALID_ARG; } if (qos > 2) { CMD_ERR("invalid qos %d\n", qos); return CMD_STATUS_INVALID_ARG; } if (retain > 1) { CMD_ERR("invalid retain %d\n", retain); return CMD_STATUS_INVALID_ARG; } topic = tmp; CMD_DBG("topic name = %s\n", topic); buf = cmd_malloc(size); if (buf == NULL) { CMD_ERR("no memory\n"); return CMD_STATUS_FAIL; } cmd_write_respond(CMD_STATUS_OK, "OK"); cmd_raw_mode_enable(); cmd_raw_mode_read(buf, size, 30000); cmd_raw_mode_disable(); //will function connectData.willFlag = 1; connectData.will.message.lenstring.data = (char *)buf; connectData.will.message.lenstring.len = size; connectData.will.qos = qos; connectData.will.retained = retain; connectData.will.topicName.cstring = topic; cmd_free(buf); return CMD_STATUS_ACKED; }
/* @return * -2: CMD_STATUS_INVALID_ARG * -1: CMD_STATUS_FAIL * 0: CMD_STATUS_OK */ static int cmd_wlan_sta_get(char *cmd) { wlan_sta_config_t config; cmd_memset(&config, 0, sizeof(config)); if (cmd_strcmp(cmd, "ssid") == 0) { config.field = WLAN_STA_FIELD_SSID; } else if (cmd_strcmp(cmd, "psk") == 0) { config.field = WLAN_STA_FIELD_PSK; } else if (cmd_strcmp(cmd, "wep_key0") == 0) { config.field = WLAN_STA_FIELD_WEP_KEY0; } else if (cmd_strcmp(cmd, "wep_key1") == 0) { config.field = WLAN_STA_FIELD_WEP_KEY1; } else if (cmd_strcmp(cmd, "wep_key2") == 0) { config.field = WLAN_STA_FIELD_WEP_KEY2; } else if (cmd_strcmp(cmd, "wep_key3") == 0) { config.field = WLAN_STA_FIELD_WEP_KEY3; } else if (cmd_strcmp(cmd, "wep_key_index") == 0) { config.field = WLAN_STA_FIELD_WEP_KEY_INDEX; } else if (cmd_strcmp(cmd, "key_mgmt") == 0) { config.field = WLAN_STA_FIELD_KEY_MGMT; } else if (cmd_strcmp(cmd, "pairwise") == 0) { config.field = WLAN_STA_FIELD_PAIRWISE_CIPHER; } else if (cmd_strcmp(cmd, "group") == 0) { config.field = WLAN_STA_FIELD_GROUP_CIPHER; } else if (cmd_strcmp(cmd, "proto") == 0) { config.field = WLAN_STA_FIELD_PROTO; } else if (cmd_strcmp(cmd, "auth_alg") == 0) { config.field = WLAN_STA_FIELD_AUTH_ALG; } else if (cmd_strcmp(cmd, "ptk_rekey") == 0) { config.field = WLAN_STA_FIELD_WPA_PTK_REKEY; } else if (cmd_strcmp(cmd, "scan_ssid") == 0) { config.field = WLAN_STA_FIELD_SCAN_SSID; } else { CMD_ERR("%s: invalid arg '%s'\n", __func__, cmd); return -2; } if (wlan_sta_get_config(&config) != 0) { CMD_ERR("%s: get config failed\n", __func__); return -1; } if (config.field == WLAN_STA_FIELD_SSID) { CMD_LOG(1, "ssid: %.32s\n", config.u.ssid.ssid); } else if (config.field == WLAN_STA_FIELD_PSK) { CMD_LOG(1, "psk: %s\n", config.u.psk); } else if (config.field == WLAN_STA_FIELD_WEP_KEY0) { CMD_LOG(1, "wep_key0: %s\n", config.u.wep_key); } else if (config.field == WLAN_STA_FIELD_WEP_KEY1) { CMD_LOG(1, "wep_key1: %s\n", config.u.wep_key); } else if (config.field == WLAN_STA_FIELD_WEP_KEY2) { CMD_LOG(1, "wep_key2: %s\n", config.u.wep_key); } else if (config.field == WLAN_STA_FIELD_WEP_KEY3) { CMD_LOG(1, "wep_key3: %s\n", config.u.wep_key); } else if (config.field == WLAN_STA_FIELD_WEP_KEY_INDEX) { CMD_LOG(1, "wep_key_index: %d\n", config.u.wep_tx_keyidx); } else if (config.field == WLAN_STA_FIELD_KEY_MGMT) { CMD_LOG(1, "key_mgmt: %#06x\n", config.u.key_mgmt); } else if (config.field == WLAN_STA_FIELD_PAIRWISE_CIPHER) { CMD_LOG(1, "pairwise_cipher: %#06x\n", config.u.pairwise_cipher); } else if (config.field == WLAN_STA_FIELD_GROUP_CIPHER) { CMD_LOG(1, "group_cipher: %#06x\n", config.u.group_cipher); } else if (config.field == WLAN_STA_FIELD_PROTO) { CMD_LOG(1, "proto: %#06x\n", config.u.proto); } else if (config.field == WLAN_STA_FIELD_AUTH_ALG) { CMD_LOG(1, "auth_alg: %#06x\n", config.u.auth_alg); } else if (config.field == WLAN_STA_FIELD_WPA_PTK_REKEY) { CMD_LOG(1, "ptk_rekey: %d\n", config.u.wpa_ptk_rekey); } else if (config.field == WLAN_STA_FIELD_SCAN_SSID) { CMD_LOG(1, "scan_ssid: %d\n", config.u.scan_ssid); } return 0; }
enum cmd_status cmd_wlan_sta_exec(char *cmd) { int ret; cmd_write_respond(CMD_STATUS_OK, "OK"); if (cmd_strncmp(cmd, "config ", 7) == 0) { char *argv[2]; if (cmd_parse_argv(cmd + 7, argv, cmd_nitems(argv)) == 0) { ret = -2; goto out; } ret = wlan_sta_set((uint8_t *)argv[0], cmd_strlen(argv[0]), (uint8_t *)argv[1]); } else if (cmd_strncmp(cmd, "set ", 4) == 0) { ret = cmd_wlan_sta_set(cmd + 4); } else if (cmd_strncmp(cmd, "get ", 4) == 0) { ret = cmd_wlan_sta_get(cmd + 4); } else if (cmd_strcmp(cmd, "enable") == 0) { ret = wlan_sta_enable(); } else if (cmd_strcmp(cmd, "disable") == 0) { ret = wlan_sta_disable(); } else if (cmd_strcmp(cmd, "scan once") == 0) { ret = wlan_sta_scan_once(); } else if (cmd_strncmp(cmd, "scan result ", 12) == 0) { int size; if (cmd_wpas_parse_int(cmd + 12, 1, 30, &size) != 0) { ret = -2; goto out; } wlan_sta_scan_results_t results; results.ap = cmd_malloc(size * sizeof(wlan_sta_ap_t)); if (results.ap == NULL) { CMD_ERR("%s: malloc failed\n", __func__); ret = -1; goto out; } results.size = size; ret = wlan_sta_scan_result(&results); if (ret == 0) cmd_wlan_sta_print_scan_results(&results); cmd_free(results.ap); } else if (cmd_strncmp(cmd, "scan interval ", 14) == 0) { int sec; if (cmd_wpas_parse_int(cmd + 14, 0, INT32_MAX, &sec) != 0) { ret = -2; goto out; } ret = wlan_sta_scan_interval(sec); } else if (cmd_strncmp(cmd, "bss max count ", 14) == 0) { int count; if (cmd_wpas_parse_int(cmd + 14, 0, UINT8_MAX, &count) != 0) { ret = -2; goto out; } ret = wlan_sta_bss_max_count((uint8_t)count); } else if (cmd_strncmp(cmd, "bss flush ", 10) == 0) { int age; if (cmd_wpas_parse_int(cmd + 10, 0, INT32_MAX, &age) != 0) { ret = -2; goto out; } ret = wlan_sta_bss_flush(age); } else if (cmd_strcmp(cmd, "connect") == 0) { ret = wlan_sta_connect(); } else if (cmd_strcmp(cmd, "disconnect") == 0) { ret = wlan_sta_disconnect(); } else if (cmd_strcmp(cmd, "state") == 0) { wlan_sta_states_t state; ret = wlan_sta_state(&state); if (ret == 0) CMD_LOG(1, "sta state: %d\n", state); } else if (cmd_strcmp(cmd, "ap") == 0) { wlan_sta_ap_t *ap = cmd_malloc(sizeof(wlan_sta_ap_t)); if (ap == NULL) { CMD_ERR("%s: malloc failed\n", __func__); ret = -1; goto out; } ret = wlan_sta_ap_info(ap); if (ret == 0) cmd_wlan_sta_print_ap(ap); cmd_free(ap); } else if (cmd_strcmp(cmd, "wps pbc") == 0) { ret = wlan_sta_wps_pbc(); } else if ((cmd_strlen(cmd) == 7) || (cmd_strcmp(cmd, "wps pin") == 0)) { wlan_sta_wps_pin_t wps; ret = wlan_sta_wps_pin_get(&wps); if (ret == 0) CMD_LOG(1, "WPS pin: %s\n", wps.pin); } else if (cmd_strncmp(cmd, "wps pin ", 8) == 0) { if (cmd_strlen(cmd + 8) != 8) { ret = -2; goto out; } wlan_sta_wps_pin_t wps; cmd_memcpy(wps.pin, cmd + 8, 8); wps.pin[8] = '\0'; ret = wlan_sta_wps_pin_set(&wps); } else { CMD_ERR("%s: unknown command '%s'\n", __func__, cmd); return CMD_STATUS_ACKED; } out: if (ret == -2) { CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } return CMD_STATUS_ACKED; }
enum cmd_status cmd_wlan_ap_exec(char *cmd) { int ret; cmd_write_respond(CMD_STATUS_OK, "OK"); if (cmd_strncmp(cmd, "config ", 7) == 0) { char *argv[2]; if (cmd_parse_argv(cmd + 7, argv, cmd_nitems(argv)) == 0) { ret = -2; goto out; } ret = wlan_ap_set((uint8_t *)argv[0], cmd_strlen(argv[0]), (uint8_t *)argv[1]); } else if (cmd_strncmp(cmd, "set ", 4) == 0) { ret = cmd_wlan_ap_set(cmd + 4); } else if (cmd_strncmp(cmd, "get ", 4) == 0) { ret = cmd_wlan_ap_get(cmd + 4); } else if (cmd_strcmp(cmd, "enable") == 0) { ret = wlan_ap_enable(); } else if (cmd_strcmp(cmd, "reload") == 0) { ret = wlan_ap_reload(); } else if (cmd_strcmp(cmd, "disable") == 0) { ret = wlan_ap_disable(); } else if (cmd_strcmp(cmd, "sta num") == 0) { int num; ret = wlan_ap_sta_num(&num); if (ret == 0) CMD_LOG(1, "sta num: %d\n", num); } else if (cmd_strncmp(cmd, "sta info ", 9) == 0) { int size; if (cmd_wpas_parse_int(cmd + 9, 1, 30, &size) != 0) { ret = -2; goto out; } wlan_ap_stas_t stas; stas.sta = (wlan_ap_sta_t *)cmd_malloc(size * sizeof(wlan_ap_sta_t)); if (stas.sta == NULL) { CMD_ERR("%s: malloc failed\n", __func__); ret = -1; goto out; } stas.size = size; ret = wlan_ap_sta_info(&stas); if (ret == 0) cmd_wlan_ap_print_sta_info(&stas); cmd_free(stas.sta); } else { CMD_ERR("%s: unknown command '%s'\n", __func__, cmd); return CMD_STATUS_ACKED; } out: if (ret == -2) { CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } return CMD_STATUS_ACKED; }
/* @return * -2: CMD_STATUS_INVALID_ARG * -1: CMD_STATUS_FAIL * 0: CMD_STATUS_OK */ static int cmd_wlan_ap_get(char *cmd) { wlan_ap_config_t config; cmd_memset(&config, 0, sizeof(config)); if (cmd_strcmp(cmd, "ssid") == 0) { config.field = WLAN_AP_FIELD_SSID; } else if (cmd_strcmp(cmd, "psk") == 0) { config.field = WLAN_AP_FIELD_PSK; } else if (cmd_strcmp(cmd, "key_mgmt") == 0) { config.field = WLAN_AP_FIELD_KEY_MGMT; } else if (cmd_strcmp(cmd, "wpa") == 0) { config.field = WLAN_AP_FIELD_WPA_CIPHER; } else if (cmd_strcmp(cmd, "rsn") == 0) { config.field = WLAN_AP_FIELD_RSN_CIPHER; } else if (cmd_strcmp(cmd, "proto") == 0) { config.field = WLAN_AP_FIELD_PROTO; } else if (cmd_strcmp(cmd, "auth_alg") == 0) { config.field = WLAN_AP_FIELD_AUTH_ALG; } else if (cmd_strcmp(cmd, "group_rekey") == 0) { config.field = WLAN_AP_FIELD_GROUP_REKEY; } else if (cmd_strcmp(cmd, "strict_rekey") == 0) { config.field = WLAN_AP_FIELD_STRICT_REKEY; } else if (cmd_strcmp(cmd, "gmk_rekey") == 0) { config.field = WLAN_AP_FIELD_GMK_REKEY; } else if (cmd_strcmp(cmd, "ptk_rekey") == 0) { config.field = WLAN_AP_FIELD_PTK_REKEY; } else if (cmd_strcmp(cmd, "hw_mode") == 0) { config.field = WLAN_AP_FIELD_HW_MODE; } else if (cmd_strcmp(cmd, "80211n") == 0) { config.field = WLAN_AP_FIELD_IEEE80211N; } else if (cmd_strcmp(cmd, "channel") == 0) { config.field = WLAN_AP_FIELD_CHANNEL; } else if (cmd_strcmp(cmd, "beacon_int") == 0) { config.field = WLAN_AP_FIELD_BEACON_INT; } else if (cmd_strcmp(cmd, "dtim") == 0) { config.field = WLAN_AP_FIELD_DTIM; } else if (cmd_strcmp(cmd, "max_num_sta") == 0) { config.field = WLAN_AP_FIELD_MAX_NUM_STA; } else { CMD_ERR("%s: invalid arg '%s'\n", __func__, cmd); return -2; } if (wlan_ap_get_config(&config) != 0) { CMD_ERR("%s: get config failed\n", __func__); return -1; } if (config.field == WLAN_AP_FIELD_SSID) { CMD_LOG(1, "ssid: %.32s\n", config.u.ssid.ssid); } else if (config.field == WLAN_AP_FIELD_PSK) { CMD_LOG(1, "psk: %s\n", config.u.psk); } else if (config.field == WLAN_AP_FIELD_KEY_MGMT) { CMD_LOG(1, "key_mgmt: %#06x\n", config.u.key_mgmt); } else if (config.field == WLAN_AP_FIELD_WPA_CIPHER) { CMD_LOG(1, "wpa_cipher: %#06x\n", config.u.wpa_cipher); } else if (config.field == WLAN_AP_FIELD_RSN_CIPHER) { CMD_LOG(1, "rsn_cipher: %#06x\n", config.u.rsn_cipher); } else if (config.field == WLAN_AP_FIELD_PROTO) { CMD_LOG(1, "proto: %#06x\n", config.u.proto); } else if (config.field == WLAN_AP_FIELD_AUTH_ALG) { CMD_LOG(1, "auth_alg: %#06x\n", config.u.auth_alg); } else if (config.field == WLAN_AP_FIELD_GROUP_REKEY) { CMD_LOG(1, "group_rekey: %d\n", config.u.group_rekey); } else if (config.field == WLAN_AP_FIELD_STRICT_REKEY) { CMD_LOG(1, "strict_rekey: %d\n", config.u.strict_rekey); } else if (config.field == WLAN_AP_FIELD_GMK_REKEY) { CMD_LOG(1, "gmk_rekey: %d\n", config.u.gmk_rekey); } else if (config.field == WLAN_AP_FIELD_PTK_REKEY) { CMD_LOG(1, "ptk_rekey: %d\n", config.u.ptk_rekey); } else if (config.field == WLAN_AP_FIELD_HW_MODE) { if (config.u.hw_mode == WLAN_AP_HW_MODE_IEEE80211B) { CMD_LOG(1, "hw_mode: b\n"); } else if (config.u.hw_mode == WLAN_AP_HW_MODE_IEEE80211G) { CMD_LOG(1, "hw_mode: g\n"); } else if (config.u.hw_mode == WLAN_AP_HW_MODE_IEEE80211A) { CMD_LOG(1, "hw_mode: a\n"); } else if (config.u.hw_mode == WLAN_AP_HW_MODE_IEEE80211AD) { CMD_LOG(1, "hw_mode: ad\n"); } else { CMD_ERR("%s: invalid hw_mode\n", __func__); } } else if (config.field == WLAN_AP_FIELD_IEEE80211N) { CMD_LOG(1, "ieee80211n: %d\n", config.u.ieee80211n); } else if (config.field == WLAN_AP_FIELD_CHANNEL) { CMD_LOG(1, "channel: %d\n", config.u.channel); } else if (config.field == WLAN_AP_FIELD_BEACON_INT) { CMD_LOG(1, "beacon_int: %d\n", config.u.beacon_int); } else if (config.field == WLAN_AP_FIELD_DTIM) { CMD_LOG(1, "dtim: %d\n", config.u.dtim); } else if (config.field == WLAN_AP_FIELD_MAX_NUM_STA) { CMD_LOG(1, "max_num_sta: %d\n", config.u.max_num_sta); } return 0; }
/* @return * -2: CMD_STATUS_INVALID_ARG * -1: CMD_STATUS_FAIL * 0: CMD_STATUS_OK */ static int cmd_wlan_ap_set(char *cmd) { char *value; wlan_ap_config_t config; value = cmd_strchr(cmd, ' '); if (value == NULL) return -2; *value++ = '\0'; config.field = WLAN_AP_FIELD_NUM; if (cmd_strcmp(cmd, "ssid") == 0) { uint8_t ssid_len = cmd_strlen(value); if ((ssid_len >= 1) && (ssid_len <= 32)) { config.field = WLAN_STA_FIELD_SSID; cmd_memcpy(config.u.ssid.ssid, value, ssid_len); config.u.ssid.ssid_len = ssid_len; } } else if (cmd_strcmp(cmd, "psk") == 0) { config.field = WLAN_AP_FIELD_PSK; cmd_strlcpy((char *)config.u.psk, value, sizeof(config.u.psk)); } else if (cmd_strcmp(cmd, "key_mgmt") == 0) { int key_mgmt = cmd_wpas_parse_key_mgmt(value); if (key_mgmt > 0) { config.field = WLAN_AP_FIELD_KEY_MGMT; config.u.key_mgmt = key_mgmt; } } else if (cmd_strcmp(cmd, "wpa") == 0) { int wpa_cipher = cmd_wpas_parse_cipher(value); if (wpa_cipher > 0) { config.field = WLAN_AP_FIELD_WPA_CIPHER; config.u.wpa_cipher = wpa_cipher; } } else if (cmd_strcmp(cmd, "rsn") == 0) { int rsn_cipher = cmd_wpas_parse_cipher(value); if (rsn_cipher > 0) { config.field = WLAN_AP_FIELD_RSN_CIPHER; config.u.rsn_cipher = rsn_cipher; } } else if (cmd_strcmp(cmd, "proto") == 0) { int proto = cmd_wpas_parse_proto(value); if (proto >= 0) { config.field = WLAN_AP_FIELD_PROTO; config.u.proto = proto; } } else if (cmd_strcmp(cmd, "auth_alg") == 0) { int auth_alg = cmd_wpas_parse_auth_alg(value); if (auth_alg > 0) { config.field = WLAN_AP_FIELD_AUTH_ALG; config.u.auth_alg = auth_alg; } } else if (cmd_strcmp(cmd, "group_rekey") == 0) { int group_rekey; if (cmd_wpas_parse_int(value, 0, INT32_MAX, &group_rekey) == 0) { config.field = WLAN_AP_FIELD_GROUP_REKEY; config.u.group_rekey = group_rekey; } } else if (cmd_strcmp(cmd, "strict_rekey") == 0) { int strict_rekey; if (cmd_wpas_parse_int(value, 0, 1, &strict_rekey) == 0) { config.field = WLAN_AP_FIELD_STRICT_REKEY; config.u.strict_rekey = strict_rekey; } } else if (cmd_strcmp(cmd, "gmk_rekey") == 0) { int gmk_rekey; if (cmd_wpas_parse_int(value, 0, INT32_MAX, &gmk_rekey) == 0) { config.field = WLAN_AP_FIELD_GMK_REKEY; config.u.gmk_rekey = gmk_rekey; } } else if (cmd_strcmp(cmd, "ptk_rekey") == 0) { int ptk_rekey; if (cmd_wpas_parse_int(value, 0, INT32_MAX, &ptk_rekey) == 0) { config.field = WLAN_AP_FIELD_PTK_REKEY; config.u.ptk_rekey = ptk_rekey; } } else if (cmd_strcmp(cmd, "hw_mode") == 0) { if ((value[0] == 'b') && (value[1] == '\0')) { config.field = WLAN_AP_FIELD_HW_MODE; config.u.hw_mode = WLAN_AP_HW_MODE_IEEE80211B; } else if ((value[0] == 'g') && (value[1] == '\0')) { config.field = WLAN_AP_FIELD_HW_MODE; config.u.hw_mode = WLAN_AP_HW_MODE_IEEE80211G; } } else if (cmd_strcmp(cmd, "80211n") == 0) { int ieee80211n; if (cmd_wpas_parse_int(value, 0, 1, &ieee80211n) == 0) { config.field = WLAN_AP_FIELD_IEEE80211N; config.u.ieee80211n = ieee80211n; } } else if (cmd_strcmp(cmd, "channel") == 0) { int channel; if (cmd_wpas_parse_int(value, 1, 14, &channel) == 0) { config.field = WLAN_AP_FIELD_CHANNEL; config.u.channel = channel; } } else if (cmd_strcmp(cmd, "beacon_int") == 0) { int beacon_int; if (cmd_wpas_parse_int(value, 15, 65535, &beacon_int) == 0) { config.field = WLAN_AP_FIELD_BEACON_INT; config.u.beacon_int = beacon_int; } } else if (cmd_strcmp(cmd, "dtim") == 0) { int dtim; if (cmd_wpas_parse_int(value, 1, 255, &dtim) == 0) { config.field = WLAN_AP_FIELD_DTIM; config.u.dtim = dtim; } } else if (cmd_strcmp(cmd, "max_num_sta") == 0) { int max_num_sta; if (cmd_wpas_parse_int(value, 0, INT32_MAX, &max_num_sta) == 0) { config.field = WLAN_AP_FIELD_MAX_NUM_STA; config.u.max_num_sta = max_num_sta; } } if (config.field < WLAN_AP_FIELD_NUM) return wlan_ap_set_config(&config); CMD_ERR("%s: invalid arg '%s %s'\n", __func__, cmd, value); return -2; }