1 /* 2 * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved. 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions 6 * are met: 7 * 8 * Redistribution of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 11 * Redistribution in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 15 * Neither the name of Sun Microsystems, Inc. or the names of 16 * contributors may be used to endorse or promote products derived 17 * from this software without specific prior written permission. 18 * 19 * This software is provided "AS IS," without a warranty of any kind. 20 * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, 21 * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A 22 * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. 23 * SUN MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE 24 * FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING 25 * OR DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL 26 * SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, 27 * OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR 28 * PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF 29 * LIABILITY, ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, 30 * EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. 31 */ 32 33 #include <stdlib.h> 34 #include <string.h> 35 #include <stdio.h> 36 #include <sys/types.h> 37 #include <sys/select.h> 38 #include <sys/time.h> 39 #include <signal.h> 40 #include <unistd.h> 41 42 #include <ipmitool/helper.h> 43 #include <ipmitool/log.h> 44 #include <ipmitool/ipmi.h> 45 #include <ipmitool/ipmi_intf.h> 46 #include <ipmitool/ipmi_user.h> 47 #include <ipmitool/ipmi_constants.h> 48 #include <ipmitool/ipmi_strings.h> 49 #include <ipmitool/bswap.h> 50 51 52 extern int verbose; 53 extern int csv_output; 54 55 56 /* _ipmi_get_user_access - Get User Access for given channel. Results are stored 57 * into passed struct. 58 * 59 * @intf - IPMI interface 60 * @user_access_rsp - ptr to user_access_t with UID and Channel set 61 * 62 * returns - negative number means error, positive is a ccode 63 */ 64 int 65 _ipmi_get_user_access(struct ipmi_intf *intf, 66 struct user_access_t *user_access_rsp) 67 { 68 struct ipmi_rq req = {0}; 69 struct ipmi_rs *rsp; 70 uint8_t data[2]; 71 if (user_access_rsp == NULL) { 72 return (-3); 73 } 74 data[0] = user_access_rsp->channel & 0x0F; 75 data[1] = user_access_rsp->user_id & 0x3F; 76 req.msg.netfn = IPMI_NETFN_APP; 77 req.msg.cmd = IPMI_GET_USER_ACCESS; 78 req.msg.data = data; 79 req.msg.data_len = 2; 80 rsp = intf->sendrecv(intf, &req); 81 if (rsp == NULL) { 82 return (-1); 83 } else if (rsp->ccode != 0) { 84 return rsp->ccode; 85 } else if (rsp->data_len != 4) { 86 return (-2); 87 } 88 user_access_rsp->max_user_ids = rsp->data[0] & 0x3F; 89 user_access_rsp->enable_status = rsp->data[1] & 0xC0; 90 user_access_rsp->enabled_user_ids = rsp->data[1] & 0x3F; 91 user_access_rsp->fixed_user_ids = rsp->data[2] & 0x3F; 92 user_access_rsp->callin_callback = rsp->data[3] & 0x40; 93 user_access_rsp->link_auth = rsp->data[3] & 0x20; 94 user_access_rsp->ipmi_messaging = rsp->data[3] & 0x10; 95 user_access_rsp->privilege_limit = rsp->data[3] & 0x0F; 96 return rsp->ccode; 97 } 98 99 /* _ipmi_get_user_name - Fetch User Name for given User ID. User Name is stored 100 * into passed structure. 101 * 102 * @intf - ipmi interface 103 * @user_name - user_name_t struct with UID set 104 * 105 * returns - negative number means error, positive is a ccode 106 */ 107 int 108 _ipmi_get_user_name(struct ipmi_intf *intf, struct user_name_t *user_name_ptr) 109 { 110 struct ipmi_rq req = {0}; 111 struct ipmi_rs *rsp; 112 uint8_t data[1]; 113 if (user_name_ptr == NULL) { 114 return (-3); 115 } 116 data[0] = user_name_ptr->user_id & 0x3F; 117 req.msg.netfn = IPMI_NETFN_APP; 118 req.msg.cmd = IPMI_GET_USER_NAME; 119 req.msg.data = data; 120 req.msg.data_len = 1; 121 rsp = intf->sendrecv(intf, &req); 122 if (rsp == NULL) { 123 return (-1); 124 } else if (rsp->ccode > 0) { 125 return rsp->ccode; 126 } else if (rsp->data_len != 17) { 127 return (-2); 128 } 129 memset(user_name_ptr->user_name, '\0', 17); 130 memcpy(user_name_ptr->user_name, rsp->data, 16); 131 return rsp->ccode; 132 } 133 134 /* _ipmi_set_user_access - Set User Access for given channel. 135 * 136 * @intf - IPMI interface 137 * @user_access_req - ptr to user_access_t with desired User Access. 138 * @change_priv_limit_only - change User's privilege limit only 139 * 140 * returns - negative number means error, positive is a ccode 141 */ 142 int 143 _ipmi_set_user_access(struct ipmi_intf *intf, 144 struct user_access_t *user_access_req, 145 uint8_t change_priv_limit_only) 146 { 147 uint8_t data[4]; 148 struct ipmi_rq req = {0}; 149 struct ipmi_rs *rsp; 150 if (user_access_req == NULL) { 151 return (-3); 152 } 153 data[0] = change_priv_limit_only ? 0x00 : 0x80; 154 if (user_access_req->callin_callback) { 155 data[0] |= 0x40; 156 } 157 if (user_access_req->link_auth) { 158 data[0] |= 0x20; 159 } 160 if (user_access_req->ipmi_messaging) { 161 data[0] |= 0x10; 162 } 163 data[0] |= (user_access_req->channel & 0x0F); 164 data[1] = user_access_req->user_id & 0x3F; 165 data[2] = user_access_req->privilege_limit & 0x0F; 166 data[3] = user_access_req->session_limit & 0x0F; 167 req.msg.netfn = IPMI_NETFN_APP; 168 req.msg.cmd = IPMI_SET_USER_ACCESS; 169 req.msg.data = data; 170 req.msg.data_len = 4; 171 rsp = intf->sendrecv(intf, &req); 172 if (rsp == NULL) { 173 return (-1); 174 } else { 175 return rsp->ccode; 176 } 177 } 178 179 /* _ipmi_set_user_password - Set User Password command. 180 * 181 * @intf - IPMI interface 182 * @user_id - IPMI User ID 183 * @operation - which operation to perform(en/disable user, set/test password) 184 * @password - User Password 185 * @is_twenty_byte - 0 = store as 16byte, otherwise store as 20byte password 186 * 187 * returns - negative number means error, positive is a ccode 188 */ 189 int 190 _ipmi_set_user_password(struct ipmi_intf *intf, uint8_t user_id, 191 uint8_t operation, const char *password, 192 uint8_t is_twenty_byte) 193 { 194 struct ipmi_rq req = {0}; 195 struct ipmi_rs *rsp; 196 uint8_t *data; 197 uint8_t data_len = (is_twenty_byte) ? 22 : 18; 198 data = malloc(sizeof(uint8_t) * data_len); 199 if (data == NULL) { 200 return (-4); 201 } 202 memset(data, 0, data_len); 203 data[0] = (is_twenty_byte) ? 0x80 : 0x00; 204 data[0] |= (0x0F & user_id); 205 data[1] = 0x03 & operation; 206 if (password != NULL) { 207 size_t copy_len = strlen(password); 208 if (copy_len > (data_len - 2)) { 209 copy_len = data_len - 2; 210 } else if (copy_len < 1) { 211 copy_len = 0; 212 } 213 strncpy((char *)(data + 2), password, copy_len); 214 } 215 216 req.msg.netfn = IPMI_NETFN_APP; 217 req.msg.cmd = IPMI_SET_USER_PASSWORD; 218 req.msg.data = data; 219 req.msg.data_len = data_len; 220 rsp = intf->sendrecv(intf, &req); 221 free(data); 222 data = NULL; 223 if (rsp == NULL) { 224 return (-1); 225 } 226 return rsp->ccode; 227 } 228 229 static void 230 dump_user_access(const char *user_name, 231 struct user_access_t *user_access) 232 { 233 static int printed_header = 0; 234 if (!printed_header) { 235 printf("ID Name Callin Link Auth IPMI Msg " 236 "Channel Priv Limit\n"); 237 printed_header = 1; 238 } 239 printf("%-4d%-17s%-8s%-11s%-11s%-s\n", 240 user_access->user_id, 241 user_name, 242 user_access->callin_callback? "false": "true ", 243 user_access->link_auth? "true ": "false", 244 user_access->ipmi_messaging? "true ": "false", 245 val2str(user_access->privilege_limit, 246 ipmi_privlvl_vals)); 247 } 248 249 250 251 static void 252 dump_user_access_csv(const char *user_name, 253 struct user_access_t *user_access) 254 { 255 printf("%d,%s,%s,%s,%s,%s\n", 256 user_access->user_id, 257 user_name, 258 user_access->callin_callback? "false": "true", 259 user_access->link_auth? "true": "false", 260 user_access->ipmi_messaging? "true": "false", 261 val2str(user_access->privilege_limit, 262 ipmi_privlvl_vals)); 263 } 264 265 /* ipmi_print_user_list - List IPMI Users and their ACLs for given channel. 266 * 267 * @intf - IPMI interface 268 * @channel_number - IPMI channel 269 * 270 * returns - 0 on success, (-1) on error 271 */ 272 static int 273 ipmi_print_user_list(struct ipmi_intf *intf, uint8_t channel_number) 274 { 275 struct user_access_t user_access = {0}; 276 struct user_name_t user_name = {0}; 277 int ccode = 0; 278 uint8_t current_user_id = 1; 279 do { 280 memset(&user_access, 0, sizeof(user_access)); 281 user_access.user_id = current_user_id; 282 user_access.channel = channel_number; 283 ccode = _ipmi_get_user_access(intf, &user_access); 284 if (eval_ccode(ccode) != 0) { 285 return (-1); 286 } 287 memset(&user_name, 0, sizeof(user_name)); 288 user_name.user_id = current_user_id; 289 ccode = _ipmi_get_user_name(intf, &user_name); 290 if (eval_ccode(ccode) != 0) { 291 return (-1); 292 } 293 if ((current_user_id == 0) 294 || user_access.link_auth 295 || user_access.ipmi_messaging 296 || strcmp("", (char *)user_name.user_name)) { 297 if (csv_output) { 298 dump_user_access_csv((char *)user_name.user_name, 299 &user_access); 300 } else { 301 dump_user_access((char *)user_name.user_name, 302 &user_access); 303 } 304 } 305 ++current_user_id; 306 } while ((current_user_id <= user_access.max_user_ids) 307 && (current_user_id <= IPMI_UID_MAX)); 308 return 0; 309 } 310 311 /* ipmi_print_user_summary - print User statistics for given channel 312 * 313 * @intf - IPMI interface 314 * @channel_number - channel number 315 * 316 * returns - 0 on success, (-1) on error 317 */ 318 static int 319 ipmi_print_user_summary(struct ipmi_intf *intf, uint8_t channel_number) 320 { 321 struct user_access_t user_access = {0}; 322 int ccode = 0; 323 user_access.channel = channel_number; 324 user_access.user_id = 1; 325 ccode = _ipmi_get_user_access(intf, &user_access); 326 if (eval_ccode(ccode) != 0) { 327 return (-1); 328 } 329 if (csv_output) { 330 printf("%" PRIu8 ",%" PRIu8 ",%" PRIu8 "\n", 331 user_access.max_user_ids, 332 user_access.enabled_user_ids, 333 user_access.fixed_user_ids); 334 } else { 335 printf("Maximum IDs : %" PRIu8 "\n", 336 user_access.max_user_ids); 337 printf("Enabled User Count : %" PRIu8 "\n", 338 user_access.enabled_user_ids); 339 printf("Fixed Name Count : %" PRIu8 "\n", 340 user_access.fixed_user_ids); 341 } 342 return 0; 343 } 344 345 /* 346 * ipmi_user_set_username 347 */ 348 static int 349 ipmi_user_set_username( 350 struct ipmi_intf *intf, 351 uint8_t user_id, 352 const char *name) 353 { 354 struct ipmi_rs * rsp; 355 struct ipmi_rq req; 356 uint8_t msg_data[17]; 357 358 /* 359 * Ensure there is space for the name in the request message buffer 360 */ 361 if (strlen(name) >= sizeof(msg_data)) { 362 return -1; 363 } 364 365 memset(&req, 0, sizeof(req)); 366 req.msg.netfn = IPMI_NETFN_APP; /* 0x06 */ 367 req.msg.cmd = IPMI_SET_USER_NAME; /* 0x45 */ 368 req.msg.data = msg_data; 369 req.msg.data_len = sizeof(msg_data); 370 memset(msg_data, 0, sizeof(msg_data)); 371 372 /* The channel number will remain constant throughout this function */ 373 msg_data[0] = user_id; 374 strncpy((char *)(msg_data + 1), name, strlen(name)); 375 376 rsp = intf->sendrecv(intf, &req); 377 378 if (rsp == NULL) { 379 lprintf(LOG_ERR, "Set User Name command failed (user %d, name %s)", 380 user_id, name); 381 return -1; 382 } 383 if (rsp->ccode > 0) { 384 lprintf(LOG_ERR, "Set User Name command failed (user %d, name %s): %s", 385 user_id, name, val2str(rsp->ccode, completion_code_vals)); 386 return -1; 387 } 388 389 return 0; 390 } 391 392 /* ipmi_user_test_password - Call _ipmi_set_user_password() with operation bit 393 * set to test password and interpret result. 394 */ 395 static int 396 ipmi_user_test_password(struct ipmi_intf *intf, uint8_t user_id, 397 const char *password, uint8_t is_twenty_byte_password) 398 { 399 int ret = 0; 400 ret = _ipmi_set_user_password(intf, user_id, 401 IPMI_PASSWORD_TEST_PASSWORD, password, 402 is_twenty_byte_password); 403 404 switch (ret) { 405 case 0: 406 printf("Success\n"); 407 break; 408 case 0x80: 409 printf("Failure: password incorrect\n"); 410 break; 411 case 0x81: 412 printf("Failure: wrong password size\n"); 413 break; 414 default: 415 printf("Unknown error\n"); 416 } 417 418 return ((ret == 0) ? 0 : -1); 419 } 420 421 422 /* 423 * print_user_usage 424 */ 425 static void 426 print_user_usage(void) 427 { 428 lprintf(LOG_NOTICE, 429 "User Commands:"); 430 lprintf(LOG_NOTICE, 431 " summary [<channel number>]"); 432 lprintf(LOG_NOTICE, 433 " list [<channel number>]"); 434 lprintf(LOG_NOTICE, 435 " set name <user id> <username>"); 436 lprintf(LOG_NOTICE, 437 " set password <user id> [<password> <16|20>]"); 438 lprintf(LOG_NOTICE, 439 " disable <user id>"); 440 lprintf(LOG_NOTICE, 441 " enable <user id>"); 442 lprintf(LOG_NOTICE, 443 " priv <user id> <privilege level> [<channel number>]"); 444 lprintf(LOG_NOTICE, 445 " Privilege levels:"); 446 lprintf(LOG_NOTICE, 447 " * 0x1 - Callback"); 448 lprintf(LOG_NOTICE, 449 " * 0x2 - User"); 450 lprintf(LOG_NOTICE, 451 " * 0x3 - Operator"); 452 lprintf(LOG_NOTICE, 453 " * 0x4 - Administrator"); 454 lprintf(LOG_NOTICE, 455 " * 0x5 - OEM Proprietary"); 456 lprintf(LOG_NOTICE, 457 " * 0xF - No Access"); 458 lprintf(LOG_NOTICE, ""); 459 lprintf(LOG_NOTICE, 460 " test <user id> <16|20> [<password]>"); 461 lprintf(LOG_NOTICE, ""); 462 } 463 464 465 const char * 466 ipmi_user_build_password_prompt(uint8_t user_id) 467 { 468 static char prompt[128]; 469 memset(prompt, 0, 128); 470 snprintf(prompt, 128, "Password for user %d: ", user_id); 471 return prompt; 472 } 473 474 /* ask_password - ask user for password 475 * 476 * @user_id: User ID which will be built-in into text 477 * 478 * @returns pointer to char with password 479 */ 480 char * 481 ask_password(uint8_t user_id) 482 { 483 const char *password_prompt = 484 ipmi_user_build_password_prompt(user_id); 485 # ifdef HAVE_GETPASSPHRASE 486 return getpassphrase(password_prompt); 487 # else 488 return (char*)getpass(password_prompt); 489 # endif 490 } 491 492 int 493 ipmi_user_summary(struct ipmi_intf *intf, int argc, char **argv) 494 { 495 /* Summary*/ 496 uint8_t channel; 497 if (argc == 1) { 498 channel = 0x0E; /* Ask about the current channel */ 499 } else if (argc == 2) { 500 if (is_ipmi_channel_num(argv[1], &channel) != 0) { 501 return (-1); 502 } 503 } else { 504 print_user_usage(); 505 return (-1); 506 } 507 return ipmi_print_user_summary(intf, channel); 508 } 509 510 int 511 ipmi_user_list(struct ipmi_intf *intf, int argc, char **argv) 512 { 513 /* List */ 514 uint8_t channel; 515 if (argc == 1) { 516 channel = 0x0E; /* Ask about the current channel */ 517 } else if (argc == 2) { 518 if (is_ipmi_channel_num(argv[1], &channel) != 0) { 519 return (-1); 520 } 521 } else { 522 print_user_usage(); 523 return (-1); 524 } 525 return ipmi_print_user_list(intf, channel); 526 } 527 528 int 529 ipmi_user_test(struct ipmi_intf *intf, int argc, char **argv) 530 { 531 /* Test */ 532 char *password = NULL; 533 int password_length = 0; 534 uint8_t user_id = 0; 535 /* a little irritating, isn't it */ 536 if (argc != 3 && argc != 4) { 537 print_user_usage(); 538 return (-1); 539 } 540 if (is_ipmi_user_id(argv[1], &user_id)) { 541 return (-1); 542 } 543 if (str2int(argv[2], &password_length) != 0 544 || (password_length != 16 && password_length != 20)) { 545 lprintf(LOG_ERR, 546 "Given password length '%s' is invalid.", 547 argv[2]); 548 lprintf(LOG_ERR, "Expected value is either 16 or 20."); 549 return (-1); 550 } 551 if (argc == 3) { 552 /* We need to prompt for a password */ 553 password = ask_password(user_id); 554 if (password == NULL) { 555 lprintf(LOG_ERR, "ipmitool: malloc failure"); 556 return (-1); 557 } 558 } else { 559 password = argv[3]; 560 } 561 return ipmi_user_test_password(intf, 562 user_id, 563 password, 564 password_length == 20); 565 } 566 567 int 568 ipmi_user_priv(struct ipmi_intf *intf, int argc, char **argv) 569 { 570 struct user_access_t user_access = {0}; 571 int ccode = 0; 572 573 if (argc != 3 && argc != 4) { 574 print_user_usage(); 575 return (-1); 576 } 577 if (argc == 4) { 578 if (is_ipmi_channel_num(argv[3], &user_access.channel) != 0) { 579 return (-1); 580 } 581 } else { 582 /* Use channel running on */ 583 user_access.channel = 0x0E; 584 } 585 if (is_ipmi_user_priv_limit(argv[2], &user_access.privilege_limit) != 0 586 || is_ipmi_user_id(argv[1], &user_access.user_id) != 0) { 587 return (-1); 588 } 589 ccode = _ipmi_set_user_access(intf, &user_access, 1); 590 if (eval_ccode(ccode) != 0) { 591 lprintf(LOG_ERR, "Set Privilege Level command failed (user %d)", 592 user_access.user_id); 593 return (-1); 594 } else { 595 printf("Set Privilege Level command successful (user %d)", 596 user_access.user_id); 597 return 0; 598 } 599 } 600 601 int 602 ipmi_user_mod(struct ipmi_intf *intf, int argc, char **argv) 603 { 604 /* Disable / Enable */ 605 uint8_t user_id; 606 uint8_t operation; 607 608 if (argc != 2) { 609 print_user_usage(); 610 return (-1); 611 } 612 if (is_ipmi_user_id(argv[1], &user_id)) { 613 return (-1); 614 } 615 operation = (strncmp(argv[0], "disable", 7) == 0) ? 616 IPMI_PASSWORD_DISABLE_USER : IPMI_PASSWORD_ENABLE_USER; 617 618 return _ipmi_set_user_password(intf, user_id, operation, 619 (char *)NULL, 0); 620 } 621 622 int 623 ipmi_user_password(struct ipmi_intf *intf, int argc, char **argv) 624 { 625 char *password = NULL; 626 int ccode = 0; 627 uint8_t password_type = 16; 628 uint8_t user_id = 0; 629 if (is_ipmi_user_id(argv[2], &user_id)) { 630 return (-1); 631 } 632 633 if (argc == 3) { 634 /* We need to prompt for a password */ 635 char *tmp; 636 password = ask_password(user_id); 637 if (password == NULL) { 638 lprintf(LOG_ERR, "ipmitool: malloc failure"); 639 return (-1); 640 } 641 tmp = ask_password(user_id); 642 if (tmp == NULL) { 643 lprintf(LOG_ERR, "ipmitool: malloc failure"); 644 return (-1); 645 } 646 if (strlen(password) != strlen(tmp) 647 || strncmp(password, tmp, strlen(tmp))) { 648 lprintf(LOG_ERR, "Passwords do not match."); 649 return (-1); 650 } 651 } else { 652 password = argv[3]; 653 if (argc > 4) { 654 if ((str2uchar(argv[4], &password_type) != 0) 655 || (password_type != 16 && password_type != 20)) { 656 lprintf(LOG_ERR, "Invalid password length '%s'", argv[4]); 657 return (-1); 658 } 659 } else { 660 password_type = 16; 661 } 662 } 663 664 if (password == NULL) { 665 lprintf(LOG_ERR, "Unable to parse password argument."); 666 return (-1); 667 } else if (strlen(password) > 20) { 668 lprintf(LOG_ERR, "Password is too long (> 20 bytes)"); 669 return (-1); 670 } 671 672 ccode = _ipmi_set_user_password(intf, user_id, 673 IPMI_PASSWORD_SET_PASSWORD, password, 674 password_type > 16); 675 if (eval_ccode(ccode) != 0) { 676 lprintf(LOG_ERR, "Set User Password command failed (user %d)", 677 user_id); 678 return (-1); 679 } else { 680 printf("Set User Password command successful (user %d)\n", 681 user_id); 682 return 0; 683 } 684 } 685 686 int 687 ipmi_user_name(struct ipmi_intf *intf, int argc, char **argv) 688 { 689 /* Set Name */ 690 uint8_t user_id = 0; 691 if (argc != 4) { 692 print_user_usage(); 693 return (-1); 694 } 695 if (is_ipmi_user_id(argv[2], &user_id)) { 696 return (-1); 697 } 698 if (strlen(argv[3]) > 16) { 699 lprintf(LOG_ERR, "Username is too long (> 16 bytes)"); 700 return (-1); 701 } 702 703 return ipmi_user_set_username(intf, user_id, argv[3]); 704 } 705 706 /* 707 * ipmi_user_main 708 * 709 * Upon entry to this function argv should contain our arguments 710 * specific to this subcommand 711 */ 712 int 713 ipmi_user_main(struct ipmi_intf *intf, int argc, char **argv) 714 { 715 if (argc == 0) { 716 lprintf(LOG_ERR, "Not enough parameters given."); 717 print_user_usage(); 718 return (-1); 719 } 720 if (strncmp(argv[0], "help", 4) == 0) { 721 /* Help */ 722 print_user_usage(); 723 return 0; 724 } else if (strncmp(argv[0], "summary", 7) == 0) { 725 return ipmi_user_summary(intf, argc, argv); 726 } else if (strncmp(argv[0], "list", 4) == 0) { 727 return ipmi_user_list(intf, argc, argv); 728 } else if (strncmp(argv[0], "test", 4) == 0) { 729 return ipmi_user_test(intf, argc, argv); 730 } else if (strncmp(argv[0], "set", 3) == 0) { 731 /* Set */ 732 if ((argc >= 3) 733 && (strncmp("password", argv[1], 8) == 0)) { 734 return ipmi_user_password(intf, argc, argv); 735 } else if ((argc >= 2) 736 && (strncmp("name", argv[1], 4) == 0)) { 737 return ipmi_user_name(intf, argc, argv); 738 } else { 739 print_user_usage(); 740 return (-1); 741 } 742 } else if (strncmp(argv[0], "priv", 4) == 0) { 743 return ipmi_user_priv(intf, argc, argv); 744 } else if ((strncmp(argv[0], "disable", 7) == 0) 745 || (strncmp(argv[0], "enable", 6) == 0)) { 746 return ipmi_user_mod(intf, argc, argv); 747 } else { 748 lprintf(LOG_ERR, "Invalid user command: '%s'\n", argv[0]); 749 print_user_usage(); 750 return (-1); 751 } 752 } 753