src/host/layer23/src/mobile/vty_interface.c

   1 /*
   2  * (C) 2010 by Andreas Eversberg <jolly@eversberg.eu>
   3  *
   4  * All Rights Reserved
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along
  17  * with this program; if not, write to the Free Software Foundation, Inc.,
  18  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19  *
  20  */
  21
  22 #include <string.h>
  23 #include <stdlib.h>
  24 #include <stdarg.h>
  25 #include <unistd.h>
  26 #include <sys/types.h>
  27
  28 #include <osmocore/utils.h>
  29 #include <osmocore/gsm48.h>
  30
  31 #include <osmocom/bb/common/osmocom_data.h>
  32 #include <osmocom/bb/common/networks.h>
  33 #include <osmocom/bb/mobile/mncc.h>
  34 #include <osmocom/bb/mobile/transaction.h>
  35 #include <osmocom/bb/mobile/vty.h>
  36 #include <osmocom/bb/mobile/gps.h>
  37 #include <osmocom/vty/telnet_interface.h>
  38
  39 int mncc_call(struct osmocom_ms *ms, char *number);
  40 int mncc_hangup(struct osmocom_ms *ms);
  41 int mncc_answer(struct osmocom_ms *ms);
  42 int mncc_hold(struct osmocom_ms *ms);
  43 int mncc_retrieve(struct osmocom_ms *ms, int number);
  44
  45 extern struct llist_head ms_list;
  46 extern struct llist_head active_connections;
  47
  48 struct cmd_node ms_node = {
  49         MS_NODE,
  50         "%s(ms)#",
  51         1
  52 };
  53
  54 struct cmd_node testsim_node = {
  55         TESTSIM_NODE,
  56         "%s(test-sim)#",
  57         1
  58 };
  59
  60 static void print_vty(void *priv, const char *fmt, ...)
  61 {
  62         char buffer[1000];
  63         struct vty *vty = priv;
  64         va_list args;
  65
  66         va_start(args, fmt);
  67         vsnprintf(buffer, sizeof(buffer) - 1, fmt, args);
  68         buffer[sizeof(buffer) - 1] = '\0';
  69         va_end(args);
  70
  71         if (buffer[0]) {
  72                 if (buffer[strlen(buffer) - 1] == '\n') {
  73                         buffer[strlen(buffer) - 1] = '\0';
  74                         vty_out(vty, "%s%s", buffer, VTY_NEWLINE);
  75                 } else
  76                         vty_out(vty, "%s", buffer);
  77         }
  78 }
  79
  80 static struct osmocom_ms *get_ms(const char *name, struct vty *vty)
  81 {
  82         struct osmocom_ms *ms;
  83
  84         llist_for_each_entry(ms, &ms_list, entity) {
  85                 if (!strcmp(ms->name, name))
  86                         return ms;
  87         }
  88         vty_out(vty, "MS name '%s' does not exits.%s", name, VTY_NEWLINE);
  89
  90         return NULL;
  91 }
  92
  93 DEFUN(show_ms, show_ms_cmd, "show ms",
  94         SHOW_STR "Display available MS entities\n")
  95 {
  96         struct osmocom_ms *ms;
  97
  98         llist_for_each_entry(ms, &ms_list, entity) {
  99                 struct gsm_settings *set = &ms->settings;
 100
 101                 vty_out(vty, "MS NAME: %s%s", ms->name, VTY_NEWLINE);
 102                 vty_out(vty, " IMEI: %s%s", set->imei, VTY_NEWLINE);
 103                 vty_out(vty, " IMEISV: %s%s", set->imeisv, VTY_NEWLINE);
 104                 if (set->imei_random)
 105                         vty_out(vty, " IMEI generation: random (%d trailing "
 106                                 "digits)%s", set->imei_random, VTY_NEWLINE);
 107                 else
 108                         vty_out(vty, " IMEI generation: fixed%s", VTY_NEWLINE);
 109                 vty_out(vty, " network selection mode: %s%s",
 110                         (set->plmn_mode == PLMN_MODE_AUTO)
 111                                 ? "automatic" : "manual", VTY_NEWLINE);
 112         }
 113
 114         return CMD_SUCCESS;
 115 }
 116
 117 DEFUN(show_support, show_support_cmd, "show support [ms_name]",
 118         SHOW_STR "Display information about MS support\n"
 119         "Name of MS (see \"show ms\")")
 120 {
 121         struct osmocom_ms *ms;
 122
 123         if (argc) {
 124                 ms = get_ms(argv[0], vty);
 125                 if (!ms)
 126                         return CMD_WARNING;
 127                 gsm_support_dump(&ms->support, print_vty, vty);
 128         } else {
 129                 llist_for_each_entry(ms, &ms_list, entity) {
 130                         gsm_support_dump(&ms->support, print_vty, vty);
 131                         vty_out(vty, "%s", VTY_NEWLINE);
 132                 }
 133         }
 134
 135         return CMD_SUCCESS;
 136 }
 137
 138 static void gsm_states_dump(struct osmocom_ms *ms, struct vty *vty)
 139 {
 140         struct gsm_trans *trans;
 141
 142         vty_out(vty, "Current state of MS '%s'%s", ms->name, VTY_NEWLINE);
 143         if (ms->settings.plmn_mode == PLMN_MODE_AUTO)
 144                 vty_out(vty, " automatic network selection: %s%s",
 145                         plmn_a_state_names[ms->plmn.state], VTY_NEWLINE);
 146         else
 147                 vty_out(vty, " manual network selection: %s%s",
 148                         plmn_m_state_names[ms->plmn.state], VTY_NEWLINE);
 149         vty_out(vty, " cell selection: %s%s",
 150                 cs_state_names[ms->cellsel.state], VTY_NEWLINE);
 151         vty_out(vty, " radio ressource layer: %s%s",
 152                 gsm48_rr_state_names[ms->rrlayer.state], VTY_NEWLINE);
 153         vty_out(vty, " mobility management layer: %s",
 154                 gsm48_mm_state_names[ms->mmlayer.state]);
 155         if (ms->mmlayer.state == GSM48_MM_ST_MM_IDLE)
 156                 vty_out(vty, ", %s",
 157                         gsm48_mm_substate_names[ms->mmlayer.substate]);
 158         vty_out(vty, "%s", VTY_NEWLINE);
 159         llist_for_each_entry(trans, &ms->trans_list, entry) {
 160                 vty_out(vty, " call control: %s%s",
 161                         gsm48_cc_state_name(trans->cc.state), VTY_NEWLINE);
 162         }
 163 }
 164
 165 DEFUN(show_states, show_states_cmd, "show states [ms_name]",
 166         SHOW_STR "Display current states of given MS\n"
 167         "Name of MS (see \"show ms\")")
 168 {
 169         struct osmocom_ms *ms;
 170
 171         if (argc) {
 172                 ms = get_ms(argv[0], vty);
 173                 if (!ms)
 174                         return CMD_WARNING;
 175                 gsm_states_dump(ms, vty);
 176         } else {
 177                 llist_for_each_entry(ms, &ms_list, entity) {
 178                         gsm_states_dump(ms, vty);
 179                         vty_out(vty, "%s", VTY_NEWLINE);
 180                 }
 181         }
 182
 183         return CMD_SUCCESS;
 184 }
 185
 186 DEFUN(show_subscr, show_subscr_cmd, "show subscriber [ms_name]",
 187         SHOW_STR "Display information about subscriber\n"
 188         "Name of MS (see \"show ms\")")
 189 {
 190         struct osmocom_ms *ms;
 191
 192         if (argc) {
 193                 ms = get_ms(argv[0], vty);
 194                 if (!ms)
 195                         return CMD_WARNING;
 196                 gsm_subscr_dump(&ms->subscr, print_vty, vty);
 197         } else {
 198                 llist_for_each_entry(ms, &ms_list, entity) {
 199                         gsm_subscr_dump(&ms->subscr, print_vty, vty);
 200                         vty_out(vty, "%s", VTY_NEWLINE);
 201                 }
 202         }
 203
 204         return CMD_SUCCESS;
 205 }
 206
 207 DEFUN(show_cell, show_cell_cmd, "show cell MS_NAME",
 208         SHOW_STR "Display information about received cells\n"
 209         "Name of MS (see \"show ms\")")
 210 {
 211         struct osmocom_ms *ms;
 212
 213         ms = get_ms(argv[0], vty);
 214         if (!ms)
 215                 return CMD_WARNING;
 216
 217         gsm322_dump_cs_list(&ms->cellsel, GSM322_CS_FLAG_SYSINFO, print_vty,
 218                 vty);
 219
 220         return CMD_SUCCESS;
 221 }
 222
 223 DEFUN(show_cell_si, show_cell_si_cmd, "show cell MS_NAME <0-1023>",
 224         SHOW_STR "Display information about received cell\n"
 225         "Name of MS (see \"show ms\")\nRadio frequency number")
 226 {
 227         struct osmocom_ms *ms;
 228         int i;
 229         struct gsm48_sysinfo *s;
 230
 231         ms = get_ms(argv[0], vty);
 232         if (!ms)
 233                 return CMD_WARNING;
 234
 235         i = atoi(argv[1]);
 236         if (i < 0 || i > 1023) {
 237                 vty_out(vty, "Given ARFCN '%s' not in range (0..1023)%s",
 238                         argv[1], VTY_NEWLINE);
 239                 return CMD_WARNING;
 240         }
 241         s = ms->cellsel.list[i].sysinfo;
 242         if (!s) {
 243                 vty_out(vty, "Given ARFCN '%s' has no sysinfo available%s",
 244                         argv[1], VTY_NEWLINE);
 245                 return CMD_SUCCESS;
 246         }
 247
 248         gsm48_sysinfo_dump(s, i, print_vty, vty);
 249
 250         return CMD_SUCCESS;
 251 }
 252
 253 DEFUN(show_ba, show_ba_cmd, "show ba MS_NAME [mcc] [mnc]",
 254         SHOW_STR "Display information about band allocations\n"
 255         "Name of MS (see \"show ms\")\nMobile Country Code\n"
 256         "Mobile Network Code")
 257 {
 258         struct osmocom_ms *ms;
 259         uint16_t mcc = 0, mnc = 0;
 260
 261         ms = get_ms(argv[0], vty);
 262         if (!ms)
 263                 return CMD_WARNING;
 264
 265         if (argc >= 3) {
 266                 mcc = gsm_input_mcc((char *)argv[1]);
 267                 mnc = gsm_input_mnc((char *)argv[2]);
 268                 if (!mcc) {
 269                         vty_out(vty, "Given MCC invalid%s", VTY_NEWLINE);
 270                         return CMD_WARNING;
 271                 }
 272                 if (!mnc) {
 273                         vty_out(vty, "Given MNC invalid%s", VTY_NEWLINE);
 274                         return CMD_WARNING;
 275                 }
 276         }
 277
 278         gsm322_dump_ba_list(&ms->cellsel, mcc, mnc, print_vty, vty);
 279
 280         return CMD_SUCCESS;
 281 }
 282
 283 DEFUN(show_forb_plmn, show_forb_plmn_cmd, "show forbidden plmn MS_NAME",
 284         SHOW_STR "Display information about forbidden cells / networks\n"
 285         "Display forbidden PLMNs\nName of MS (see \"show ms\")")
 286 {
 287         struct osmocom_ms *ms;
 288
 289         ms = get_ms(argv[0], vty);
 290         if (!ms)
 291                 return CMD_WARNING;
 292
 293         gsm_subscr_dump_forbidden_plmn(ms, print_vty, vty);
 294
 295         return CMD_SUCCESS;
 296 }
 297
 298 DEFUN(show_forb_la, show_forb_la_cmd, "show forbidden location-area MS_NAME",
 299         SHOW_STR "Display information about forbidden cells / networks\n"
 300         "Display forbidden location areas\nName of MS (see \"show ms\")")
 301 {
 302         struct osmocom_ms *ms;
 303
 304         ms = get_ms(argv[0], vty);
 305         if (!ms)
 306                 return CMD_WARNING;
 307
 308         gsm322_dump_forbidden_la(ms, print_vty, vty);
 309
 310         return CMD_SUCCESS;
 311 }
 312
 313 DEFUN(monitor_network, monitor_network_cmd, "monitor network MS_NAME",
 314         "Monitor...\nMonitor network information\nName of MS (see \"show ms\")")
 315 {
 316         struct osmocom_ms *ms;
 317
 318         ms = get_ms(argv[0], vty);
 319         if (!ms)
 320                 return CMD_WARNING;
 321
 322         gsm48_rr_start_monitor(ms);
 323
 324         return CMD_SUCCESS;
 325 }
 326
 327 DEFUN(no_monitor_network, no_monitor_network_cmd, "no monitor network MS_NAME",
 328         NO_STR "Monitor...\nDeactivate monitor of network information\n"
 329         "Name of MS (see \"show ms\")")
 330 {
 331         struct osmocom_ms *ms;
 332
 333         ms = get_ms(argv[0], vty);
 334         if (!ms)
 335                 return CMD_WARNING;
 336
 337         gsm48_rr_stop_monitor(ms);
 338
 339         return CMD_SUCCESS;
 340 }
 341
 342 DEFUN(sim_test, sim_test_cmd, "sim testcard MS_NAME [mcc] [mnc]",
 343         "SIM actions\nInsert test card\nName of MS (see \"show ms\")\n"
 344         "Mobile Country Code of RPLMN\nMobile Network Code of RPLMN")
 345 {
 346         struct osmocom_ms *ms;
 347         uint16_t mcc = 0x001, mnc = 0x01f;
 348
 349         ms = get_ms(argv[0], vty);
 350         if (!ms)
 351                 return CMD_WARNING;
 352
 353         if (ms->subscr.sim_valid) {
 354                 vty_out(vty, "SIM already presend, remove first!%s",
 355                         VTY_NEWLINE);
 356                 return CMD_WARNING;
 357         }
 358
 359         if (argc >= 3) {
 360                 mcc = gsm_input_mcc((char *)argv[1]);
 361                 mnc = gsm_input_mnc((char *)argv[2]);
 362                 if (!mcc) {
 363                         vty_out(vty, "Given MCC invalid%s", VTY_NEWLINE);
 364                         return CMD_WARNING;
 365                 }
 366                 if (!mnc) {
 367                         vty_out(vty, "Given MNC invalid%s", VTY_NEWLINE);
 368                         return CMD_WARNING;
 369                 }
 370         }
 371
 372         gsm_subscr_testcard(ms, mcc, mnc);
 373
 374         return CMD_SUCCESS;
 375 }
 376
 377 DEFUN(sim_reader, sim_reader_cmd, "sim reader MS_NAME",
 378         "SIM actions\nSelect SIM from reader\nName of MS (see \"show ms\")")
 379 {
 380         struct osmocom_ms *ms;
 381
 382         ms = get_ms(argv[0], vty);
 383         if (!ms)
 384                 return CMD_WARNING;
 385
 386         if (ms->subscr.sim_valid) {
 387                 vty_out(vty, "SIM already presend, remove first!%s",
 388                         VTY_NEWLINE);
 389                 return CMD_WARNING;
 390         }
 391
 392         gsm_subscr_simcard(ms);
 393
 394         return CMD_SUCCESS;
 395 }
 396
 397 DEFUN(sim_remove, sim_remove_cmd, "sim remove MS_NAME",
 398         "SIM actions\nRemove SIM card\nName of MS (see \"show ms\")")
 399 {
 400         struct osmocom_ms *ms;
 401
 402         ms = get_ms(argv[0], vty);
 403         if (!ms)
 404                 return CMD_WARNING;
 405
 406         if (!ms->subscr.sim_valid) {
 407                 vty_out(vty, "No Sim inserted!%s", VTY_NEWLINE);
 408                 return CMD_WARNING;
 409         }
 410
 411         gsm_subscr_remove(ms);
 412
 413         return CMD_SUCCESS;
 414 }
 415
 416 DEFUN(sim_pin, sim_pin_cmd, "sim pin MS_NAME PIN",
 417         "SIM actions\nEnter PIN for SIM card\nName of MS (see \"show ms\")\n"
 418         "PIN number")
 419 {
 420         struct osmocom_ms *ms;
 421
 422         ms = get_ms(argv[0], vty);
 423         if (!ms)
 424                 return CMD_WARNING;
 425
 426         if (strlen(argv[1]) < 4 || strlen(argv[1]) > 8) {
 427                 vty_out(vty, "PIN must be in range 4..8!%s", VTY_NEWLINE);
 428                 return CMD_WARNING;
 429         }
 430
 431         if (!ms->subscr.sim_pin_required) {
 432                 vty_out(vty, "No PIN is required at this time!%s", VTY_NEWLINE);
 433                 return CMD_WARNING;
 434         }
 435
 436         gsm_subscr_sim_pin(ms, (char *)argv[1], "", 0);
 437
 438         return CMD_SUCCESS;
 439 }
 440
 441 DEFUN(sim_disable_pin, sim_disable_pin_cmd, "sim disable-pin MS_NAME PIN",
 442         "SIM actions\nDisable PIN of SIM card\nName of MS (see \"show ms\")\n"
 443         "PIN number")
 444 {
 445         struct osmocom_ms *ms;
 446
 447         ms = get_ms(argv[0], vty);
 448         if (!ms)
 449                 return CMD_WARNING;
 450
 451         if (strlen(argv[1]) < 4 || strlen(argv[1]) > 8) {
 452                 vty_out(vty, "PIN must be in range 4..8!%s", VTY_NEWLINE);
 453                 return CMD_WARNING;
 454         }
 455
 456         gsm_subscr_sim_pin(ms, (char *)argv[1], "", -1);
 457
 458         return CMD_SUCCESS;
 459 }
 460
 461 DEFUN(sim_enable_pin, sim_enable_pin_cmd, "sim enable-pin MS_NAME PIN",
 462         "SIM actions\nEnable PIN of SIM card\nName of MS (see \"show ms\")\n"
 463         "PIN number")
 464 {
 465         struct osmocom_ms *ms;
 466
 467         ms = get_ms(argv[0], vty);
 468         if (!ms)
 469                 return CMD_WARNING;
 470
 471         if (strlen(argv[1]) < 4 || strlen(argv[1]) > 8) {
 472                 vty_out(vty, "PIN must be in range 4..8!%s", VTY_NEWLINE);
 473                 return CMD_WARNING;
 474         }
 475
 476         gsm_subscr_sim_pin(ms, (char *)argv[1], "", 1);
 477
 478         return CMD_SUCCESS;
 479 }
 480
 481 DEFUN(sim_change_pin, sim_change_pin_cmd, "sim change-pin MS_NAME OLD NEW",
 482         "SIM actions\nChange PIN of SIM card\nName of MS (see \"show ms\")\n"
 483         "Old PIN number\nNew PIN number")
 484 {
 485         struct osmocom_ms *ms;
 486
 487         ms = get_ms(argv[0], vty);
 488         if (!ms)
 489                 return CMD_WARNING;
 490
 491         if (strlen(argv[1]) < 4 || strlen(argv[1]) > 8) {
 492                 vty_out(vty, "Old PIN must be in range 4..8!%s", VTY_NEWLINE);
 493                 return CMD_WARNING;
 494         }
 495         if (strlen(argv[2]) < 4 || strlen(argv[2]) > 8) {
 496                 vty_out(vty, "New PIN must be in range 4..8!%s", VTY_NEWLINE);
 497                 return CMD_WARNING;
 498         }
 499
 500         gsm_subscr_sim_pin(ms, (char *)argv[1], (char *)argv[2], 2);
 501
 502         return CMD_SUCCESS;
 503 }
 504
 505 DEFUN(sim_unblock_pin, sim_unblock_pin_cmd, "sim unblock-pin MS_NAME PUC NEW",
 506         "SIM actions\nChange PIN of SIM card\nName of MS (see \"show ms\")\n"
 507         "Personal Unblock Key\nNew PIN number")
 508 {
 509         struct osmocom_ms *ms;
 510
 511         ms = get_ms(argv[0], vty);
 512         if (!ms)
 513                 return CMD_WARNING;
 514
 515         if (strlen(argv[1]) != 8) {
 516                 vty_out(vty, "PUC must be 8 digits!%s", VTY_NEWLINE);
 517                 return CMD_WARNING;
 518         }
 519         if (strlen(argv[2]) < 4 || strlen(argv[2]) > 8) {
 520                 vty_out(vty, "PIN must be in range 4..8!%s", VTY_NEWLINE);
 521                 return CMD_WARNING;
 522         }
 523
 524         gsm_subscr_sim_pin(ms, (char *)argv[1], (char *)argv[2], 99);
 525
 526         return CMD_SUCCESS;
 527 }
 528
 529 DEFUN(network_select, network_select_cmd, "network select MS_NAME MCC MNC",
 530         "Select ...\nSelect Network\nName of MS (see \"show ms\")\n"
 531         "Mobile Country Code\nMobile Network Code")
 532 {
 533         struct osmocom_ms *ms;
 534         struct gsm322_plmn *plmn;
 535         struct msgb *nmsg;
 536         struct gsm322_msg *ngm;
 537         struct gsm322_plmn_list *temp;
 538         uint16_t mcc = gsm_input_mcc((char *)argv[1]),
 539                  mnc = gsm_input_mnc((char *)argv[2]);
 540         int found = 0;
 541
 542         ms = get_ms(argv[0], vty);
 543         if (!ms)
 544                 return CMD_WARNING;
 545         plmn = &ms->plmn;
 546
 547         if (!mcc) {
 548                 vty_out(vty, "Given MCC invalid%s", VTY_NEWLINE);
 549                 return CMD_WARNING;
 550         }
 551         if (!mnc) {
 552                 vty_out(vty, "Given MNC invalid%s", VTY_NEWLINE);
 553                 return CMD_WARNING;
 554         }
 555
 556         llist_for_each_entry(temp, &plmn->sorted_plmn, entry)
 557                 if (temp->mcc == mcc &&  temp->mnc == mnc)
 558                         found = 1;
 559         if (!found) {
 560                 vty_out(vty, "Network not in list!%s", VTY_NEWLINE);
 561                 return CMD_WARNING;
 562         }
 563
 564         nmsg = gsm322_msgb_alloc(GSM322_EVENT_CHOOSE_PLMN);
 565         if (!nmsg)
 566                 return CMD_WARNING;
 567         ngm = (struct gsm322_msg *) nmsg->data;
 568         ngm->mcc = mcc;
 569         ngm->mnc = mnc;
 570         gsm322_plmn_sendmsg(ms, nmsg);
 571
 572         return CMD_SUCCESS;
 573 }
 574
 575 DEFUN(call, call_cmd, "call MS_NAME (NUMBER|emergency|answer|hangup|hold)",
 576         "Make a call\nName of MS (see \"show ms\")\nPhone number to call\n"
 577         "Make an emergency call\nAnswer an incomming call\nHangup a call\n"
 578         "Hold current active call\n")
 579 {
 580         struct osmocom_ms *ms;
 581
 582         ms = get_ms(argv[0], vty);
 583         if (!ms)
 584                 return CMD_WARNING;
 585
 586         switch (argv[1][0]) {
 587         case 'a':
 588                 mncc_answer(ms);
 589                 break;
 590         case 'h':
 591                 if (argv[1][1] == 'a')
 592                         mncc_hangup(ms);
 593                 else
 594                         mncc_hold(ms);
 595                 break;
 596         default:
 597                 mncc_call(ms, (char *)argv[1]);
 598         }
 599
 600         return CMD_SUCCESS;
 601 }
 602
 603 DEFUN(call_retr, call_retr_cmd, "call MS_NAME retrieve [number]",
 604         "Make a call\nName of MS (see \"show ms\")\n"
 605         "Retrieve call on hold\nNumber of call to retrieve")
 606 {
 607         struct osmocom_ms *ms;
 608
 609         ms = get_ms(argv[0], vty);
 610         if (!ms)
 611                 return CMD_WARNING;
 612
 613         mncc_retrieve(ms, (argc > 1) ? atoi(argv[1]) : 0);
 614
 615         return CMD_SUCCESS;
 616 }
 617
 618 DEFUN(network_show, network_show_cmd, "network show MS_NAME",
 619         "Network ...\nShow results of network search (again)\n"
 620         "Name of MS (see \"show ms\")")
 621 {
 622         struct osmocom_ms *ms;
 623         struct gsm322_plmn *plmn;
 624         struct gsm322_plmn_list *temp;
 625
 626         ms = get_ms(argv[0], vty);
 627         if (!ms)
 628                 return CMD_WARNING;
 629         plmn = &ms->plmn;
 630
 631         if (ms->settings.plmn_mode != PLMN_MODE_AUTO
 632          && plmn->state != GSM322_M3_NOT_ON_PLMN) {
 633                 vty_out(vty, "Start network search first!%s", VTY_NEWLINE);
 634                 return CMD_WARNING;
 635         }
 636
 637         llist_for_each_entry(temp, &plmn->sorted_plmn, entry)
 638                 vty_out(vty, " Network %s, %s (%s, %s)%s",
 639                         gsm_print_mcc(temp->mcc), gsm_print_mnc(temp->mnc),
 640                         gsm_get_mcc(temp->mcc),
 641                         gsm_get_mnc(temp->mcc, temp->mnc), VTY_NEWLINE);
 642
 643         return CMD_SUCCESS;
 644 }
 645
 646 DEFUN(network_search, network_search_cmd, "network search MS_NAME",
 647         "Network ...\nTrigger network search\nName of MS (see \"show ms\")")
 648 {
 649         struct osmocom_ms *ms;
 650         struct msgb *nmsg;
 651
 652         ms = get_ms(argv[0], vty);
 653         if (!ms)
 654                 return CMD_WARNING;
 655
 656         nmsg = gsm322_msgb_alloc(GSM322_EVENT_USER_RESEL);
 657         if (!nmsg)
 658                 return CMD_WARNING;
 659         gsm322_plmn_sendmsg(ms, nmsg);
 660
 661         return CMD_SUCCESS;
 662 }
 663
 664 DEFUN(cfg_gps_enable, cfg_gps_enable_cmd, "gps enable",
 665         "GPS receiver")
 666 {
 667         if (gps_open()) {
 668                 gps.enable = 1;
 669                 vty_out(vty, "Failed to open GPS device!%s", VTY_NEWLINE);
 670                 return CMD_WARNING;
 671         }
 672         gps.enable = 1;
 673
 674         return CMD_SUCCESS;
 675 }
 676
 677 DEFUN(cfg_no_gps_enable, cfg_no_gps_enable_cmd, "no gps enable",
 678         NO_STR "Disable GPS receiver")
 679 {
 680         if (gps.enable)
 681                 gps_close();
 682         gps.enable = 0;
 683
 684         return CMD_SUCCESS;
 685 }
 686
 687 DEFUN(cfg_gps_device, cfg_gps_device_cmd, "gps device DEVICE",
 688         "GPS receiver\nSelect serial device\n"
 689         "Full path of serial device including /dev/")
 690 {
 691         strncpy(gps.device, argv[0], sizeof(gps.device));
 692         gps.device[sizeof(gps.device) - 1] = '\0';
 693         if (gps.enable) {
 694                 gps_close();
 695                 if (gps_open()) {
 696                         vty_out(vty, "Failed to open GPS device!%s",
 697                                 VTY_NEWLINE);
 698                         return CMD_WARNING;
 699                 }
 700         }
 701
 702         return CMD_SUCCESS;
 703 }
 704
 705 DEFUN(cfg_gps_baud, cfg_gps_baud_cmd, "gps baudrate "
 706         "(default|4800|""9600|19200|38400|57600|115200)",
 707         "GPS receiver\nSelect baud rate\nDefault, don't modify\n\n\n\n\n\n")
 708 {
 709         if (argv[0][0] == 'd')
 710                 gps.baud = 0;
 711         else
 712                 gps.baud = atoi(argv[0]);
 713         if (gps.enable) {
 714                 gps_close();
 715                 if (gps_open()) {
 716                         gps.enable = 0;
 717                         vty_out(vty, "Failed to open GPS device!%s",
 718                                 VTY_NEWLINE);
 719                         return CMD_WARNING;
 720                 }
 721         }
 722
 723         return CMD_SUCCESS;
 724 }
 725
 726 /* per MS config */
 727 DEFUN(cfg_ms, cfg_ms_cmd, "ms MS_NAME",
 728         "Select a mobile station to configure\nName of MS (see \"show ms\")")
 729 {
 730         struct osmocom_ms *ms;
 731
 732         ms = get_ms(argv[0], vty);
 733         if (!ms)
 734                 return CMD_WARNING;
 735
 736         vty->index = ms;
 737         vty->node = MS_NODE;
 738
 739         return CMD_SUCCESS;
 740 }
 741
 742 static void config_write_ms_single(struct vty *vty, struct osmocom_ms *ms)
 743 {
 744         struct gsm_settings *set = &ms->settings;
 745
 746         vty_out(vty, "ms %s%s", ms->name, VTY_NEWLINE);
 747         switch(set->sim_type) {
 748                 case GSM_SIM_TYPE_NONE:
 749                 vty_out(vty, " sim none%s", VTY_NEWLINE);
 750                 break;
 751                 case GSM_SIM_TYPE_READER:
 752                 vty_out(vty, " sim reader%s", VTY_NEWLINE);
 753                 break;
 754                 case GSM_SIM_TYPE_TEST:
 755                 vty_out(vty, " sim test%s", VTY_NEWLINE);
 756                 break;
 757         }
 758         vty_out(vty, " network-selection-mode %s%s", (set->plmn_mode
 759                         == PLMN_MODE_AUTO) ? "auto" : "manual", VTY_NEWLINE);
 760         vty_out(vty, " imei %s %s%s", set->imei,
 761                 set->imeisv + strlen(set->imei), VTY_NEWLINE);
 762         if (set->imei_random)
 763                 vty_out(vty, " imei-random %d%s", set->imei_random,
 764                         VTY_NEWLINE);
 765         else
 766                 vty_out(vty, " imei-fixed%s", VTY_NEWLINE);
 767         if (set->emergency_imsi[0])
 768                 vty_out(vty, " emergency-imsi %s%s", set->emergency_imsi,
 769                         VTY_NEWLINE);
 770         else
 771                 vty_out(vty, " no emergency-imsi%s", VTY_NEWLINE);
 772         vty_out(vty, " %scall-waiting%s", (set->cw) ? "" : "no ", VTY_NEWLINE);
 773         vty_out(vty, " %sclip%s", (set->clip) ? "" : "no ", VTY_NEWLINE);
 774         vty_out(vty, " %sclir%s", (set->clir) ? "" : "no ", VTY_NEWLINE);
 775         vty_out(vty, " test-sim%s", VTY_NEWLINE);
 776         vty_out(vty, "  imsi %s%s", set->test_imsi, VTY_NEWLINE);
 777         switch (set->test_ki_type) {
 778         case GSM_SIM_KEY_XOR:
 779                 vty_out(vty, "  ki xor %s%s", hexdump(set->test_ki, 12),
 780                         VTY_NEWLINE);
 781                 break;
 782         case GSM_SIM_KEY_COMP128:
 783                 vty_out(vty, "  ki comp128 %s%s", hexdump(set->test_ki, 16),
 784                         VTY_NEWLINE);
 785                 break;
 786         }
 787         vty_out(vty, "  %sbarred-access%s", (set->test_barr) ? "" : "no ",
 788                 VTY_NEWLINE);
 789         if (set->test_rplmn_valid)
 790                 vty_out(vty, "  rplmn %s %s%s",
 791                         gsm_print_mcc(set->test_rplmn_mcc),
 792                         gsm_print_mnc(set->test_rplmn_mnc),
 793                         VTY_NEWLINE);
 794         else
 795                 vty_out(vty, "  no rplmn%s", VTY_NEWLINE);
 796         vty_out(vty, "  hplmn-search %s%s", (set->test_always) ? "everywhere"
 797                         : "foreign-country", VTY_NEWLINE);
 798         vty_out(vty, " exit%s", VTY_NEWLINE);
 799         if (set->alter_tx_power)
 800                 if (set->alter_tx_power_value)
 801                         vty_out(vty, " tx-power %d%s",
 802                                 set->alter_tx_power_value, VTY_NEWLINE);
 803                 else
 804                         vty_out(vty, " tx-power full%s", VTY_NEWLINE);
 805         else
 806                 vty_out(vty, " tx-power auto%s", VTY_NEWLINE);
 807         if (set->alter_delay)
 808                 vty_out(vty, " simulated-delay %d%s", set->alter_delay,
 809                         VTY_NEWLINE);
 810         else
 811                 vty_out(vty, " no simulated-delay%s", VTY_NEWLINE);
 812         if (set->stick)
 813                 vty_out(vty, " stick %d%s", set->stick_arfcn,
 814                         VTY_NEWLINE);
 815         else
 816                 vty_out(vty, " no stick%s", VTY_NEWLINE);
 817         if (set->no_lupd)
 818                 vty_out(vty, " no location-updating%s", VTY_NEWLINE);
 819         else
 820                 vty_out(vty, " location-updating%s", VTY_NEWLINE);
 821         vty_out(vty, "exit%s", VTY_NEWLINE);
 822         vty_out(vty, "!%s", VTY_NEWLINE);
 823 }
 824
 825 static int config_write_ms(struct vty *vty)
 826 {
 827         struct osmocom_ms *ms;
 828
 829         vty_out(vty, "gps device %s%s", gps.device, VTY_NEWLINE);
 830         if (gps.baud)
 831                 vty_out(vty, "gps baudrate %d%s", gps.baud, VTY_NEWLINE);
 832         else
 833                 vty_out(vty, "gps baudrate default%s", VTY_NEWLINE);
 834         vty_out(vty, "%sgps enable%s", (gps.enable) ? "" : "no ", VTY_NEWLINE);
 835         vty_out(vty, "!%s", VTY_NEWLINE);
 836
 837         llist_for_each_entry(ms, &ms_list, entity)
 838                 config_write_ms_single(vty, ms);
 839
 840         return CMD_SUCCESS;
 841 }
 842
 843 DEFUN(cfg_ms_sim, cfg_ms_sim_cmd, "sim (none|reader|test)",
 844         "Set SIM card type when powering on\nNo SIM interted\n"
 845         "Use SIM from reader\nTest SIM inserted")
 846 {
 847         struct osmocom_ms *ms = vty->index;
 848
 849         switch (argv[0][0]) {
 850         case 'n':
 851                 ms->settings.sim_type = GSM_SIM_TYPE_NONE;
 852                 break;
 853         case 'r':
 854                 ms->settings.sim_type = GSM_SIM_TYPE_READER;
 855                 break;
 856         case 't':
 857                 ms->settings.sim_type = GSM_SIM_TYPE_TEST;
 858                 break;
 859         default:
 860                 vty_out(vty, "unknown SIM type%s", VTY_NEWLINE);
 861                 return CMD_WARNING;
 862         }
 863
 864         return CMD_SUCCESS;
 865 }
 866
 867 DEFUN(cfg_ms_mode, cfg_ms_mode_cmd, "network-selection-mode (auto|manual)",
 868         "Set network selection mode\nAutomatic network selection\n"
 869         "Manual network selection")
 870 {
 871         struct osmocom_ms *ms = vty->index;
 872         struct msgb *nmsg;
 873
 874         if (!ms->plmn.state) {
 875                 if (argv[0][0] == 'a')
 876                         ms->settings.plmn_mode = PLMN_MODE_AUTO;
 877                 else
 878                         ms->settings.plmn_mode = PLMN_MODE_MANUAL;
 879
 880                 return CMD_SUCCESS;
 881         }
 882         if (argv[0][0] == 'a')
 883                 nmsg = gsm322_msgb_alloc(GSM322_EVENT_SEL_AUTO);
 884         else
 885                 nmsg = gsm322_msgb_alloc(GSM322_EVENT_SEL_MANUAL);
 886         if (!nmsg)
 887                 return CMD_WARNING;
 888         gsm322_plmn_sendmsg(ms, nmsg);
 889
 890         return CMD_SUCCESS;
 891 }
 892
 893 DEFUN(cfg_ms_imei, cfg_ms_imei_cmd, "imei IMEI [SV]",
 894         "Set IMEI (enter without control digit)\n15 Digits IMEI\n"
 895         "Software version digit")
 896 {
 897         struct osmocom_ms *ms = vty->index;
 898         char *error, *sv = "0";
 899
 900         if (argc >= 2)
 901                 sv = (char *)argv[1];
 902
 903         error = gsm_check_imei(argv[0], sv);
 904         if (error) {
 905                 vty_out(vty, "%s%s", error, VTY_NEWLINE);
 906                 return CMD_WARNING;
 907         }
 908
 909         strcpy(ms->settings.imei, argv[0]);
 910         strcpy(ms->settings.imeisv, argv[0]);
 911         strcpy(ms->settings.imeisv + 15, sv);
 912
 913         return CMD_SUCCESS;
 914 }
 915
 916 DEFUN(cfg_ms_imei_fixed, cfg_ms_imei_fixed_cmd, "imei-fixed",
 917         "Use fixed IMEI on every power on")
 918 {
 919         struct osmocom_ms *ms = vty->index;
 920
 921         ms->settings.imei_random = 0;
 922
 923         return CMD_SUCCESS;
 924 }
 925
 926 DEFUN(cfg_ms_imei_random, cfg_ms_imei_random_cmd, "imei-random <0-15>",
 927         "Use random IMEI on every power on\n"
 928         "Number of trailing digits to randomize")
 929 {
 930         struct osmocom_ms *ms = vty->index;
 931
 932         ms->settings.imei_random = atoi(argv[0]);
 933
 934         return CMD_SUCCESS;
 935 }
 936
 937 DEFUN(cfg_ms_emerg_imsi, cfg_ms_emerg_imsi_cmd, "emergency-imsi IMSI",
 938         "Use special IMSI for emergency calls\n15 digits IMSI")
 939 {
 940         struct osmocom_ms *ms = vty->index;
 941         char *error;
 942
 943         error = gsm_check_imsi(argv[0]);
 944         if (error) {
 945                 vty_out(vty, "%s%s", error, VTY_NEWLINE);
 946                 return CMD_WARNING;
 947         }
 948         strcpy(ms->settings.emergency_imsi, argv[0]);
 949
 950         return CMD_SUCCESS;
 951 }
 952
 953 DEFUN(cfg_ms_no_emerg_imsi, cfg_ms_no_emerg_imsi_cmd, "no emergency-imsi",
 954         NO_STR "Use IMSI of SIM or IMEI for emergency calls")
 955 {
 956         struct osmocom_ms *ms = vty->index;
 957
 958         ms->settings.emergency_imsi[0] = '\0';
 959
 960         return CMD_SUCCESS;
 961 }
 962
 963 DEFUN(cfg_no_cw, cfg_ms_no_cw_cmd, "no call-waiting",
 964         NO_STR "Disallow waiting calls")
 965 {
 966         struct osmocom_ms *ms = vty->index;
 967
 968         ms->settings.cw = 0;
 969
 970         return CMD_SUCCESS;
 971 }
 972
 973 DEFUN(cfg_cw, cfg_ms_cw_cmd, "call-waiting",
 974         "Allow waiting calls")
 975 {
 976         struct osmocom_ms *ms = vty->index;
 977
 978         ms->settings.cw = 1;
 979
 980         return CMD_SUCCESS;
 981 }
 982
 983 DEFUN(cfg_clip, cfg_ms_clip_cmd, "clip",
 984         "Force caller ID presentation")
 985 {
 986         struct osmocom_ms *ms = vty->index;
 987
 988         ms->settings.clip = 1;
 989         ms->settings.clir = 0;
 990
 991         return CMD_SUCCESS;
 992 }
 993
 994 DEFUN(cfg_clir, cfg_ms_clir_cmd, "clir",
 995         "Force caller ID restriction")
 996 {
 997         struct osmocom_ms *ms = vty->index;
 998
 999         ms->settings.clip = 0;
1000         ms->settings.clir = 1;
1001
1002         return CMD_SUCCESS;
1003 }
1004
1005 DEFUN(cfg_no_clip, cfg_ms_no_clip_cmd, "no clip",
1006         NO_STR "Disable forcing of caller ID presentation")
1007 {
1008         struct osmocom_ms *ms = vty->index;
1009
1010         ms->settings.clip = 0;
1011
1012         return CMD_SUCCESS;
1013 }
1014
1015 DEFUN(cfg_no_clir, cfg_ms_no_clir_cmd, "no clir",
1016         NO_STR "Disable forcing of caller ID restriction")
1017 {
1018         struct osmocom_ms *ms = vty->index;
1019
1020         ms->settings.clir = 0;
1021
1022         return CMD_SUCCESS;
1023 }
1024
1025 DEFUN(cfg_ms_tx_power, cfg_ms_tx_power_cmd, "tx-power (auto|full)",
1026         "Set the way to choose transmit power\nControlled by BTS\n"
1027         "Always full power\nFixed GSM power value if supported")
1028 {
1029         struct osmocom_ms *ms = vty->index;
1030
1031         switch (argv[0][0]) {
1032         case 'a':
1033                 ms->settings.alter_tx_power = 0;
1034                 break;
1035         case 'f':
1036                 ms->settings.alter_tx_power = 1;
1037                 ms->settings.alter_tx_power_value = 0;
1038                 break;
1039         }
1040
1041         return CMD_SUCCESS;
1042 }
1043
1044 DEFUN(cfg_ms_tx_power_val, cfg_ms_tx_power_val_cmd, "tx-power <0-31>",
1045         "Set the way to choose transmit power\n"
1046         "Fixed GSM power value if supported")
1047 {
1048         struct osmocom_ms *ms = vty->index;
1049
1050         ms->settings.alter_tx_power = 1;
1051         ms->settings.alter_tx_power_value = atoi(argv[0]);
1052
1053         return CMD_SUCCESS;
1054 }
1055
1056 DEFUN(cfg_ms_sim_delay, cfg_ms_sim_delay_cmd, "simulated-delay <-128-127>",
1057         "Simulate a lower or higher distance from the BTS\n"
1058         "Delay in half bits (distance in 553.85 meter steps)")
1059 {
1060         struct osmocom_ms *ms = vty->index;
1061
1062         ms->settings.alter_delay = atoi(argv[0]);
1063
1064         return CMD_SUCCESS;
1065 }
1066
1067 DEFUN(cfg_ms_no_sim_delay, cfg_ms_no_sim_delay_cmd, "no simulated-delay",
1068         NO_STR "Do not simulate a lower or higher distance from the BTS")
1069 {
1070         struct osmocom_ms *ms = vty->index;
1071
1072         ms->settings.alter_delay = 0;
1073
1074         return CMD_SUCCESS;
1075 }
1076
1077 DEFUN(cfg_ms_stick, cfg_ms_stick_cmd, "stick <0-1023>",
1078         "Stick to the given cell\nARFCN of the cell to stick to")
1079 {
1080         struct osmocom_ms *ms = vty->index;
1081
1082         ms->settings.stick = 1;
1083         ms->settings.stick_arfcn = atoi(argv[0]);
1084
1085         return CMD_SUCCESS;
1086 }
1087
1088 DEFUN(cfg_ms_no_stick, cfg_ms_no_stick_cmd, "no stick",
1089         NO_STR "Do not stick to any cell")
1090 {
1091         struct osmocom_ms *ms = vty->index;
1092
1093         ms->settings.stick = 0;
1094
1095         return CMD_SUCCESS;
1096 }
1097
1098 DEFUN(cfg_ms_lupd, cfg_ms_lupd_cmd, "location-updating",
1099         "Allow location updating")
1100 {
1101         struct osmocom_ms *ms = vty->index;
1102
1103         ms->settings.no_lupd = 0;
1104
1105         return CMD_SUCCESS;
1106 }
1107
1108 DEFUN(cfg_ms_no_lupd, cfg_ms_no_lupd_cmd, "no location-updating",
1109         NO_STR "Do not allow location updating")
1110 {
1111         struct osmocom_ms *ms = vty->index;
1112
1113         ms->settings.no_lupd = 1;
1114
1115         return CMD_SUCCESS;
1116 }
1117
1118 /* per testsim config */
1119 DEFUN(cfg_ms_testsim, cfg_ms_testsim_cmd, "test-sim",
1120         "Configure test SIM emulation")
1121 {
1122         vty->node = TESTSIM_NODE;
1123
1124         return CMD_SUCCESS;
1125 }
1126
1127 static int config_write_dummy(struct vty *vty)
1128 {
1129         return CMD_SUCCESS;
1130 }
1131
1132 DEFUN(cfg_test_imsi, cfg_test_imsi_cmd, "imsi IMSI",
1133         "Set IMSI on test card\n15 digits IMSI")
1134 {
1135         struct osmocom_ms *ms = vty->index;
1136         char *error = gsm_check_imsi(argv[0]);
1137
1138         if (error) {
1139                 vty_out(vty, "%s%s", error, VTY_NEWLINE);
1140                 return CMD_WARNING;
1141         }
1142
1143         strcpy(ms->settings.test_imsi, argv[0]);
1144
1145         return CMD_SUCCESS;
1146 }
1147
1148 #define HEX_STR "\nByte as two digits hexadecimal"
1149 DEFUN(cfg_test_ki_xor, cfg_test_ki_xor_cmd, "ki xor HEX HEX HEX HEX HEX HEX "
1150         "HEX HEX HEX HEX HEX HEX",
1151         "Set Key (Kc) on test card\nUse XOR algorithm" HEX_STR HEX_STR HEX_STR
1152         HEX_STR HEX_STR HEX_STR HEX_STR HEX_STR HEX_STR HEX_STR HEX_STR HEX_STR)
1153 {
1154         struct osmocom_ms *ms = vty->index;
1155         struct gsm_settings *set = &ms->settings;
1156         uint8_t ki[12];
1157         const char *p;
1158         int i;
1159
1160         for (i = 0; i < 12; i++) {
1161                 p = argv[i];
1162                 if (!strncmp(p, "0x", 2))
1163                         p += 2;
1164                 if (strlen(p) != 2) {
1165                         vty_out(vty, "Expecting two digits hex value (with or "
1166                                 "without 0x in front)%s", VTY_NEWLINE);
1167                         return CMD_WARNING;
1168                 }
1169                 ki[i] = strtoul(p, NULL, 16);
1170         }
1171
1172         set->test_ki_type = GSM_SIM_KEY_XOR;
1173         memcpy(set->test_ki, ki, 12);
1174         return CMD_SUCCESS;
1175 }
1176
1177 DEFUN(cfg_test_ki_comp128, cfg_test_ki_comp128_cmd, "ki comp128 HEX HEX HEX "
1178         "HEX HEX HEX HEX HEX HEX HEX HEX HEX HEX HEX HEX HEX",
1179         "Set Key (Kc) on test card\nUse XOR algorithm" HEX_STR HEX_STR HEX_STR
1180         HEX_STR HEX_STR HEX_STR HEX_STR HEX_STR HEX_STR HEX_STR HEX_STR HEX_STR
1181         HEX_STR HEX_STR HEX_STR HEX_STR)
1182 {
1183         struct osmocom_ms *ms = vty->index;
1184         struct gsm_settings *set = &ms->settings;
1185         uint8_t ki[16];
1186         const char *p;
1187         int i;
1188
1189         for (i = 0; i < 16; i++) {
1190                 p = argv[i];
1191                 if (!strncmp(p, "0x", 2))
1192                         p += 2;
1193                 if (strlen(p) != 2) {
1194                         vty_out(vty, "Expecting two digits hex value (with or "
1195                                 "without 0x in front)%s", VTY_NEWLINE);
1196                         return CMD_WARNING;
1197                 }
1198                 ki[i] = strtoul(p, NULL, 16);
1199         }
1200
1201         set->test_ki_type = GSM_SIM_KEY_COMP128;
1202         memcpy(set->test_ki, ki, 16);
1203         return CMD_SUCCESS;
1204 }
1205
1206 DEFUN(cfg_test_barr, cfg_test_barr_cmd, "barred-access",
1207         "Allow access to barred cells")
1208 {
1209         struct osmocom_ms *ms = vty->index;
1210
1211         ms->settings.test_barr = 1;
1212
1213         return CMD_SUCCESS;
1214 }
1215
1216 DEFUN(cfg_test_no_barr, cfg_test_no_barr_cmd, "no barred-access",
1217         NO_STR "Deny access to barred cells")
1218 {
1219         struct osmocom_ms *ms = vty->index;
1220
1221         ms->settings.test_barr = 0;
1222
1223         return CMD_SUCCESS;
1224 }
1225
1226 DEFUN(cfg_test_no_rplmn, cfg_test_no_rplmn_cmd, "no rplmn",
1227         NO_STR "Unset Registered PLMN")
1228 {
1229         struct osmocom_ms *ms = vty->index;
1230
1231         ms->settings.test_rplmn_valid = 0;
1232
1233         return CMD_SUCCESS;
1234 }
1235
1236 DEFUN(cfg_test_rplmn, cfg_test_rplmn_cmd, "rplmn MCC MNC",
1237         "Set Registered PLMN\nMobile Country Code\nMobile Network Code")
1238 {
1239         struct osmocom_ms *ms = vty->index;
1240         uint16_t mcc = gsm_input_mcc((char *)argv[0]),
1241                  mnc = gsm_input_mnc((char *)argv[1]);
1242
1243         if (!mcc) {
1244                 vty_out(vty, "Given MCC invalid%s", VTY_NEWLINE);
1245                 return CMD_WARNING;
1246         }
1247         if (!mnc) {
1248                 vty_out(vty, "Given MNC invalid%s", VTY_NEWLINE);
1249                 return CMD_WARNING;
1250         }
1251         ms->settings.test_rplmn_valid = 1;
1252         ms->settings.test_rplmn_mcc = mcc;
1253         ms->settings.test_rplmn_mnc = mnc;
1254
1255         return CMD_SUCCESS;
1256 }
1257
1258 DEFUN(cfg_test_hplmn, cfg_test_hplmn_cmd, "hplmn-search (everywhere|foreign-country)",
1259         "Set Home PLMN search mode\n"
1260         "Search for HPLMN when on any other network\n"
1261         "Search for HPLMN when in a different country")
1262 {
1263         struct osmocom_ms *ms = vty->index;
1264
1265         switch (argv[0][0]) {
1266         case 'e':
1267                 ms->settings.test_always = 1;
1268                 break;
1269         case 'f':
1270                 ms->settings.test_always = 0;
1271                 break;
1272         }
1273
1274         return CMD_SUCCESS;
1275 }
1276
1277 enum node_type ms_vty_go_parent(struct vty *vty)
1278 {
1279         switch (vty->node) {
1280         case MS_NODE:
1281                 vty->node = CONFIG_NODE;
1282                 vty->index = NULL;
1283                 break;
1284         case TESTSIM_NODE:
1285                 vty->node = MS_NODE;
1286                 break;
1287         default:
1288                 vty->node = CONFIG_NODE;
1289         }
1290
1291         return vty->node;
1292 }
1293
1294 /* Down vty node level. */
1295 gDEFUN(ournode_exit,
1296        ournode_exit_cmd, "exit", "Exit current mode and down to previous mode\n")
1297 {
1298         switch (vty->node) {
1299         case MS_NODE:
1300                 vty->node = CONFIG_NODE;
1301                 vty->index = NULL;
1302                 break;
1303         case TESTSIM_NODE:
1304                 vty->node = MS_NODE;
1305                 break;
1306         default:
1307                 break;
1308         }
1309         return CMD_SUCCESS;
1310 }
1311
1312 /* End of configuration. */
1313 gDEFUN(ournode_end,
1314        ournode_end_cmd, "end", "End current mode and change to enable mode.")
1315 {
1316         switch (vty->node) {
1317         case VIEW_NODE:
1318         case ENABLE_NODE:
1319                 /* Nothing to do. */
1320                 break;
1321         case CONFIG_NODE:
1322         case VTY_NODE:
1323         case MS_NODE:
1324         case TESTSIM_NODE:
1325                 vty_config_unlock(vty);
1326                 vty->node = ENABLE_NODE;
1327                 vty->index = NULL;
1328                 vty->index_sub = NULL;
1329                 break;
1330         default:
1331                 break;
1332         }
1333         return CMD_SUCCESS;
1334 }
1335
1336 int ms_vty_init(void)
1337 {
1338         install_element_ve(&show_ms_cmd);
1339         install_element_ve(&show_subscr_cmd);
1340         install_element_ve(&show_support_cmd);
1341         install_element_ve(&show_states_cmd);
1342         install_element_ve(&show_cell_cmd);
1343         install_element_ve(&show_cell_si_cmd);
1344         install_element_ve(&show_ba_cmd);
1345         install_element_ve(&show_forb_la_cmd);
1346         install_element_ve(&show_forb_plmn_cmd);
1347         install_element_ve(&monitor_network_cmd);
1348         install_element_ve(&no_monitor_network_cmd);
1349
1350         install_element(ENABLE_NODE, &sim_test_cmd);
1351         install_element(ENABLE_NODE, &sim_reader_cmd);
1352         install_element(ENABLE_NODE, &sim_remove_cmd);
1353         install_element(ENABLE_NODE, &sim_pin_cmd);
1354         install_element(ENABLE_NODE, &sim_disable_pin_cmd);
1355         install_element(ENABLE_NODE, &sim_enable_pin_cmd);
1356         install_element(ENABLE_NODE, &sim_change_pin_cmd);
1357         install_element(ENABLE_NODE, &sim_unblock_pin_cmd);
1358         install_element(ENABLE_NODE, &network_search_cmd);
1359         install_element(ENABLE_NODE, &network_show_cmd);
1360         install_element(ENABLE_NODE, &network_select_cmd);
1361         install_element(ENABLE_NODE, &call_cmd);
1362         install_element(ENABLE_NODE, &call_retr_cmd);
1363
1364         install_element(CONFIG_NODE, &cfg_gps_device_cmd);
1365         install_element(CONFIG_NODE, &cfg_gps_baud_cmd);
1366         install_element(CONFIG_NODE, &cfg_gps_enable_cmd);
1367         install_element(CONFIG_NODE, &cfg_no_gps_enable_cmd);
1368
1369         install_element(CONFIG_NODE, &cfg_ms_cmd);
1370         install_element(CONFIG_NODE, &ournode_end_cmd);
1371         install_node(&ms_node, config_write_ms);
1372         install_default(MS_NODE);
1373         install_element(MS_NODE, &ournode_exit_cmd);
1374         install_element(MS_NODE, &ournode_end_cmd);
1375         install_element(MS_NODE, &cfg_ms_sim_cmd);
1376         install_element(MS_NODE, &cfg_ms_mode_cmd);
1377         install_element(MS_NODE, &cfg_ms_imei_cmd);
1378         install_element(MS_NODE, &cfg_ms_imei_fixed_cmd);
1379         install_element(MS_NODE, &cfg_ms_imei_random_cmd);
1380         install_element(MS_NODE, &cfg_ms_no_emerg_imsi_cmd);
1381         install_element(MS_NODE, &cfg_ms_emerg_imsi_cmd);
1382         install_element(MS_NODE, &cfg_ms_cw_cmd);
1383         install_element(MS_NODE, &cfg_ms_no_cw_cmd);
1384         install_element(MS_NODE, &cfg_ms_clip_cmd);
1385         install_element(MS_NODE, &cfg_ms_clir_cmd);
1386         install_element(MS_NODE, &cfg_ms_no_clip_cmd);
1387         install_element(MS_NODE, &cfg_ms_no_clir_cmd);
1388         install_element(MS_NODE, &cfg_ms_testsim_cmd);
1389         install_element(MS_NODE, &cfg_ms_tx_power_cmd);
1390         install_element(MS_NODE, &cfg_ms_tx_power_val_cmd);
1391         install_element(MS_NODE, &cfg_ms_sim_delay_cmd);
1392         install_element(MS_NODE, &cfg_ms_no_sim_delay_cmd);
1393         install_element(MS_NODE, &cfg_ms_stick_cmd);
1394         install_element(MS_NODE, &cfg_ms_no_stick_cmd);
1395         install_element(MS_NODE, &cfg_ms_lupd_cmd);
1396         install_element(MS_NODE, &cfg_ms_no_lupd_cmd);
1397
1398         install_node(&testsim_node, config_write_dummy);
1399         install_default(TESTSIM_NODE);
1400         install_element(TESTSIM_NODE, &ournode_exit_cmd);
1401         install_element(TESTSIM_NODE, &ournode_end_cmd);
1402         install_element(TESTSIM_NODE, &cfg_test_imsi_cmd);
1403         install_element(TESTSIM_NODE, &cfg_test_ki_xor_cmd);
1404         install_element(TESTSIM_NODE, &cfg_test_ki_comp128_cmd);
1405         install_element(TESTSIM_NODE, &cfg_test_barr_cmd);
1406         install_element(TESTSIM_NODE, &cfg_test_no_barr_cmd);
1407         install_element(TESTSIM_NODE, &cfg_test_no_rplmn_cmd);
1408         install_element(TESTSIM_NODE, &cfg_test_rplmn_cmd);
1409         install_element(TESTSIM_NODE, &cfg_test_hplmn_cmd);
1410
1411         return 0;
1412 }
1413
1414 void vty_notify(struct osmocom_ms *ms, const char *fmt, ...)
1415 {
1416         struct telnet_connection *connection;
1417         char buffer[1000];
1418         va_list args;
1419         struct vty *vty;
1420
1421         if (fmt) {
1422                 va_start(args, fmt);
1423                 vsnprintf(buffer, sizeof(buffer) - 1, fmt, args);
1424                 buffer[sizeof(buffer) - 1] = '\0';
1425                 va_end(args);
1426
1427                 if (!buffer[0])
1428                         return;
1429         }
1430
1431         llist_for_each_entry(connection, &active_connections, entry) {
1432                 vty = connection->vty;
1433                 if (!vty)
1434                         continue;
1435                 if (!fmt) {
1436                         vty_out(vty, "%s%% (MS %s)%s", VTY_NEWLINE, ms->name,
1437                                 VTY_NEWLINE);
1438                         continue;
1439                 }
1440                 if (buffer[strlen(buffer) - 1] == '\n') {
1441                         buffer[strlen(buffer) - 1] = '\0';
1442                         vty_out(vty, "%% %s%s", buffer, VTY_NEWLINE);
1443                         buffer[strlen(buffer)] = '\n';
1444                 } else
1445                         vty_out(vty, "%% %s", buffer);
1446         }
1447 }
1448