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 struct cmd_node support_node = {
  61         SUPPORT_NODE,
  62         "%s(support)#",
  63         1
  64 };
  65
  66 static void print_vty(void *priv, const char *fmt, ...)
  67 {
  68         char buffer[1000];
  69         struct vty *vty = priv;
  70         va_list args;
  71
  72         va_start(args, fmt);
  73         vsnprintf(buffer, sizeof(buffer) - 1, fmt, args);
  74         buffer[sizeof(buffer) - 1] = '\0';
  75         va_end(args);
  76
  77         if (buffer[0]) {
  78                 if (buffer[strlen(buffer) - 1] == '\n') {
  79                         buffer[strlen(buffer) - 1] = '\0';
  80                         vty_out(vty, "%s%s", buffer, VTY_NEWLINE);
  81                 } else
  82                         vty_out(vty, "%s", buffer);
  83         }
  84 }
  85
  86 int vty_reading = 0;
  87
  88 static void vty_restart(struct vty *vty)
  89 {
  90         if (vty_reading)
  91                 return;
  92         vty_out(vty, "You must restart for change to take effect!%s",
  93                 VTY_NEWLINE);
  94 }
  95
  96 static struct osmocom_ms *get_ms(const char *name, struct vty *vty)
  97 {
  98         struct osmocom_ms *ms;
  99
 100         llist_for_each_entry(ms, &ms_list, entity) {
 101                 if (!strcmp(ms->name, name))
 102                         return ms;
 103         }
 104         vty_out(vty, "MS name '%s' does not exits.%s", name, VTY_NEWLINE);
 105
 106         return NULL;
 107 }
 108
 109 DEFUN(show_ms, show_ms_cmd, "show ms",
 110         SHOW_STR "Display available MS entities\n")
 111 {
 112         struct osmocom_ms *ms;
 113
 114         llist_for_each_entry(ms, &ms_list, entity) {
 115                 struct gsm_settings *set = &ms->settings;
 116
 117                 vty_out(vty, "MS NAME: %s%s", ms->name, VTY_NEWLINE);
 118                 vty_out(vty, " IMEI: %s%s", set->imei, VTY_NEWLINE);
 119                 vty_out(vty, " IMEISV: %s%s", set->imeisv, VTY_NEWLINE);
 120                 if (set->imei_random)
 121                         vty_out(vty, " IMEI generation: random (%d trailing "
 122                                 "digits)%s", set->imei_random, VTY_NEWLINE);
 123                 else
 124                         vty_out(vty, " IMEI generation: fixed%s", VTY_NEWLINE);
 125                 vty_out(vty, " network selection mode: %s%s",
 126                         (set->plmn_mode == PLMN_MODE_AUTO)
 127                                 ? "automatic" : "manual", VTY_NEWLINE);
 128         }
 129
 130         return CMD_SUCCESS;
 131 }
 132
 133 DEFUN(show_support, show_support_cmd, "show support [ms_name]",
 134         SHOW_STR "Display information about MS support\n"
 135         "Name of MS (see \"show ms\")")
 136 {
 137         struct osmocom_ms *ms;
 138
 139         if (argc) {
 140                 ms = get_ms(argv[0], vty);
 141                 if (!ms)
 142                         return CMD_WARNING;
 143                 gsm_support_dump(ms, print_vty, vty);
 144         } else {
 145                 llist_for_each_entry(ms, &ms_list, entity) {
 146                         gsm_support_dump(ms, print_vty, vty);
 147                         vty_out(vty, "%s", VTY_NEWLINE);
 148                 }
 149         }
 150
 151         return CMD_SUCCESS;
 152 }
 153
 154 static void gsm_states_dump(struct osmocom_ms *ms, struct vty *vty)
 155 {
 156         struct gsm_settings *set = &ms->settings;
 157         struct gsm_trans *trans;
 158
 159         vty_out(vty, "Current state of MS '%s'%s", ms->name, VTY_NEWLINE);
 160         if (set->plmn_mode == PLMN_MODE_AUTO)
 161                 vty_out(vty, " automatic network selection: %s%s",
 162                         plmn_a_state_names[ms->plmn.state], VTY_NEWLINE);
 163         else
 164                 vty_out(vty, " manual network selection: %s%s",
 165                         plmn_m_state_names[ms->plmn.state], VTY_NEWLINE);
 166         vty_out(vty, " cell selection: %s%s",
 167                 cs_state_names[ms->cellsel.state], VTY_NEWLINE);
 168         vty_out(vty, " radio ressource layer: %s%s",
 169                 gsm48_rr_state_names[ms->rrlayer.state], VTY_NEWLINE);
 170         vty_out(vty, " mobility management layer: %s",
 171                 gsm48_mm_state_names[ms->mmlayer.state]);
 172         if (ms->mmlayer.state == GSM48_MM_ST_MM_IDLE)
 173                 vty_out(vty, ", %s",
 174                         gsm48_mm_substate_names[ms->mmlayer.substate]);
 175         vty_out(vty, "%s", VTY_NEWLINE);
 176         llist_for_each_entry(trans, &ms->trans_list, entry) {
 177                 vty_out(vty, " call control: %s%s",
 178                         gsm48_cc_state_name(trans->cc.state), VTY_NEWLINE);
 179         }
 180 }
 181
 182 DEFUN(show_states, show_states_cmd, "show states [ms_name]",
 183         SHOW_STR "Display current states of given MS\n"
 184         "Name of MS (see \"show ms\")")
 185 {
 186         struct osmocom_ms *ms;
 187
 188         if (argc) {
 189                 ms = get_ms(argv[0], vty);
 190                 if (!ms)
 191                         return CMD_WARNING;
 192                 gsm_states_dump(ms, vty);
 193         } else {
 194                 llist_for_each_entry(ms, &ms_list, entity) {
 195                         gsm_states_dump(ms, vty);
 196                         vty_out(vty, "%s", VTY_NEWLINE);
 197                 }
 198         }
 199
 200         return CMD_SUCCESS;
 201 }
 202
 203 DEFUN(show_subscr, show_subscr_cmd, "show subscriber [ms_name]",
 204         SHOW_STR "Display information about subscriber\n"
 205         "Name of MS (see \"show ms\")")
 206 {
 207         struct osmocom_ms *ms;
 208
 209         if (argc) {
 210                 ms = get_ms(argv[0], vty);
 211                 if (!ms)
 212                         return CMD_WARNING;
 213                 gsm_subscr_dump(&ms->subscr, print_vty, vty);
 214         } else {
 215                 llist_for_each_entry(ms, &ms_list, entity) {
 216                         gsm_subscr_dump(&ms->subscr, print_vty, vty);
 217                         vty_out(vty, "%s", VTY_NEWLINE);
 218                 }
 219         }
 220
 221         return CMD_SUCCESS;
 222 }
 223
 224 DEFUN(show_cell, show_cell_cmd, "show cell MS_NAME",
 225         SHOW_STR "Display information about received cells\n"
 226         "Name of MS (see \"show ms\")")
 227 {
 228         struct osmocom_ms *ms;
 229
 230         ms = get_ms(argv[0], vty);
 231         if (!ms)
 232                 return CMD_WARNING;
 233
 234         gsm322_dump_cs_list(&ms->cellsel, GSM322_CS_FLAG_SYSINFO, print_vty,
 235                 vty);
 236
 237         return CMD_SUCCESS;
 238 }
 239
 240 DEFUN(show_cell_si, show_cell_si_cmd, "show cell MS_NAME <0-1023>",
 241         SHOW_STR "Display information about received cell\n"
 242         "Name of MS (see \"show ms\")\nRadio frequency number")
 243 {
 244         struct osmocom_ms *ms;
 245         int i;
 246         struct gsm48_sysinfo *s;
 247
 248         ms = get_ms(argv[0], vty);
 249         if (!ms)
 250                 return CMD_WARNING;
 251
 252         i = atoi(argv[1]);
 253         if (i < 0 || i > 1023) {
 254                 vty_out(vty, "Given ARFCN '%s' not in range (0..1023)%s",
 255                         argv[1], VTY_NEWLINE);
 256                 return CMD_WARNING;
 257         }
 258         s = ms->cellsel.list[i].sysinfo;
 259         if (!s) {
 260                 vty_out(vty, "Given ARFCN '%s' has no sysinfo available%s",
 261                         argv[1], VTY_NEWLINE);
 262                 return CMD_SUCCESS;
 263         }
 264
 265         gsm48_sysinfo_dump(s, i, print_vty, vty);
 266
 267         return CMD_SUCCESS;
 268 }
 269
 270 DEFUN(show_ba, show_ba_cmd, "show ba MS_NAME [mcc] [mnc]",
 271         SHOW_STR "Display information about band allocations\n"
 272         "Name of MS (see \"show ms\")\nMobile Country Code\n"
 273         "Mobile Network Code")
 274 {
 275         struct osmocom_ms *ms;
 276         uint16_t mcc = 0, mnc = 0;
 277
 278         ms = get_ms(argv[0], vty);
 279         if (!ms)
 280                 return CMD_WARNING;
 281
 282         if (argc >= 3) {
 283                 mcc = gsm_input_mcc((char *)argv[1]);
 284                 mnc = gsm_input_mnc((char *)argv[2]);
 285                 if (!mcc) {
 286                         vty_out(vty, "Given MCC invalid%s", VTY_NEWLINE);
 287                         return CMD_WARNING;
 288                 }
 289                 if (!mnc) {
 290                         vty_out(vty, "Given MNC invalid%s", VTY_NEWLINE);
 291                         return CMD_WARNING;
 292                 }
 293         }
 294
 295         gsm322_dump_ba_list(&ms->cellsel, mcc, mnc, print_vty, vty);
 296
 297         return CMD_SUCCESS;
 298 }
 299
 300 DEFUN(show_forb_plmn, show_forb_plmn_cmd, "show forbidden plmn MS_NAME",
 301         SHOW_STR "Display information about forbidden cells / networks\n"
 302         "Display forbidden PLMNs\nName of MS (see \"show ms\")")
 303 {
 304         struct osmocom_ms *ms;
 305
 306         ms = get_ms(argv[0], vty);
 307         if (!ms)
 308                 return CMD_WARNING;
 309
 310         gsm_subscr_dump_forbidden_plmn(ms, print_vty, vty);
 311
 312         return CMD_SUCCESS;
 313 }
 314
 315 DEFUN(show_forb_la, show_forb_la_cmd, "show forbidden location-area MS_NAME",
 316         SHOW_STR "Display information about forbidden cells / networks\n"
 317         "Display forbidden location areas\nName of MS (see \"show ms\")")
 318 {
 319         struct osmocom_ms *ms;
 320
 321         ms = get_ms(argv[0], vty);
 322         if (!ms)
 323                 return CMD_WARNING;
 324
 325         gsm322_dump_forbidden_la(ms, print_vty, vty);
 326
 327         return CMD_SUCCESS;
 328 }
 329
 330 DEFUN(monitor_network, monitor_network_cmd, "monitor network MS_NAME",
 331         "Monitor...\nMonitor network information\nName of MS (see \"show ms\")")
 332 {
 333         struct osmocom_ms *ms;
 334
 335         ms = get_ms(argv[0], vty);
 336         if (!ms)
 337                 return CMD_WARNING;
 338
 339         gsm48_rr_start_monitor(ms);
 340
 341         return CMD_SUCCESS;
 342 }
 343
 344 DEFUN(no_monitor_network, no_monitor_network_cmd, "no monitor network MS_NAME",
 345         NO_STR "Monitor...\nDeactivate monitor of network information\n"
 346         "Name of MS (see \"show ms\")")
 347 {
 348         struct osmocom_ms *ms;
 349
 350         ms = get_ms(argv[0], vty);
 351         if (!ms)
 352                 return CMD_WARNING;
 353
 354         gsm48_rr_stop_monitor(ms);
 355
 356         return CMD_SUCCESS;
 357 }
 358
 359 DEFUN(sim_test, sim_test_cmd, "sim testcard MS_NAME [mcc] [mnc]",
 360         "SIM actions\nInsert test card\nName of MS (see \"show ms\")\n"
 361         "Mobile Country Code of RPLMN\nMobile Network Code of RPLMN")
 362 {
 363         struct osmocom_ms *ms;
 364         uint16_t mcc = 0x001, mnc = 0x01f;
 365
 366         ms = get_ms(argv[0], vty);
 367         if (!ms)
 368                 return CMD_WARNING;
 369
 370         if (ms->subscr.sim_valid) {
 371                 vty_out(vty, "SIM already presend, remove first!%s",
 372                         VTY_NEWLINE);
 373                 return CMD_WARNING;
 374         }
 375
 376         if (argc >= 3) {
 377                 mcc = gsm_input_mcc((char *)argv[1]);
 378                 mnc = gsm_input_mnc((char *)argv[2]);
 379                 if (!mcc) {
 380                         vty_out(vty, "Given MCC invalid%s", VTY_NEWLINE);
 381                         return CMD_WARNING;
 382                 }
 383                 if (!mnc) {
 384                         vty_out(vty, "Given MNC invalid%s", VTY_NEWLINE);
 385                         return CMD_WARNING;
 386                 }
 387         }
 388
 389         gsm_subscr_testcard(ms, mcc, mnc);
 390
 391         return CMD_SUCCESS;
 392 }
 393
 394 DEFUN(sim_reader, sim_reader_cmd, "sim reader MS_NAME",
 395         "SIM actions\nSelect SIM from reader\nName of MS (see \"show ms\")")
 396 {
 397         struct osmocom_ms *ms;
 398
 399         ms = get_ms(argv[0], vty);
 400         if (!ms)
 401                 return CMD_WARNING;
 402
 403         if (ms->subscr.sim_valid) {
 404                 vty_out(vty, "SIM already presend, remove first!%s",
 405                         VTY_NEWLINE);
 406                 return CMD_WARNING;
 407         }
 408
 409         gsm_subscr_simcard(ms);
 410
 411         return CMD_SUCCESS;
 412 }
 413
 414 DEFUN(sim_remove, sim_remove_cmd, "sim remove MS_NAME",
 415         "SIM actions\nRemove SIM card\nName of MS (see \"show ms\")")
 416 {
 417         struct osmocom_ms *ms;
 418
 419         ms = get_ms(argv[0], vty);
 420         if (!ms)
 421                 return CMD_WARNING;
 422
 423         if (!ms->subscr.sim_valid) {
 424                 vty_out(vty, "No Sim inserted!%s", VTY_NEWLINE);
 425                 return CMD_WARNING;
 426         }
 427
 428         gsm_subscr_remove(ms);
 429
 430         return CMD_SUCCESS;
 431 }
 432
 433 DEFUN(sim_pin, sim_pin_cmd, "sim pin MS_NAME PIN",
 434         "SIM actions\nEnter PIN for SIM card\nName of MS (see \"show ms\")\n"
 435         "PIN number")
 436 {
 437         struct osmocom_ms *ms;
 438
 439         ms = get_ms(argv[0], vty);
 440         if (!ms)
 441                 return CMD_WARNING;
 442
 443         if (strlen(argv[1]) < 4 || strlen(argv[1]) > 8) {
 444                 vty_out(vty, "PIN must be in range 4..8!%s", VTY_NEWLINE);
 445                 return CMD_WARNING;
 446         }
 447
 448         if (!ms->subscr.sim_pin_required) {
 449                 vty_out(vty, "No PIN is required at this time!%s", VTY_NEWLINE);
 450                 return CMD_WARNING;
 451         }
 452
 453         gsm_subscr_sim_pin(ms, (char *)argv[1], "", 0);
 454
 455         return CMD_SUCCESS;
 456 }
 457
 458 DEFUN(sim_disable_pin, sim_disable_pin_cmd, "sim disable-pin MS_NAME PIN",
 459         "SIM actions\nDisable PIN of SIM card\nName of MS (see \"show ms\")\n"
 460         "PIN number")
 461 {
 462         struct osmocom_ms *ms;
 463
 464         ms = get_ms(argv[0], vty);
 465         if (!ms)
 466                 return CMD_WARNING;
 467
 468         if (strlen(argv[1]) < 4 || strlen(argv[1]) > 8) {
 469                 vty_out(vty, "PIN must be in range 4..8!%s", VTY_NEWLINE);
 470                 return CMD_WARNING;
 471         }
 472
 473         gsm_subscr_sim_pin(ms, (char *)argv[1], "", -1);
 474
 475         return CMD_SUCCESS;
 476 }
 477
 478 DEFUN(sim_enable_pin, sim_enable_pin_cmd, "sim enable-pin MS_NAME PIN",
 479         "SIM actions\nEnable PIN of SIM card\nName of MS (see \"show ms\")\n"
 480         "PIN number")
 481 {
 482         struct osmocom_ms *ms;
 483
 484         ms = get_ms(argv[0], vty);
 485         if (!ms)
 486                 return CMD_WARNING;
 487
 488         if (strlen(argv[1]) < 4 || strlen(argv[1]) > 8) {
 489                 vty_out(vty, "PIN must be in range 4..8!%s", VTY_NEWLINE);
 490                 return CMD_WARNING;
 491         }
 492
 493         gsm_subscr_sim_pin(ms, (char *)argv[1], "", 1);
 494
 495         return CMD_SUCCESS;
 496 }
 497
 498 DEFUN(sim_change_pin, sim_change_pin_cmd, "sim change-pin MS_NAME OLD NEW",
 499         "SIM actions\nChange PIN of SIM card\nName of MS (see \"show ms\")\n"
 500         "Old PIN number\nNew PIN number")
 501 {
 502         struct osmocom_ms *ms;
 503
 504         ms = get_ms(argv[0], vty);
 505         if (!ms)
 506                 return CMD_WARNING;
 507
 508         if (strlen(argv[1]) < 4 || strlen(argv[1]) > 8) {
 509                 vty_out(vty, "Old PIN must be in range 4..8!%s", VTY_NEWLINE);
 510                 return CMD_WARNING;
 511         }
 512         if (strlen(argv[2]) < 4 || strlen(argv[2]) > 8) {
 513                 vty_out(vty, "New PIN must be in range 4..8!%s", VTY_NEWLINE);
 514                 return CMD_WARNING;
 515         }
 516
 517         gsm_subscr_sim_pin(ms, (char *)argv[1], (char *)argv[2], 2);
 518
 519         return CMD_SUCCESS;
 520 }
 521
 522 DEFUN(sim_unblock_pin, sim_unblock_pin_cmd, "sim unblock-pin MS_NAME PUC NEW",
 523         "SIM actions\nChange PIN of SIM card\nName of MS (see \"show ms\")\n"
 524         "Personal Unblock Key\nNew PIN number")
 525 {
 526         struct osmocom_ms *ms;
 527
 528         ms = get_ms(argv[0], vty);
 529         if (!ms)
 530                 return CMD_WARNING;
 531
 532         if (strlen(argv[1]) != 8) {
 533                 vty_out(vty, "PUC must be 8 digits!%s", VTY_NEWLINE);
 534                 return CMD_WARNING;
 535         }
 536         if (strlen(argv[2]) < 4 || strlen(argv[2]) > 8) {
 537                 vty_out(vty, "PIN must be in range 4..8!%s", VTY_NEWLINE);
 538                 return CMD_WARNING;
 539         }
 540
 541         gsm_subscr_sim_pin(ms, (char *)argv[1], (char *)argv[2], 99);
 542
 543         return CMD_SUCCESS;
 544 }
 545
 546 DEFUN(sim_lai, sim_lai_cmd, "sim lai MS_NAME MCC MNC LAC",
 547         "SIM actions\nChange LAI of SIM card\nName of MS (see \"show ms\")\n"
 548         "Mobile Country Code\nMobile Network Code\nLocation Area Code "
 549         " (use 0000 to remove LAI)")
 550 {
 551         struct osmocom_ms *ms;
 552         uint16_t mcc = gsm_input_mcc((char *)argv[1]),
 553                  mnc = gsm_input_mnc((char *)argv[2]),
 554                  lac = strtoul(argv[3], NULL, 16);
 555
 556         ms = get_ms(argv[0], vty);
 557         if (!ms)
 558                 return CMD_WARNING;
 559
 560         if (!mcc) {
 561                 vty_out(vty, "Given MCC invalid%s", VTY_NEWLINE);
 562                 return CMD_WARNING;
 563         }
 564         if (!mnc) {
 565                 vty_out(vty, "Given MNC invalid%s", VTY_NEWLINE);
 566                 return CMD_WARNING;
 567         }
 568
 569         ms->subscr.mcc = mcc;
 570         ms->subscr.mnc = mnc;
 571         ms->subscr.lac = lac;
 572         ms->subscr.tmsi = 0xffffffff;
 573
 574         gsm_subscr_write_loci(ms);
 575
 576         return CMD_SUCCESS;
 577 }
 578
 579 DEFUN(network_select, network_select_cmd, "network select MS_NAME MCC MNC",
 580         "Select ...\nSelect Network\nName of MS (see \"show ms\")\n"
 581         "Mobile Country Code\nMobile Network Code")
 582 {
 583         struct osmocom_ms *ms;
 584         struct gsm322_plmn *plmn;
 585         struct msgb *nmsg;
 586         struct gsm322_msg *ngm;
 587         struct gsm322_plmn_list *temp;
 588         uint16_t mcc = gsm_input_mcc((char *)argv[1]),
 589                  mnc = gsm_input_mnc((char *)argv[2]);
 590         int found = 0;
 591
 592         ms = get_ms(argv[0], vty);
 593         if (!ms)
 594                 return CMD_WARNING;
 595         plmn = &ms->plmn;
 596
 597         if (!mcc) {
 598                 vty_out(vty, "Given MCC invalid%s", VTY_NEWLINE);
 599                 return CMD_WARNING;
 600         }
 601         if (!mnc) {
 602                 vty_out(vty, "Given MNC invalid%s", VTY_NEWLINE);
 603                 return CMD_WARNING;
 604         }
 605
 606         llist_for_each_entry(temp, &plmn->sorted_plmn, entry)
 607                 if (temp->mcc == mcc &&  temp->mnc == mnc)
 608                         found = 1;
 609         if (!found) {
 610                 vty_out(vty, "Network not in list!%s", VTY_NEWLINE);
 611                 return CMD_WARNING;
 612         }
 613
 614         nmsg = gsm322_msgb_alloc(GSM322_EVENT_CHOOSE_PLMN);
 615         if (!nmsg)
 616                 return CMD_WARNING;
 617         ngm = (struct gsm322_msg *) nmsg->data;
 618         ngm->mcc = mcc;
 619         ngm->mnc = mnc;
 620         gsm322_plmn_sendmsg(ms, nmsg);
 621
 622         return CMD_SUCCESS;
 623 }
 624
 625 DEFUN(call, call_cmd, "call MS_NAME (NUMBER|emergency|answer|hangup|hold)",
 626         "Make a call\nName of MS (see \"show ms\")\nPhone number to call "
 627         "(Use digits '0123456789*#abc', and '+' to dial international)\n"
 628         "Make an emergency call\nAnswer an incomming call\nHangup a call\n"
 629         "Hold current active call\n")
 630 {
 631         struct osmocom_ms *ms;
 632         int i;
 633
 634         ms = get_ms(argv[0], vty);
 635         if (!ms)
 636                 return CMD_WARNING;
 637
 638         switch (argv[1][0]) {
 639         case 'a':
 640                 mncc_answer(ms);
 641                 break;
 642         case 'h':
 643                 if (argv[1][1] == 'a')
 644                         mncc_hangup(ms);
 645                 else
 646                         mncc_hold(ms);
 647                 break;
 648         default:
 649                 for (i = 0; i < strlen(argv[1]); i++) {
 650                         /* allow international notation with + */
 651                         if (i == 0 && argv[1][i] == '+')
 652                                 continue;
 653                         if (!(argv[1][i] >= '0' && argv[1][i] <= '9')
 654                          && argv[1][i] != '*'
 655                          && argv[1][i] != '#'
 656                          && !(argv[1][i] >= 'a' && argv[1][i] <= 'c')) {
 657                                 vty_out(vty, "Invalid digit '%c'%s", argv[1][i],
 658                                         VTY_NEWLINE);
 659                                 return CMD_WARNING;
 660                         }
 661                 }
 662                 mncc_call(ms, (char *)argv[1]);
 663         }
 664
 665         return CMD_SUCCESS;
 666 }
 667
 668 DEFUN(call_retr, call_retr_cmd, "call MS_NAME retrieve [number]",
 669         "Make a call\nName of MS (see \"show ms\")\n"
 670         "Retrieve call on hold\nNumber of call to retrieve")
 671 {
 672         struct osmocom_ms *ms;
 673
 674         ms = get_ms(argv[0], vty);
 675         if (!ms)
 676                 return CMD_WARNING;
 677
 678         mncc_retrieve(ms, (argc > 1) ? atoi(argv[1]) : 0);
 679
 680         return CMD_SUCCESS;
 681 }
 682
 683 DEFUN(network_show, network_show_cmd, "network show MS_NAME",
 684         "Network ...\nShow results of network search (again)\n"
 685         "Name of MS (see \"show ms\")")
 686 {
 687         struct osmocom_ms *ms;
 688         struct gsm_settings *set;
 689         struct gsm322_plmn *plmn;
 690         struct gsm322_plmn_list *temp;
 691
 692         ms = get_ms(argv[0], vty);
 693         if (!ms)
 694                 return CMD_WARNING;
 695         set = &ms->settings;
 696         plmn = &ms->plmn;
 697
 698         if (set->plmn_mode != PLMN_MODE_AUTO
 699          && plmn->state != GSM322_M3_NOT_ON_PLMN) {
 700                 vty_out(vty, "Start network search first!%s", VTY_NEWLINE);
 701                 return CMD_WARNING;
 702         }
 703
 704         llist_for_each_entry(temp, &plmn->sorted_plmn, entry)
 705                 vty_out(vty, " Network %s, %s (%s, %s)%s",
 706                         gsm_print_mcc(temp->mcc), gsm_print_mnc(temp->mnc),
 707                         gsm_get_mcc(temp->mcc),
 708                         gsm_get_mnc(temp->mcc, temp->mnc), VTY_NEWLINE);
 709
 710         return CMD_SUCCESS;
 711 }
 712
 713 DEFUN(network_search, network_search_cmd, "network search MS_NAME",
 714         "Network ...\nTrigger network search\nName of MS (see \"show ms\")")
 715 {
 716         struct osmocom_ms *ms;
 717         struct msgb *nmsg;
 718
 719         ms = get_ms(argv[0], vty);
 720         if (!ms)
 721                 return CMD_WARNING;
 722
 723         nmsg = gsm322_msgb_alloc(GSM322_EVENT_USER_RESEL);
 724         if (!nmsg)
 725                 return CMD_WARNING;
 726         gsm322_plmn_sendmsg(ms, nmsg);
 727
 728         return CMD_SUCCESS;
 729 }
 730
 731 DEFUN(cfg_gps_enable, cfg_gps_enable_cmd, "gps enable",
 732         "GPS receiver")
 733 {
 734         if (gps_open()) {
 735                 gps.enable = 1;
 736                 vty_out(vty, "Failed to open GPS device!%s", VTY_NEWLINE);
 737                 return CMD_WARNING;
 738         }
 739         gps.enable = 1;
 740
 741         return CMD_SUCCESS;
 742 }
 743
 744 DEFUN(cfg_no_gps_enable, cfg_no_gps_enable_cmd, "no gps enable",
 745         NO_STR "Disable GPS receiver")
 746 {
 747         if (gps.enable)
 748                 gps_close();
 749         gps.enable = 0;
 750
 751         return CMD_SUCCESS;
 752 }
 753
 754 DEFUN(cfg_gps_device, cfg_gps_device_cmd, "gps device DEVICE",
 755         "GPS receiver\nSelect serial device\n"
 756         "Full path of serial device including /dev/")
 757 {
 758         strncpy(gps.device, argv[0], sizeof(gps.device));
 759         gps.device[sizeof(gps.device) - 1] = '\0';
 760         if (gps.enable) {
 761                 gps_close();
 762                 if (gps_open()) {
 763                         vty_out(vty, "Failed to open GPS device!%s",
 764                                 VTY_NEWLINE);
 765                         return CMD_WARNING;
 766                 }
 767         }
 768
 769         return CMD_SUCCESS;
 770 }
 771
 772 DEFUN(cfg_gps_baud, cfg_gps_baud_cmd, "gps baudrate "
 773         "(default|4800|""9600|19200|38400|57600|115200)",
 774         "GPS receiver\nSelect baud rate\nDefault, don't modify\n\n\n\n\n\n")
 775 {
 776         if (argv[0][0] == 'd')
 777                 gps.baud = 0;
 778         else
 779                 gps.baud = atoi(argv[0]);
 780         if (gps.enable) {
 781                 gps_close();
 782                 if (gps_open()) {
 783                         gps.enable = 0;
 784                         vty_out(vty, "Failed to open GPS device!%s",
 785                                 VTY_NEWLINE);
 786                         return CMD_WARNING;
 787                 }
 788         }
 789
 790         return CMD_SUCCESS;
 791 }
 792
 793 /* per MS config */
 794 DEFUN(cfg_ms, cfg_ms_cmd, "ms MS_NAME",
 795         "Select a mobile station to configure\nName of MS (see \"show ms\")")
 796 {
 797         struct osmocom_ms *ms;
 798
 799         ms = get_ms(argv[0], vty);
 800         if (!ms)
 801                 return CMD_WARNING;
 802
 803         vty->index = ms;
 804         vty->node = MS_NODE;
 805
 806         return CMD_SUCCESS;
 807 }
 808
 809 #define SUP_WRITE(item, cmd) \
 810         if (sup->item) \
 811                 vty_out(vty, "  %s%s%s", (set->item) ? "" : "no ", cmd, \
 812                         VTY_NEWLINE);
 813
 814 static void config_write_ms_single(struct vty *vty, struct osmocom_ms *ms)
 815 {
 816         struct gsm_settings *set = &ms->settings;
 817         struct gsm_support *sup = &ms->support;
 818
 819         vty_out(vty, "ms %s%s", ms->name, VTY_NEWLINE);
 820         switch(set->sim_type) {
 821                 case GSM_SIM_TYPE_NONE:
 822                 vty_out(vty, " sim none%s", VTY_NEWLINE);
 823                 break;
 824                 case GSM_SIM_TYPE_READER:
 825                 vty_out(vty, " sim reader%s", VTY_NEWLINE);
 826                 break;
 827                 case GSM_SIM_TYPE_TEST:
 828                 vty_out(vty, " sim test%s", VTY_NEWLINE);
 829                 break;
 830         }
 831         vty_out(vty, " network-selection-mode %s%s", (set->plmn_mode
 832                         == PLMN_MODE_AUTO) ? "auto" : "manual", VTY_NEWLINE);
 833         vty_out(vty, " imei %s %s%s", set->imei,
 834                 set->imeisv + strlen(set->imei), VTY_NEWLINE);
 835         if (set->imei_random)
 836                 vty_out(vty, " imei-random %d%s", set->imei_random,
 837                         VTY_NEWLINE);
 838         else
 839                 vty_out(vty, " imei-fixed%s", VTY_NEWLINE);
 840         if (set->emergency_imsi[0])
 841                 vty_out(vty, " emergency-imsi %s%s", set->emergency_imsi,
 842                         VTY_NEWLINE);
 843         else
 844                 vty_out(vty, " no emergency-imsi%s", VTY_NEWLINE);
 845         vty_out(vty, " %scall-waiting%s", (set->cw) ? "" : "no ", VTY_NEWLINE);
 846         vty_out(vty, " %sclip%s", (set->clip) ? "" : "no ", VTY_NEWLINE);
 847         vty_out(vty, " %sclir%s", (set->clir) ? "" : "no ", VTY_NEWLINE);
 848         if (set->alter_tx_power)
 849                 if (set->alter_tx_power_value)
 850                         vty_out(vty, " tx-power %d%s",
 851                                 set->alter_tx_power_value, VTY_NEWLINE);
 852                 else
 853                         vty_out(vty, " tx-power full%s", VTY_NEWLINE);
 854         else
 855                 vty_out(vty, " tx-power auto%s", VTY_NEWLINE);
 856         if (set->alter_delay)
 857                 vty_out(vty, " simulated-delay %d%s", set->alter_delay,
 858                         VTY_NEWLINE);
 859         else
 860                 vty_out(vty, " no simulated-delay%s", VTY_NEWLINE);
 861         if (set->stick)
 862                 vty_out(vty, " stick %d%s", set->stick_arfcn,
 863                         VTY_NEWLINE);
 864         else
 865                 vty_out(vty, " no stick%s", VTY_NEWLINE);
 866         if (set->no_lupd)
 867                 vty_out(vty, " no location-updating%s", VTY_NEWLINE);
 868         else
 869                 vty_out(vty, " location-updating%s", VTY_NEWLINE);
 870         if (set->full_v1 || set->full_v2 || set->full_v3) {
 871                 /* mandatory anyway */
 872                 vty_out(vty, " codec full-speed%s%s",
 873                         (!set->half_prefer) ? " prefer" : "",
 874                         VTY_NEWLINE);
 875         }
 876         if (set->half_v1 || set->half_v3) {
 877                 if (set->half)
 878                         vty_out(vty, " codec half-speed%s%s",
 879                                 (set->half_prefer) ? " prefer" : "",
 880                                 VTY_NEWLINE);
 881                 else
 882                         vty_out(vty, " no codec half-speed%s", VTY_NEWLINE);
 883         }
 884         vty_out(vty, " support%s", VTY_NEWLINE);
 885         SUP_WRITE(sms_ptp, "sms");
 886         SUP_WRITE(a5_1, "a5/1");
 887         SUP_WRITE(a5_2, "a5/2");
 888         SUP_WRITE(a5_3, "a5/3");
 889         SUP_WRITE(a5_4, "a5/4");
 890         SUP_WRITE(a5_5, "a5/5");
 891         SUP_WRITE(a5_6, "a5/6");
 892         SUP_WRITE(a5_7, "a5/7");
 893         SUP_WRITE(p_gsm, "p-gsm");
 894         SUP_WRITE(e_gsm, "e-gsm");
 895         SUP_WRITE(r_gsm, "r-gsm");
 896         SUP_WRITE(dcs, "dcs");
 897         vty_out(vty, "  class-900 %d%s", set->class_900, VTY_NEWLINE);
 898         vty_out(vty, "  class-dcs %d%s", set->class_dcs, VTY_NEWLINE);
 899         switch (set->ch_cap) {
 900         case GSM_CAP_SDCCH:
 901                 vty_out(vty, "  channel-capability sdcch%s", VTY_NEWLINE);
 902                 break;
 903         case GSM_CAP_SDCCH_TCHF:
 904                 vty_out(vty, "  channel-capability sdcch+tchf%s", VTY_NEWLINE);
 905                 break;
 906         case GSM_CAP_SDCCH_TCHF_TCHH:
 907                 vty_out(vty, "  channel-capability sdcch+tchf+tchh%s",
 908                         VTY_NEWLINE);
 909                 break;
 910         }
 911         SUP_WRITE(full_v1, "full-speech-v1");
 912         SUP_WRITE(full_v2, "full-speech-v2");
 913         SUP_WRITE(full_v3, "full-speech-v3");
 914         SUP_WRITE(half_v1, "half-speech-v1");
 915         SUP_WRITE(half_v3, "half-speech-v3");
 916         vty_out(vty, "  min-rxlev %d%s", set->min_rxlev_db, VTY_NEWLINE);
 917         vty_out(vty, " exit%s", VTY_NEWLINE);
 918         vty_out(vty, " test-sim%s", VTY_NEWLINE);
 919         vty_out(vty, "  imsi %s%s", set->test_imsi, VTY_NEWLINE);
 920         switch (set->test_ki_type) {
 921         case GSM_SIM_KEY_XOR:
 922                 vty_out(vty, "  ki xor %s%s", hexdump(set->test_ki, 12),
 923                         VTY_NEWLINE);
 924                 break;
 925         case GSM_SIM_KEY_COMP128:
 926                 vty_out(vty, "  ki comp128 %s%s", hexdump(set->test_ki, 16),
 927                         VTY_NEWLINE);
 928                 break;
 929         }
 930         vty_out(vty, "  %sbarred-access%s", (set->test_barr) ? "" : "no ",
 931                 VTY_NEWLINE);
 932         if (set->test_rplmn_valid)
 933                 vty_out(vty, "  rplmn %s %s%s",
 934                         gsm_print_mcc(set->test_rplmn_mcc),
 935                         gsm_print_mnc(set->test_rplmn_mnc),
 936                         VTY_NEWLINE);
 937         else
 938                 vty_out(vty, "  no rplmn%s", VTY_NEWLINE);
 939         vty_out(vty, "  hplmn-search %s%s", (set->test_always) ? "everywhere"
 940                         : "foreign-country", VTY_NEWLINE);
 941         vty_out(vty, " exit%s", VTY_NEWLINE);
 942         vty_out(vty, "exit%s", VTY_NEWLINE);
 943         vty_out(vty, "!%s", VTY_NEWLINE);
 944 }
 945
 946 static int config_write_ms(struct vty *vty)
 947 {
 948         struct osmocom_ms *ms;
 949
 950         vty_out(vty, "gps device %s%s", gps.device, VTY_NEWLINE);
 951         if (gps.baud)
 952                 vty_out(vty, "gps baudrate %d%s", gps.baud, VTY_NEWLINE);
 953         else
 954                 vty_out(vty, "gps baudrate default%s", VTY_NEWLINE);
 955         vty_out(vty, "%sgps enable%s", (gps.enable) ? "" : "no ", VTY_NEWLINE);
 956         vty_out(vty, "!%s", VTY_NEWLINE);
 957
 958         llist_for_each_entry(ms, &ms_list, entity)
 959                 config_write_ms_single(vty, ms);
 960
 961         return CMD_SUCCESS;
 962 }
 963
 964 DEFUN(cfg_ms_sim, cfg_ms_sim_cmd, "sim (none|reader|test)",
 965         "Set SIM card type when powering on\nNo SIM interted\n"
 966         "Use SIM from reader\nTest SIM inserted")
 967 {
 968         struct osmocom_ms *ms = vty->index;
 969         struct gsm_settings *set = &ms->settings;
 970
 971         switch (argv[0][0]) {
 972         case 'n':
 973                 set->sim_type = GSM_SIM_TYPE_NONE;
 974                 break;
 975         case 'r':
 976                 set->sim_type = GSM_SIM_TYPE_READER;
 977                 break;
 978         case 't':
 979                 set->sim_type = GSM_SIM_TYPE_TEST;
 980                 break;
 981         default:
 982                 vty_out(vty, "unknown SIM type%s", VTY_NEWLINE);
 983                 return CMD_WARNING;
 984         }
 985
 986         vty_restart(vty);
 987         return CMD_SUCCESS;
 988 }
 989
 990 DEFUN(cfg_ms_mode, cfg_ms_mode_cmd, "network-selection-mode (auto|manual)",
 991         "Set network selection mode\nAutomatic network selection\n"
 992         "Manual network selection")
 993 {
 994         struct osmocom_ms *ms = vty->index;
 995         struct gsm_settings *set = &ms->settings;
 996         struct msgb *nmsg;
 997
 998         if (!ms->plmn.state) {
 999                 if (argv[0][0] == 'a')
1000                         set->plmn_mode = PLMN_MODE_AUTO;
1001                 else
1002                         set->plmn_mode = PLMN_MODE_MANUAL;
1003
1004                 return CMD_SUCCESS;
1005         }
1006         if (argv[0][0] == 'a')
1007                 nmsg = gsm322_msgb_alloc(GSM322_EVENT_SEL_AUTO);
1008         else
1009                 nmsg = gsm322_msgb_alloc(GSM322_EVENT_SEL_MANUAL);
1010         if (!nmsg)
1011                 return CMD_WARNING;
1012         gsm322_plmn_sendmsg(ms, nmsg);
1013
1014         return CMD_SUCCESS;
1015 }
1016
1017 DEFUN(cfg_ms_imei, cfg_ms_imei_cmd, "imei IMEI [SV]",
1018         "Set IMEI (enter without control digit)\n15 Digits IMEI\n"
1019         "Software version digit")
1020 {
1021         struct osmocom_ms *ms = vty->index;
1022         struct gsm_settings *set = &ms->settings;
1023         char *error, *sv = "0";
1024
1025         if (argc >= 2)
1026                 sv = (char *)argv[1];
1027
1028         error = gsm_check_imei(argv[0], sv);
1029         if (error) {
1030                 vty_out(vty, "%s%s", error, VTY_NEWLINE);
1031                 return CMD_WARNING;
1032         }
1033
1034         strcpy(set->imei, argv[0]);
1035         strcpy(set->imeisv, argv[0]);
1036         strcpy(set->imeisv + 15, sv);
1037
1038         return CMD_SUCCESS;
1039 }
1040
1041 DEFUN(cfg_ms_imei_fixed, cfg_ms_imei_fixed_cmd, "imei-fixed",
1042         "Use fixed IMEI on every power on")
1043 {
1044         struct osmocom_ms *ms = vty->index;
1045         struct gsm_settings *set = &ms->settings;
1046
1047         set->imei_random = 0;
1048
1049         vty_restart(vty);
1050         return CMD_SUCCESS;
1051 }
1052
1053 DEFUN(cfg_ms_imei_random, cfg_ms_imei_random_cmd, "imei-random <0-15>",
1054         "Use random IMEI on every power on\n"
1055         "Number of trailing digits to randomize")
1056 {
1057         struct osmocom_ms *ms = vty->index;
1058         struct gsm_settings *set = &ms->settings;
1059
1060         set->imei_random = atoi(argv[0]);
1061
1062         vty_restart(vty);
1063         return CMD_SUCCESS;
1064 }
1065
1066 DEFUN(cfg_ms_emerg_imsi, cfg_ms_emerg_imsi_cmd, "emergency-imsi IMSI",
1067         "Use special IMSI for emergency calls\n15 digits IMSI")
1068 {
1069         struct osmocom_ms *ms = vty->index;
1070         struct gsm_settings *set = &ms->settings;
1071         char *error;
1072
1073         error = gsm_check_imsi(argv[0]);
1074         if (error) {
1075                 vty_out(vty, "%s%s", error, VTY_NEWLINE);
1076                 return CMD_WARNING;
1077         }
1078         strcpy(set->emergency_imsi, argv[0]);
1079
1080         return CMD_SUCCESS;
1081 }
1082
1083 DEFUN(cfg_ms_no_emerg_imsi, cfg_ms_no_emerg_imsi_cmd, "no emergency-imsi",
1084         NO_STR "Use IMSI of SIM or IMEI for emergency calls")
1085 {
1086         struct osmocom_ms *ms = vty->index;
1087         struct gsm_settings *set = &ms->settings;
1088
1089         set->emergency_imsi[0] = '\0';
1090
1091         return CMD_SUCCESS;
1092 }
1093
1094 DEFUN(cfg_no_cw, cfg_ms_no_cw_cmd, "no call-waiting",
1095         NO_STR "Disallow waiting calls")
1096 {
1097         struct osmocom_ms *ms = vty->index;
1098         struct gsm_settings *set = &ms->settings;
1099
1100         set->cw = 0;
1101
1102         return CMD_SUCCESS;
1103 }
1104
1105 DEFUN(cfg_cw, cfg_ms_cw_cmd, "call-waiting",
1106         "Allow waiting calls")
1107 {
1108         struct osmocom_ms *ms = vty->index;
1109         struct gsm_settings *set = &ms->settings;
1110
1111         set->cw = 1;
1112
1113         return CMD_SUCCESS;
1114 }
1115
1116 DEFUN(cfg_clip, cfg_ms_clip_cmd, "clip",
1117         "Force caller ID presentation")
1118 {
1119         struct osmocom_ms *ms = vty->index;
1120         struct gsm_settings *set = &ms->settings;
1121
1122         set->clip = 1;
1123         set->clir = 0;
1124
1125         return CMD_SUCCESS;
1126 }
1127
1128 DEFUN(cfg_clir, cfg_ms_clir_cmd, "clir",
1129         "Force caller ID restriction")
1130 {
1131         struct osmocom_ms *ms = vty->index;
1132         struct gsm_settings *set = &ms->settings;
1133
1134         set->clip = 0;
1135         set->clir = 1;
1136
1137         return CMD_SUCCESS;
1138 }
1139
1140 DEFUN(cfg_no_clip, cfg_ms_no_clip_cmd, "no clip",
1141         NO_STR "Disable forcing of caller ID presentation")
1142 {
1143         struct osmocom_ms *ms = vty->index;
1144         struct gsm_settings *set = &ms->settings;
1145
1146         set->clip = 0;
1147
1148         return CMD_SUCCESS;
1149 }
1150
1151 DEFUN(cfg_no_clir, cfg_ms_no_clir_cmd, "no clir",
1152         NO_STR "Disable forcing of caller ID restriction")
1153 {
1154         struct osmocom_ms *ms = vty->index;
1155         struct gsm_settings *set = &ms->settings;
1156
1157         set->clir = 0;
1158
1159         return CMD_SUCCESS;
1160 }
1161
1162 DEFUN(cfg_ms_tx_power, cfg_ms_tx_power_cmd, "tx-power (auto|full)",
1163         "Set the way to choose transmit power\nControlled by BTS\n"
1164         "Always full power\nFixed GSM power value if supported")
1165 {
1166         struct osmocom_ms *ms = vty->index;
1167         struct gsm_settings *set = &ms->settings;
1168
1169         switch (argv[0][0]) {
1170         case 'a':
1171                 set->alter_tx_power = 0;
1172                 break;
1173         case 'f':
1174                 set->alter_tx_power = 1;
1175                 set->alter_tx_power_value = 0;
1176                 break;
1177         }
1178
1179         return CMD_SUCCESS;
1180 }
1181
1182 DEFUN(cfg_ms_tx_power_val, cfg_ms_tx_power_val_cmd, "tx-power <0-31>",
1183         "Set the way to choose transmit power\n"
1184         "Fixed GSM power value if supported")
1185 {
1186         struct osmocom_ms *ms = vty->index;
1187         struct gsm_settings *set = &ms->settings;
1188
1189         set->alter_tx_power = 1;
1190         set->alter_tx_power_value = atoi(argv[0]);
1191
1192         return CMD_SUCCESS;
1193 }
1194
1195 DEFUN(cfg_ms_sim_delay, cfg_ms_sim_delay_cmd, "simulated-delay <-128-127>",
1196         "Simulate a lower or higher distance from the BTS\n"
1197         "Delay in half bits (distance in 553.85 meter steps)")
1198 {
1199         struct osmocom_ms *ms = vty->index;
1200         struct gsm_settings *set = &ms->settings;
1201
1202         set->alter_delay = atoi(argv[0]);
1203         gsm48_rr_alter_delay(ms);
1204
1205         return CMD_SUCCESS;
1206 }
1207
1208 DEFUN(cfg_ms_no_sim_delay, cfg_ms_no_sim_delay_cmd, "no simulated-delay",
1209         NO_STR "Do not simulate a lower or higher distance from the BTS")
1210 {
1211         struct osmocom_ms *ms = vty->index;
1212         struct gsm_settings *set = &ms->settings;
1213
1214         set->alter_delay = 0;
1215         gsm48_rr_alter_delay(ms);
1216
1217         return CMD_SUCCESS;
1218 }
1219
1220 DEFUN(cfg_ms_stick, cfg_ms_stick_cmd, "stick <0-1023>",
1221         "Stick to the given cell\nARFCN of the cell to stick to")
1222 {
1223         struct osmocom_ms *ms = vty->index;
1224         struct gsm_settings *set = &ms->settings;
1225
1226         set->stick = 1;
1227         set->stick_arfcn = atoi(argv[0]);
1228
1229         return CMD_SUCCESS;
1230 }
1231
1232 DEFUN(cfg_ms_no_stick, cfg_ms_no_stick_cmd, "no stick",
1233         NO_STR "Do not stick to any cell")
1234 {
1235         struct osmocom_ms *ms = vty->index;
1236         struct gsm_settings *set = &ms->settings;
1237
1238         set->stick = 0;
1239
1240         return CMD_SUCCESS;
1241 }
1242
1243 DEFUN(cfg_ms_lupd, cfg_ms_lupd_cmd, "location-updating",
1244         "Allow location updating")
1245 {
1246         struct osmocom_ms *ms = vty->index;
1247         struct gsm_settings *set = &ms->settings;
1248
1249         set->no_lupd = 0;
1250
1251         return CMD_SUCCESS;
1252 }
1253
1254 DEFUN(cfg_ms_no_lupd, cfg_ms_no_lupd_cmd, "no location-updating",
1255         NO_STR "Do not allow location updating")
1256 {
1257         struct osmocom_ms *ms = vty->index;
1258         struct gsm_settings *set = &ms->settings;
1259
1260         set->no_lupd = 1;
1261
1262         return CMD_SUCCESS;
1263 }
1264
1265 DEFUN(cfg_codec_full, cfg_ms_codec_full_cmd, "codec full-speed",
1266         "Enable codec\nFull speed speech codec")
1267 {
1268         struct osmocom_ms *ms = vty->index;
1269         struct gsm_settings *set = &ms->settings;
1270
1271         if (!set->full_v1 && !set->full_v2 && !set->full_v3) {
1272                 vty_out(vty, "Full-rate codec not supported%s", VTY_NEWLINE);
1273                 return CMD_WARNING;
1274         }
1275
1276         return CMD_SUCCESS;
1277 }
1278
1279 DEFUN(cfg_codec_full_pref, cfg_ms_codec_full_pref_cmd, "codec full-speed "
1280         "prefer",
1281         "Enable codec\nFull speed speech codec\nPrefer this codec")
1282 {
1283         struct osmocom_ms *ms = vty->index;
1284         struct gsm_settings *set = &ms->settings;
1285
1286         if (!set->full_v1 && !set->full_v2 && !set->full_v3) {
1287                 vty_out(vty, "Full-rate codec not supported%s", VTY_NEWLINE);
1288                 return CMD_WARNING;
1289         }
1290
1291         set->half_prefer = 0;
1292
1293         return CMD_SUCCESS;
1294 }
1295
1296 DEFUN(cfg_codec_half, cfg_ms_codec_half_cmd, "codec half-speed",
1297         "Enable codec\nHalf speed speech codec")
1298 {
1299         struct osmocom_ms *ms = vty->index;
1300         struct gsm_settings *set = &ms->settings;
1301
1302         if (!set->half_v1 && !set->half_v3) {
1303                 vty_out(vty, "Half-rate codec not supported%s", VTY_NEWLINE);
1304                 return CMD_WARNING;
1305         }
1306
1307         set->half = 1;
1308
1309         return CMD_SUCCESS;
1310 }
1311
1312 DEFUN(cfg_codec_half_pref, cfg_ms_codec_half_pref_cmd, "codec half-speed "
1313         "prefer",
1314         "Enable codec\nHalf speed speech codec\nPrefer this codec")
1315 {
1316         struct osmocom_ms *ms = vty->index;
1317         struct gsm_settings *set = &ms->settings;
1318
1319         if (!set->half_v1 && !set->half_v3) {
1320                 vty_out(vty, "Half-rate codec not supported%s", VTY_NEWLINE);
1321                 return CMD_WARNING;
1322         }
1323
1324         set->half = 1;
1325         set->half_prefer = 1;
1326
1327         return CMD_SUCCESS;
1328 }
1329
1330 DEFUN(cfg_no_codec_half, cfg_ms_no_codec_half_cmd, "no codec half-speed",
1331         NO_STR "Disable codec\nHalf speed speech codec")
1332 {
1333         struct osmocom_ms *ms = vty->index;
1334         struct gsm_settings *set = &ms->settings;
1335
1336         if (!set->half_v1 && !set->half_v3) {
1337                 vty_out(vty, "Half-rate codec not supported%s", VTY_NEWLINE);
1338                 return CMD_WARNING;
1339         }
1340
1341         set->half = 0;
1342         set->half_prefer = 0;
1343
1344         return CMD_SUCCESS;
1345 }
1346
1347 static int config_write_dummy(struct vty *vty)
1348 {
1349         return CMD_SUCCESS;
1350 }
1351
1352 /* per support config */
1353 DEFUN(cfg_ms_support, cfg_ms_support_cmd, "support",
1354         "Define supported features")
1355 {
1356         vty->node = SUPPORT_NODE;
1357
1358         return CMD_SUCCESS;
1359 }
1360
1361 #define SUP_EN(cfg, cfg_cmd, item, cmd, desc, restart) \
1362 DEFUN(cfg, cfg_cmd, cmd, "Enable " desc "support") \
1363 { \
1364         struct osmocom_ms *ms = vty->index; \
1365         struct gsm_settings *set = &ms->settings; \
1366         struct gsm_support *sup = &ms->support; \
1367         if (!sup->item) { \
1368                 vty_out(vty, desc " not supported%s", VTY_NEWLINE); \
1369                 if (vty_reading) \
1370                         return CMD_SUCCESS; \
1371                 return CMD_WARNING; \
1372         } \
1373         if (restart) \
1374                 vty_restart(vty); \
1375         set->item = 1; \
1376         return CMD_SUCCESS; \
1377 }
1378
1379 #define SUP_DI(cfg, cfg_cmd, item, cmd, desc, restart) \
1380 DEFUN(cfg, cfg_cmd, "no " cmd, NO_STR "Disable " desc " support") \
1381 { \
1382         struct osmocom_ms *ms = vty->index; \
1383         struct gsm_settings *set = &ms->settings; \
1384         struct gsm_support *sup = &ms->support; \
1385         if (!sup->item) { \
1386                 vty_out(vty, desc " not supported%s", VTY_NEWLINE); \
1387                 if (vty_reading) \
1388                         return CMD_SUCCESS; \
1389                 return CMD_WARNING; \
1390         } \
1391         if (restart) \
1392                 vty_restart(vty); \
1393         set->item = 0; \
1394         return CMD_SUCCESS; \
1395 }
1396
1397 SUP_EN(cfg_ms_sup_sms, cfg_ms_sup_sms_cmd, sms_ptp, "sms", "SMS", 0);
1398 SUP_DI(cfg_ms_sup_no_sms, cfg_ms_sup_no_sms_cmd, sms_ptp, "sms", "SMS", 0);
1399 SUP_EN(cfg_ms_sup_a5_1, cfg_ms_sup_a5_1_cmd, a5_1, "a5/1", "A5/1", 0);
1400 SUP_DI(cfg_ms_sup_no_a5_1, cfg_ms_sup_no_a5_1_cmd, a5_1, "a5/1", "A5/1", 0);
1401 SUP_EN(cfg_ms_sup_a5_2, cfg_ms_sup_a5_2_cmd, a5_2, "a5/2", "A5/2", 0);
1402 SUP_DI(cfg_ms_sup_no_a5_2, cfg_ms_sup_no_a5_2_cmd, a5_2, "a5/2", "A5/2", 0);
1403 SUP_EN(cfg_ms_sup_a5_3, cfg_ms_sup_a5_3_cmd, a5_3, "a5/3", "A5/3", 0);
1404 SUP_DI(cfg_ms_sup_no_a5_3, cfg_ms_sup_no_a5_3_cmd, a5_3, "a5/3", "A5/3", 0);
1405 SUP_EN(cfg_ms_sup_a5_4, cfg_ms_sup_a5_4_cmd, a5_4, "a5/4", "A5/4", 0);
1406 SUP_DI(cfg_ms_sup_no_a5_4, cfg_ms_sup_no_a5_4_cmd, a5_4, "a5/4", "A5/4", 0);
1407 SUP_EN(cfg_ms_sup_a5_5, cfg_ms_sup_a5_5_cmd, a5_5, "a5/5", "A5/5", 0);
1408 SUP_DI(cfg_ms_sup_no_a5_5, cfg_ms_sup_no_a5_5_cmd, a5_5, "a5/5", "A5/5", 0);
1409 SUP_EN(cfg_ms_sup_a5_6, cfg_ms_sup_a5_6_cmd, a5_6, "a5/6", "A5/6", 0);
1410 SUP_DI(cfg_ms_sup_no_a5_6, cfg_ms_sup_no_a5_6_cmd, a5_6, "a5/6", "A5/6", 0);
1411 SUP_EN(cfg_ms_sup_a5_7, cfg_ms_sup_a5_7_cmd, a5_7, "a5/7", "A5/7", 0);
1412 SUP_DI(cfg_ms_sup_no_a5_7, cfg_ms_sup_no_a5_7_cmd, a5_7, "a5/7", "A5/7", 1);
1413 SUP_EN(cfg_ms_sup_p_gsm, cfg_ms_sup_p_gsm_cmd, p_gsm, "p-gsm", "P-GSM (900)",
1414         1);
1415 SUP_DI(cfg_ms_sup_no_p_gsm, cfg_ms_sup_no_p_gsm_cmd, p_gsm, "p-gsm",
1416         "P-GSM (900)", 1);
1417 SUP_EN(cfg_ms_sup_e_gsm, cfg_ms_sup_e_gsm_cmd, e_gsm, "e-gsm", "E-GSM (850)",
1418         1);
1419 SUP_DI(cfg_ms_sup_no_e_gsm, cfg_ms_sup_no_e_gsm_cmd, e_gsm, "e-gsm",
1420         "E-GSM (850)", 1);
1421 SUP_EN(cfg_ms_sup_r_gsm, cfg_ms_sup_r_gsm_cmd, r_gsm, "r-gsm", "R-GSM (850)",
1422         1);
1423 SUP_DI(cfg_ms_sup_no_r_gsm, cfg_ms_sup_no_r_gsm_cmd, r_gsm, "r-gsm",
1424         "R-GSM (850)", 1);
1425 SUP_EN(cfg_ms_sup_dcs, cfg_ms_sup_dcs_cmd, dcs, "dcs", "DCS (1800)", 0);
1426 SUP_DI(cfg_ms_sup_no_dcs, cfg_ms_sup_no_dcs_cmd, dcs, "dcs", "DCS (1800)", 0);
1427
1428 DEFUN(cfg_ms_sup_class_900, cfg_ms_sup_class_900_cmd, "class-900 (1|2|3|4|5)",
1429         "Select power class for GSM 850/900\n"
1430         "20 Watts\n"
1431         "8 Watts\n"
1432         "5 Watts\n"
1433         "2 Watts\n"
1434         "0.8 Watts")
1435 {
1436         struct osmocom_ms *ms = vty->index;
1437         struct gsm_settings *set = &ms->settings;
1438         struct gsm_support *sup = &ms->support;
1439
1440         set->class_900 = atoi(argv[0]);
1441
1442         if (set->class_900 < sup->class_900 && !vty_reading)
1443                 vty_out(vty, "You selected an higher class than supported "
1444                         " by hardware!%s", VTY_NEWLINE);
1445
1446         return CMD_SUCCESS;
1447 }
1448
1449 DEFUN(cfg_ms_sup_class_dcs, cfg_ms_sup_class_dcs_cmd, "class-dcs (1|2|3)",
1450         "Select power class for DCS 1800\n"
1451         "1 Watt\n"
1452         "0.25 Watts\n"
1453         "4 Watts")
1454 {
1455         struct osmocom_ms *ms = vty->index;
1456         struct gsm_settings *set = &ms->settings;
1457         struct gsm_support *sup = &ms->support;
1458
1459         set->class_dcs = atoi(argv[0]);
1460
1461         if (((set->class_dcs + 1) & 3) < ((sup->class_dcs + 1) & 3)
1462          && !vty_reading)
1463                 vty_out(vty, "You selected an higher class than supported "
1464                         " by hardware!%s", VTY_NEWLINE);
1465
1466         return CMD_SUCCESS;
1467 }
1468
1469 DEFUN(cfg_ms_sup_ch_cap, cfg_ms_sup_ch_cap_cmd, "channel-capability "
1470         "(sdcch|sdcch+tchf|sdcch+tchf+tchh)",
1471         "Select channel capability\nSDCCH only\nSDCCH + TCH/F\nSDCCH + TCH/H")
1472 {
1473         struct osmocom_ms *ms = vty->index;
1474         struct gsm_settings *set = &ms->settings;
1475         struct gsm_support *sup = &ms->support;
1476         uint8_t ch_cap;
1477
1478         if (!strcmp(argv[0], "sdcch+tchf+tchh"))
1479                 ch_cap = GSM_CAP_SDCCH_TCHF_TCHH;
1480         else if (!strcmp(argv[0], "sdcch+tchf"))
1481                 ch_cap = GSM_CAP_SDCCH_TCHF;
1482         else
1483                 ch_cap = GSM_CAP_SDCCH;
1484
1485         if (ch_cap > sup->ch_cap && !vty_reading) {
1486                 vty_out(vty, "You selected an higher capability than supported "
1487                         " by hardware!%s", VTY_NEWLINE);
1488                 return CMD_WARNING;
1489         }
1490
1491         set->ch_cap = ch_cap;
1492
1493         return CMD_SUCCESS;
1494 }
1495
1496 SUP_EN(cfg_ms_sup_full_v1, cfg_ms_sup_full_v1_cmd, full_v1, "full-speech-v1",
1497         "Full rate speech V1", 0);
1498 SUP_DI(cfg_ms_sup_no_full_v1, cfg_ms_sup_no_full_v1_cmd, full_v1,
1499         "full-speech-v1", "Full rate speech V1", 0);
1500 SUP_EN(cfg_ms_sup_full_v2, cfg_ms_sup_full_v2_cmd, full_v2, "full-speech-v2",
1501         "Full rate speech V2 (EFR)", 0);
1502 SUP_DI(cfg_ms_sup_no_full_v2, cfg_ms_sup_no_full_v2_cmd, full_v2,
1503         "full-speech-v2", "Full rate speech V2 (EFR)", 0);
1504 SUP_EN(cfg_ms_sup_full_v3, cfg_ms_sup_full_v3_cmd, full_v3, "full-speech-v3",
1505         "Full rate speech V3 (AMR)", 0);
1506 SUP_DI(cfg_ms_sup_no_full_v3, cfg_ms_sup_no_full_v3_cmd, full_v3,
1507         "full-speech-v3", "Full rate speech V3 (AMR)", 0);
1508 SUP_EN(cfg_ms_sup_half_v1, cfg_ms_sup_half_v1_cmd, half_v1, "half-speech-v1",
1509         "Half rate speech V1 (AMR)", 0);
1510 SUP_DI(cfg_ms_sup_no_half_v1, cfg_ms_sup_no_half_v1_cmd, half_v1,
1511         "half-speech-v1", "Half rate speech V1", 0);
1512 SUP_EN(cfg_ms_sup_half_v3, cfg_ms_sup_half_v3_cmd, half_v3, "half-speech-v3",
1513         "Half rate speech V3 (AMR)", 0);
1514 SUP_DI(cfg_ms_sup_no_half_v3, cfg_ms_sup_no_half_v3_cmd, half_v3,
1515         "half-speech-v3", "Half rate speech V3", 0);
1516
1517 DEFUN(cfg_ms_sup_min_rxlev, cfg_ms_sup_min_rxlev_cmd, "min-rxlev <-110--47>",
1518         "Set the minimum receive level to select a cell\n"
1519         "Minimum receive level from -110 dBm to -47 dBm")
1520 {
1521         struct osmocom_ms *ms = vty->index;
1522         struct gsm_settings *set = &ms->settings;
1523
1524         set->min_rxlev_db = atoi(argv[0]);
1525
1526         return CMD_SUCCESS;
1527 }
1528
1529 /* per testsim config */
1530 DEFUN(cfg_ms_testsim, cfg_ms_testsim_cmd, "test-sim",
1531         "Configure test SIM emulation")
1532 {
1533         vty->node = TESTSIM_NODE;
1534
1535         return CMD_SUCCESS;
1536 }
1537
1538 DEFUN(cfg_test_imsi, cfg_test_imsi_cmd, "imsi IMSI",
1539         "Set IMSI on test card\n15 digits IMSI")
1540 {
1541         struct osmocom_ms *ms = vty->index;
1542         struct gsm_settings *set = &ms->settings;
1543         char *error = gsm_check_imsi(argv[0]);
1544
1545         if (error) {
1546                 vty_out(vty, "%s%s", error, VTY_NEWLINE);
1547                 return CMD_WARNING;
1548         }
1549
1550         strcpy(set->test_imsi, argv[0]);
1551
1552         vty_restart(vty);
1553         return CMD_SUCCESS;
1554 }
1555
1556 #define HEX_STR "\nByte as two digits hexadecimal"
1557 DEFUN(cfg_test_ki_xor, cfg_test_ki_xor_cmd, "ki xor HEX HEX HEX HEX HEX HEX "
1558         "HEX HEX HEX HEX HEX HEX",
1559         "Set Key (Kc) on test card\nUse XOR algorithm" HEX_STR HEX_STR HEX_STR
1560         HEX_STR HEX_STR HEX_STR HEX_STR HEX_STR HEX_STR HEX_STR HEX_STR HEX_STR)
1561 {
1562         struct osmocom_ms *ms = vty->index;
1563         struct gsm_settings *set = &ms->settings;
1564         uint8_t ki[12];
1565         const char *p;
1566         int i;
1567
1568         for (i = 0; i < 12; i++) {
1569                 p = argv[i];
1570                 if (!strncmp(p, "0x", 2))
1571                         p += 2;
1572                 if (strlen(p) != 2) {
1573                         vty_out(vty, "Expecting two digits hex value (with or "
1574                                 "without 0x in front)%s", VTY_NEWLINE);
1575                         return CMD_WARNING;
1576                 }
1577                 ki[i] = strtoul(p, NULL, 16);
1578         }
1579
1580         set->test_ki_type = GSM_SIM_KEY_XOR;
1581         memcpy(set->test_ki, ki, 12);
1582         return CMD_SUCCESS;
1583 }
1584
1585 DEFUN(cfg_test_ki_comp128, cfg_test_ki_comp128_cmd, "ki comp128 HEX HEX HEX "
1586         "HEX HEX HEX HEX HEX HEX HEX HEX HEX HEX HEX HEX HEX",
1587         "Set Key (Kc) on test card\nUse XOR algorithm" HEX_STR HEX_STR HEX_STR
1588         HEX_STR HEX_STR HEX_STR HEX_STR HEX_STR HEX_STR HEX_STR HEX_STR HEX_STR
1589         HEX_STR HEX_STR HEX_STR HEX_STR)
1590 {
1591         struct osmocom_ms *ms = vty->index;
1592         struct gsm_settings *set = &ms->settings;
1593         uint8_t ki[16];
1594         const char *p;
1595         int i;
1596
1597         for (i = 0; i < 16; i++) {
1598                 p = argv[i];
1599                 if (!strncmp(p, "0x", 2))
1600                         p += 2;
1601                 if (strlen(p) != 2) {
1602                         vty_out(vty, "Expecting two digits hex value (with or "
1603                                 "without 0x in front)%s", VTY_NEWLINE);
1604                         return CMD_WARNING;
1605                 }
1606                 ki[i] = strtoul(p, NULL, 16);
1607         }
1608
1609         set->test_ki_type = GSM_SIM_KEY_COMP128;
1610         memcpy(set->test_ki, ki, 16);
1611         return CMD_SUCCESS;
1612 }
1613
1614 DEFUN(cfg_test_barr, cfg_test_barr_cmd, "barred-access",
1615         "Allow access to barred cells")
1616 {
1617         struct osmocom_ms *ms = vty->index;
1618         struct gsm_settings *set = &ms->settings;
1619
1620         set->test_barr = 1;
1621
1622         return CMD_SUCCESS;
1623 }
1624
1625 DEFUN(cfg_test_no_barr, cfg_test_no_barr_cmd, "no barred-access",
1626         NO_STR "Deny access to barred cells")
1627 {
1628         struct osmocom_ms *ms = vty->index;
1629         struct gsm_settings *set = &ms->settings;
1630
1631         set->test_barr = 0;
1632
1633         return CMD_SUCCESS;
1634 }
1635
1636 DEFUN(cfg_test_no_rplmn, cfg_test_no_rplmn_cmd, "no rplmn",
1637         NO_STR "Unset Registered PLMN")
1638 {
1639         struct osmocom_ms *ms = vty->index;
1640         struct gsm_settings *set = &ms->settings;
1641
1642         set->test_rplmn_valid = 0;
1643
1644         vty_restart(vty);
1645         return CMD_SUCCESS;
1646 }
1647
1648 DEFUN(cfg_test_rplmn, cfg_test_rplmn_cmd, "rplmn MCC MNC",
1649         "Set Registered PLMN\nMobile Country Code\nMobile Network Code")
1650 {
1651         struct osmocom_ms *ms = vty->index;
1652         struct gsm_settings *set = &ms->settings;
1653         uint16_t mcc = gsm_input_mcc((char *)argv[0]),
1654                  mnc = gsm_input_mnc((char *)argv[1]);
1655
1656         if (!mcc) {
1657                 vty_out(vty, "Given MCC invalid%s", VTY_NEWLINE);
1658                 return CMD_WARNING;
1659         }
1660         if (!mnc) {
1661                 vty_out(vty, "Given MNC invalid%s", VTY_NEWLINE);
1662                 return CMD_WARNING;
1663         }
1664         set->test_rplmn_valid = 1;
1665         set->test_rplmn_mcc = mcc;
1666         set->test_rplmn_mnc = mnc;
1667
1668         vty_restart(vty);
1669         return CMD_SUCCESS;
1670 }
1671
1672 DEFUN(cfg_test_hplmn, cfg_test_hplmn_cmd, "hplmn-search (everywhere|foreign-country)",
1673         "Set Home PLMN search mode\n"
1674         "Search for HPLMN when on any other network\n"
1675         "Search for HPLMN when in a different country")
1676 {
1677         struct osmocom_ms *ms = vty->index;
1678         struct gsm_settings *set = &ms->settings;
1679
1680         switch (argv[0][0]) {
1681         case 'e':
1682                 set->test_always = 1;
1683                 break;
1684         case 'f':
1685                 set->test_always = 0;
1686                 break;
1687         }
1688
1689         vty_restart(vty);
1690         return CMD_SUCCESS;
1691 }
1692
1693 enum node_type ms_vty_go_parent(struct vty *vty)
1694 {
1695         switch (vty->node) {
1696         case MS_NODE:
1697                 vty->node = CONFIG_NODE;
1698                 vty->index = NULL;
1699                 break;
1700         case TESTSIM_NODE:
1701         case SUPPORT_NODE:
1702                 vty->node = MS_NODE;
1703                 break;
1704         default:
1705                 vty->node = CONFIG_NODE;
1706         }
1707
1708         return vty->node;
1709 }
1710
1711 /* Down vty node level. */
1712 gDEFUN(ournode_exit,
1713        ournode_exit_cmd, "exit", "Exit current mode and down to previous mode\n")
1714 {
1715         switch (vty->node) {
1716         case MS_NODE:
1717                 vty->node = CONFIG_NODE;
1718                 vty->index = NULL;
1719                 break;
1720         case TESTSIM_NODE:
1721         case SUPPORT_NODE:
1722                 vty->node = MS_NODE;
1723                 break;
1724         default:
1725                 break;
1726         }
1727         return CMD_SUCCESS;
1728 }
1729
1730 /* End of configuration. */
1731 gDEFUN(ournode_end,
1732        ournode_end_cmd, "end", "End current mode and change to enable mode.")
1733 {
1734         switch (vty->node) {
1735         case VIEW_NODE:
1736         case ENABLE_NODE:
1737                 /* Nothing to do. */
1738                 break;
1739         case CONFIG_NODE:
1740         case VTY_NODE:
1741         case MS_NODE:
1742         case TESTSIM_NODE:
1743         case SUPPORT_NODE:
1744                 vty_config_unlock(vty);
1745                 vty->node = ENABLE_NODE;
1746                 vty->index = NULL;
1747                 vty->index_sub = NULL;
1748                 break;
1749         default:
1750                 break;
1751         }
1752         return CMD_SUCCESS;
1753 }
1754
1755 #define SUP_NODE(item) \
1756         install_element(SUPPORT_NODE, &cfg_ms_sup_item_cmd);
1757
1758 int ms_vty_init(void)
1759 {
1760         install_element_ve(&show_ms_cmd);
1761         install_element_ve(&show_subscr_cmd);
1762         install_element_ve(&show_support_cmd);
1763         install_element_ve(&show_states_cmd);
1764         install_element_ve(&show_cell_cmd);
1765         install_element_ve(&show_cell_si_cmd);
1766         install_element_ve(&show_ba_cmd);
1767         install_element_ve(&show_forb_la_cmd);
1768         install_element_ve(&show_forb_plmn_cmd);
1769         install_element_ve(&monitor_network_cmd);
1770         install_element_ve(&no_monitor_network_cmd);
1771
1772         install_element(ENABLE_NODE, &sim_test_cmd);
1773         install_element(ENABLE_NODE, &sim_reader_cmd);
1774         install_element(ENABLE_NODE, &sim_remove_cmd);
1775         install_element(ENABLE_NODE, &sim_pin_cmd);
1776         install_element(ENABLE_NODE, &sim_disable_pin_cmd);
1777         install_element(ENABLE_NODE, &sim_enable_pin_cmd);
1778         install_element(ENABLE_NODE, &sim_change_pin_cmd);
1779         install_element(ENABLE_NODE, &sim_unblock_pin_cmd);
1780         install_element(ENABLE_NODE, &sim_lai_cmd);
1781         install_element(ENABLE_NODE, &network_search_cmd);
1782         install_element(ENABLE_NODE, &network_show_cmd);
1783         install_element(ENABLE_NODE, &network_select_cmd);
1784         install_element(ENABLE_NODE, &call_cmd);
1785         install_element(ENABLE_NODE, &call_retr_cmd);
1786
1787         install_element(CONFIG_NODE, &cfg_gps_device_cmd);
1788         install_element(CONFIG_NODE, &cfg_gps_baud_cmd);
1789         install_element(CONFIG_NODE, &cfg_gps_enable_cmd);
1790         install_element(CONFIG_NODE, &cfg_no_gps_enable_cmd);
1791
1792         install_element(CONFIG_NODE, &cfg_ms_cmd);
1793         install_element(CONFIG_NODE, &ournode_end_cmd);
1794         install_node(&ms_node, config_write_ms);
1795         install_default(MS_NODE);
1796         install_element(MS_NODE, &ournode_exit_cmd);
1797         install_element(MS_NODE, &ournode_end_cmd);
1798         install_element(MS_NODE, &cfg_ms_sim_cmd);
1799         install_element(MS_NODE, &cfg_ms_mode_cmd);
1800         install_element(MS_NODE, &cfg_ms_imei_cmd);
1801         install_element(MS_NODE, &cfg_ms_imei_fixed_cmd);
1802         install_element(MS_NODE, &cfg_ms_imei_random_cmd);
1803         install_element(MS_NODE, &cfg_ms_no_emerg_imsi_cmd);
1804         install_element(MS_NODE, &cfg_ms_emerg_imsi_cmd);
1805         install_element(MS_NODE, &cfg_ms_cw_cmd);
1806         install_element(MS_NODE, &cfg_ms_no_cw_cmd);
1807         install_element(MS_NODE, &cfg_ms_clip_cmd);
1808         install_element(MS_NODE, &cfg_ms_clir_cmd);
1809         install_element(MS_NODE, &cfg_ms_no_clip_cmd);
1810         install_element(MS_NODE, &cfg_ms_no_clir_cmd);
1811         install_element(MS_NODE, &cfg_ms_tx_power_cmd);
1812         install_element(MS_NODE, &cfg_ms_tx_power_val_cmd);
1813         install_element(MS_NODE, &cfg_ms_sim_delay_cmd);
1814         install_element(MS_NODE, &cfg_ms_no_sim_delay_cmd);
1815         install_element(MS_NODE, &cfg_ms_stick_cmd);
1816         install_element(MS_NODE, &cfg_ms_no_stick_cmd);
1817         install_element(MS_NODE, &cfg_ms_lupd_cmd);
1818         install_element(MS_NODE, &cfg_ms_no_lupd_cmd);
1819         install_element(MS_NODE, &cfg_ms_codec_full_cmd);
1820         install_element(MS_NODE, &cfg_ms_codec_full_pref_cmd);
1821         install_element(MS_NODE, &cfg_ms_codec_half_cmd);
1822         install_element(MS_NODE, &cfg_ms_codec_half_pref_cmd);
1823         install_element(MS_NODE, &cfg_ms_no_codec_half_cmd);
1824         install_element(MS_NODE, &cfg_ms_testsim_cmd);
1825         install_element(MS_NODE, &cfg_ms_support_cmd);
1826         install_node(&support_node, config_write_dummy);
1827         install_default(SUPPORT_NODE);
1828         install_element(SUPPORT_NODE, &ournode_exit_cmd);
1829         install_element(SUPPORT_NODE, &ournode_end_cmd);
1830         install_element(SUPPORT_NODE, &cfg_ms_sup_sms_cmd);
1831         install_element(SUPPORT_NODE, &cfg_ms_sup_no_sms_cmd);
1832         install_element(SUPPORT_NODE, &cfg_ms_sup_a5_1_cmd);
1833         install_element(SUPPORT_NODE, &cfg_ms_sup_no_a5_1_cmd);
1834         install_element(SUPPORT_NODE, &cfg_ms_sup_a5_2_cmd);
1835         install_element(SUPPORT_NODE, &cfg_ms_sup_no_a5_2_cmd);
1836         install_element(SUPPORT_NODE, &cfg_ms_sup_a5_3_cmd);
1837         install_element(SUPPORT_NODE, &cfg_ms_sup_no_a5_3_cmd);
1838         install_element(SUPPORT_NODE, &cfg_ms_sup_a5_4_cmd);
1839         install_element(SUPPORT_NODE, &cfg_ms_sup_no_a5_4_cmd);
1840         install_element(SUPPORT_NODE, &cfg_ms_sup_a5_5_cmd);
1841         install_element(SUPPORT_NODE, &cfg_ms_sup_no_a5_5_cmd);
1842         install_element(SUPPORT_NODE, &cfg_ms_sup_a5_6_cmd);
1843         install_element(SUPPORT_NODE, &cfg_ms_sup_no_a5_6_cmd);
1844         install_element(SUPPORT_NODE, &cfg_ms_sup_a5_7_cmd);
1845         install_element(SUPPORT_NODE, &cfg_ms_sup_no_a5_7_cmd);
1846         install_element(SUPPORT_NODE, &cfg_ms_sup_p_gsm_cmd);
1847         install_element(SUPPORT_NODE, &cfg_ms_sup_no_p_gsm_cmd);
1848         install_element(SUPPORT_NODE, &cfg_ms_sup_e_gsm_cmd);
1849         install_element(SUPPORT_NODE, &cfg_ms_sup_no_e_gsm_cmd);
1850         install_element(SUPPORT_NODE, &cfg_ms_sup_r_gsm_cmd);
1851         install_element(SUPPORT_NODE, &cfg_ms_sup_no_r_gsm_cmd);
1852         install_element(SUPPORT_NODE, &cfg_ms_sup_dcs_cmd);
1853         install_element(SUPPORT_NODE, &cfg_ms_sup_no_dcs_cmd);
1854         install_element(SUPPORT_NODE, &cfg_ms_sup_class_900_cmd);
1855         install_element(SUPPORT_NODE, &cfg_ms_sup_class_dcs_cmd);
1856         install_element(SUPPORT_NODE, &cfg_ms_sup_ch_cap_cmd);
1857         install_element(SUPPORT_NODE, &cfg_ms_sup_full_v1_cmd);
1858         install_element(SUPPORT_NODE, &cfg_ms_sup_no_full_v1_cmd);
1859         install_element(SUPPORT_NODE, &cfg_ms_sup_full_v2_cmd);
1860         install_element(SUPPORT_NODE, &cfg_ms_sup_no_full_v2_cmd);
1861         install_element(SUPPORT_NODE, &cfg_ms_sup_full_v3_cmd);
1862         install_element(SUPPORT_NODE, &cfg_ms_sup_no_full_v3_cmd);
1863         install_element(SUPPORT_NODE, &cfg_ms_sup_half_v1_cmd);
1864         install_element(SUPPORT_NODE, &cfg_ms_sup_no_half_v1_cmd);
1865         install_element(SUPPORT_NODE, &cfg_ms_sup_half_v3_cmd);
1866         install_element(SUPPORT_NODE, &cfg_ms_sup_no_half_v3_cmd);
1867         install_element(SUPPORT_NODE, &cfg_ms_sup_min_rxlev_cmd);
1868         install_node(&testsim_node, config_write_dummy);
1869         install_default(TESTSIM_NODE);
1870         install_element(TESTSIM_NODE, &ournode_exit_cmd);
1871         install_element(TESTSIM_NODE, &ournode_end_cmd);
1872         install_element(TESTSIM_NODE, &cfg_test_imsi_cmd);
1873         install_element(TESTSIM_NODE, &cfg_test_ki_xor_cmd);
1874         install_element(TESTSIM_NODE, &cfg_test_ki_comp128_cmd);
1875         install_element(TESTSIM_NODE, &cfg_test_barr_cmd);
1876         install_element(TESTSIM_NODE, &cfg_test_no_barr_cmd);
1877         install_element(TESTSIM_NODE, &cfg_test_no_rplmn_cmd);
1878         install_element(TESTSIM_NODE, &cfg_test_rplmn_cmd);
1879         install_element(TESTSIM_NODE, &cfg_test_hplmn_cmd);
1880
1881         return 0;
1882 }
1883
1884 void vty_notify(struct osmocom_ms *ms, const char *fmt, ...)
1885 {
1886         struct telnet_connection *connection;
1887         char buffer[1000];
1888         va_list args;
1889         struct vty *vty;
1890
1891         if (fmt) {
1892                 va_start(args, fmt);
1893                 vsnprintf(buffer, sizeof(buffer) - 1, fmt, args);
1894                 buffer[sizeof(buffer) - 1] = '\0';
1895                 va_end(args);
1896
1897                 if (!buffer[0])
1898                         return;
1899         }
1900
1901         llist_for_each_entry(connection, &active_connections, entry) {
1902                 vty = connection->vty;
1903                 if (!vty)
1904                         continue;
1905                 if (!fmt) {
1906                         vty_out(vty, "%s%% (MS %s)%s", VTY_NEWLINE, ms->name,
1907                                 VTY_NEWLINE);
1908                         continue;
1909                 }
1910                 if (buffer[strlen(buffer) - 1] == '\n') {
1911                         buffer[strlen(buffer) - 1] = '\0';
1912                         vty_out(vty, "%% %s%s", buffer, VTY_NEWLINE);
1913                         buffer[strlen(buffer)] = '\n';
1914                 } else
1915                         vty_out(vty, "%% %s", buffer);
1916         }
1917 }
1918