tools/stktest.c

   1 /*
   2  *
   3  *  oFono - Open Source Telephony
   4  *
   5  *  Copyright (C) 2008-2011  Intel Corporation. All rights reserved.
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License version 2 as
   9  *  published by the Free Software Foundation.
  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
  17  *  along with this program; if not, write to the Free Software
  18  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  19  *
  20  */
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include <config.h>
  24 #endif
  25
  26 #include <stdio.h>
  27 #include <errno.h>
  28 #include <fcntl.h>
  29 #include <unistd.h>
  30 #include <stdlib.h>
  31 #include <string.h>
  32 #include <signal.h>
  33 #include <netinet/in.h>
  34 #include <arpa/inet.h>
  35
  36 #include <gdbus.h>
  37 #include <gatchat/gatserver.h>
  38
  39 #define OFONO_SERVICE   "org.ofono"
  40 #define STKTEST_PATH    "/stktest"
  41 #define STKTEST_ERROR   "org.ofono.stktest"
  42 #define OFONO_MANAGER_INTERFACE         OFONO_SERVICE ".Manager"
  43 #define OFONO_MODEM_INTERFACE           OFONO_SERVICE ".Modem"
  44 #define OFONO_STK_INTERFACE             OFONO_SERVICE ".SimToolkit"
  45 #define OFONO_STKAGENT_INTERFACE        OFONO_SERVICE ".SimToolkitAgent"
  46
  47 #define LISTEN_PORT     12765
  48
  49 enum test_state {
  50         TEST_STATE_POWERING_UP = 1,
  51         TEST_STATE_REGISTERING_AGENT,
  52         TEST_STATE_RUNNING,
  53         TEST_STATE_POWERING_DOWN,
  54 };
  55
  56 static GMainLoop *main_loop = NULL;
  57 static volatile sig_atomic_t __terminated = 0;
  58
  59 /* DBus related */
  60 static DBusConnection *conn;
  61 static gboolean ofono_running = FALSE;
  62 static guint modem_changed_watch;
  63 enum test_state state;
  64
  65 /* Emulator setup */
  66 static guint server_watch;
  67 static GAtServer *emulator;
  68
  69 /* Emulated modem state variables */
  70 static int modem_mode = 0;
  71
  72 static gboolean create_tcp(void);
  73
  74 static const char *to_hex(const unsigned char *data, unsigned int len)
  75 {
  76         static char buf[512+1];
  77         unsigned int i;
  78
  79         for (i = 0; i < len; i++)
  80                 sprintf(buf + i * 2, "%02hhX", data[i]);
  81
  82         buf[i*2] = '\0';
  83
  84         return buf;
  85 }
  86
  87 static void send_proactive_command(const unsigned char *pdu, unsigned int len)
  88 {
  89         char buf[1024];
  90
  91         sprintf(buf, "+CUSATP: %s", to_hex(pdu, len));
  92         g_at_server_send_unsolicited(emulator, buf);
  93 }
  94
  95 static DBusMessage *stktest_error_invalid_args(DBusMessage *msg)
  96 {
  97         return g_dbus_create_error(msg, STKTEST_ERROR ".InvalidArguments",
  98                                         "Invalid arguments provided");
  99 }
 100
 101 static DBusMessage *agent_release(DBusConnection *conn, DBusMessage *msg,
 102                                         void *data)
 103 {
 104         g_print("Got Release");
 105
 106         return dbus_message_new_method_return(msg);
 107 }
 108
 109 static DBusMessage *agent_display_text(DBusConnection *conn, DBusMessage *msg,
 110                                         void *data)
 111 {
 112         const char *text;
 113         unsigned char icon_id;
 114         dbus_bool_t urgent;
 115
 116         if (dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &text,
 117                                                 DBUS_TYPE_BYTE, &icon_id,
 118                                                 DBUS_TYPE_BOOLEAN, &urgent,
 119                                                 DBUS_TYPE_INVALID) == FALSE)
 120                 return stktest_error_invalid_args(msg);
 121
 122         g_print("Got DisplayText with: %s, %u, %d\n", text, icon_id, urgent);
 123
 124         return dbus_message_new_method_return(msg);
 125 }
 126
 127 static void server_debug(const char *str, void *data)
 128 {
 129         g_print("%s: %s\n", (char *) data, str);
 130 }
 131
 132 static void cgmi_cb(GAtServer *server, GAtServerRequestType type,
 133                         GAtResult *cmd, gpointer user)
 134 {
 135         switch (type) {
 136         case G_AT_SERVER_REQUEST_TYPE_COMMAND_ONLY:
 137                 g_at_server_send_info(server, "oFono", TRUE);
 138                 g_at_server_send_final(server, G_AT_SERVER_RESULT_OK);
 139                 break;
 140         case G_AT_SERVER_REQUEST_TYPE_SUPPORT:
 141                 g_at_server_send_final(server, G_AT_SERVER_RESULT_OK);
 142                 break;
 143         default:
 144                 g_at_server_send_final(server, G_AT_SERVER_RESULT_ERROR);
 145         };
 146 }
 147
 148 static void cgmm_cb(GAtServer *server, GAtServerRequestType type,
 149                         GAtResult *cmd, gpointer user)
 150 {
 151         switch (type) {
 152         case G_AT_SERVER_REQUEST_TYPE_COMMAND_ONLY:
 153                 g_at_server_send_info(server, "oFono pre-1.0", TRUE);
 154                 g_at_server_send_final(server, G_AT_SERVER_RESULT_OK);
 155                 break;
 156         case G_AT_SERVER_REQUEST_TYPE_SUPPORT:
 157                 g_at_server_send_final(server, G_AT_SERVER_RESULT_OK);
 158                 break;
 159         default:
 160                 g_at_server_send_final(server, G_AT_SERVER_RESULT_ERROR);
 161         };
 162 }
 163
 164 static void cgmr_cb(GAtServer *server, GAtServerRequestType type,
 165                         GAtResult *cmd, gpointer user)
 166 {
 167         char buf[256];
 168
 169         switch (type) {
 170         case G_AT_SERVER_REQUEST_TYPE_COMMAND_ONLY:
 171                 sprintf(buf, "oFono pre-1.0 version: %s", VERSION);
 172                 g_at_server_send_info(server, buf, TRUE);
 173                 g_at_server_send_final(server, G_AT_SERVER_RESULT_OK);
 174                 break;
 175         case G_AT_SERVER_REQUEST_TYPE_SUPPORT:
 176                 g_at_server_send_final(server, G_AT_SERVER_RESULT_OK);
 177                 break;
 178         default:
 179                 g_at_server_send_final(server, G_AT_SERVER_RESULT_ERROR);
 180         };
 181 }
 182
 183 static void cgsn_cb(GAtServer *server, GAtServerRequestType type,
 184                         GAtResult *cmd, gpointer user)
 185 {
 186         switch (type) {
 187         case G_AT_SERVER_REQUEST_TYPE_COMMAND_ONLY:
 188                 g_at_server_send_info(server, "123456789", TRUE);
 189                 g_at_server_send_final(server, G_AT_SERVER_RESULT_OK);
 190                 break;
 191         case G_AT_SERVER_REQUEST_TYPE_SUPPORT:
 192                 g_at_server_send_final(server, G_AT_SERVER_RESULT_OK);
 193                 break;
 194         default:
 195                 g_at_server_send_final(server, G_AT_SERVER_RESULT_ERROR);
 196         };
 197 }
 198
 199 static gboolean send_ok(gpointer user)
 200 {
 201         GAtServer *server = user;
 202
 203         g_at_server_send_final(server, G_AT_SERVER_RESULT_OK);
 204
 205         return FALSE;
 206 }
 207
 208 static void cfun_cb(GAtServer *server, GAtServerRequestType type,
 209                         GAtResult *cmd, gpointer user)
 210 {
 211         char buf[12];
 212
 213         switch (type) {
 214         case G_AT_SERVER_REQUEST_TYPE_SUPPORT:
 215                 g_at_server_send_info(server, "+CFUN: (0-1,4)", TRUE);
 216                 g_at_server_send_final(server, G_AT_SERVER_RESULT_OK);
 217                 break;
 218         case G_AT_SERVER_REQUEST_TYPE_QUERY:
 219                 snprintf(buf, sizeof(buf), "+CFUN: %d", modem_mode);
 220                 g_at_server_send_info(server, buf, TRUE);
 221                 g_at_server_send_final(server, G_AT_SERVER_RESULT_OK);
 222                 break;
 223         case G_AT_SERVER_REQUEST_TYPE_SET:
 224         {
 225                 GAtResultIter iter;
 226                 int mode;
 227
 228                 g_at_result_iter_init(&iter, cmd);
 229                 g_at_result_iter_next(&iter, "");
 230
 231                 if (g_at_result_iter_next_number(&iter, &mode) == FALSE)
 232                         goto error;
 233
 234                 if (mode != 0 && mode != 1)
 235                         goto error;
 236
 237                 if (modem_mode == mode) {
 238                         g_at_server_send_final(server, G_AT_SERVER_RESULT_OK);
 239                         break;
 240                 }
 241
 242                 modem_mode = mode;
 243                 g_timeout_add_seconds(1, send_ok, server);
 244                 break;
 245         }
 246         default:
 247                 goto error;
 248         };
 249
 250         return;
 251
 252 error:
 253         g_at_server_send_final(server, G_AT_SERVER_RESULT_ERROR);
 254 }
 255
 256 static void listen_again(gpointer user_data)
 257 {
 258         if (create_tcp() == TRUE)
 259                 return;
 260
 261         g_print("Error listening to socket\n");
 262         g_main_loop_quit(main_loop);
 263 }
 264
 265 static void setup_emulator(GAtServer *server)
 266 {
 267         g_at_server_set_debug(server, server_debug, "Server");
 268
 269         g_at_server_register(server, "+CGMI", cgmi_cb, NULL, NULL);
 270         g_at_server_register(server, "+CGMM", cgmm_cb, NULL, NULL);
 271         g_at_server_register(server, "+CGMR", cgmr_cb, NULL, NULL);
 272         g_at_server_register(server, "+CGSN", cgsn_cb, NULL, NULL);
 273         g_at_server_register(server, "+CFUN", cfun_cb, NULL, NULL);
 274
 275         g_at_server_set_disconnect_function(server, listen_again, NULL);
 276 }
 277
 278 static gboolean on_socket_connected(GIOChannel *chan, GIOCondition cond,
 279                                                         gpointer user)
 280 {
 281         struct sockaddr saddr;
 282         unsigned int len = sizeof(saddr);
 283         int fd;
 284         GIOChannel *client_io = NULL;
 285
 286         if (cond != G_IO_IN)
 287                 goto error;
 288
 289         fd = accept(g_io_channel_unix_get_fd(chan), &saddr, &len);
 290         if (fd == -1)
 291                 goto error;
 292
 293         client_io = g_io_channel_unix_new(fd);
 294
 295         emulator = g_at_server_new(client_io);
 296         g_io_channel_unref(client_io);
 297
 298         if (emulator == NULL)
 299                 goto error;
 300
 301         setup_emulator(emulator);
 302
 303 error:
 304         server_watch = 0;
 305         return FALSE;
 306 }
 307
 308 static gboolean create_tcp(void)
 309 {
 310         struct sockaddr_in addr;
 311         int sk;
 312         int reuseaddr = 1;
 313         GIOChannel *server_io;
 314
 315         sk = socket(PF_INET, SOCK_STREAM, 0);
 316         if (sk < 0) {
 317                 g_print("Can't create tcp/ip socket: %s (%d)\n",
 318                                                 strerror(errno), errno);
 319                 return FALSE;
 320         }
 321
 322         memset(&addr, 0, sizeof(addr));
 323
 324         addr.sin_family = AF_INET;
 325         addr.sin_addr.s_addr = INADDR_ANY;
 326         addr.sin_port = htons(LISTEN_PORT);
 327
 328         setsockopt(sk, SOL_SOCKET, SO_REUSEADDR, &reuseaddr, sizeof(reuseaddr));
 329         if (bind(sk, (struct sockaddr *) &addr, sizeof(struct sockaddr)) < 0) {
 330                 g_print("Can't bind socket: %s (%d)", strerror(errno), errno);
 331                 close(sk);
 332                 return FALSE;
 333         }
 334
 335         if (listen(sk, 1) < 0) {
 336                 g_print("Can't listen on socket: %s (%d)",
 337                                                 strerror(errno), errno);
 338                 close(sk);
 339                 return FALSE;
 340         }
 341
 342         g_print("new tcp is created at tcp port %d\n", LISTEN_PORT);
 343
 344         server_io = g_io_channel_unix_new(sk);
 345         g_io_channel_set_close_on_unref(server_io, TRUE);
 346
 347         server_watch = g_io_add_watch_full(server_io,
 348                                 G_PRIORITY_DEFAULT,
 349                                 G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
 350                                 on_socket_connected, NULL, NULL);
 351
 352         g_io_channel_unref(server_io);
 353
 354         return TRUE;
 355 }
 356
 357 static gboolean has_stk_interface(DBusMessageIter *iter)
 358 {
 359         DBusMessageIter entry;
 360
 361         dbus_message_iter_recurse(iter, &entry);
 362
 363         while (dbus_message_iter_get_arg_type(&entry) == DBUS_TYPE_STRING) {
 364                 const char *interface;
 365
 366                 dbus_message_iter_get_basic(&entry, &interface);
 367
 368                 if (g_str_equal(interface, OFONO_STK_INTERFACE) == TRUE)
 369                         return TRUE;
 370
 371                 dbus_message_iter_next(&entry);
 372         }
 373
 374         return FALSE;
 375 }
 376
 377 static int send_with_reply(const char *path, const char *interface,
 378                                 const char *method, DBusPendingCall **call,
 379                                 DBusPendingCallNotifyFunction cb,
 380                                 void *user_data, DBusFreeFunction free_func,
 381                                 int timeout, int type, ...)
 382 {
 383         DBusMessage *msg;
 384         DBusPendingCall *c;
 385         va_list args;
 386         int err;
 387
 388         msg = dbus_message_new_method_call(OFONO_SERVICE, path,
 389                                                 interface, method);
 390         if (msg == NULL) {
 391                 g_printerr("Unable to allocate new D-Bus %s message\n", method);
 392                 err = -ENOMEM;
 393                 goto fail;
 394         }
 395
 396         va_start(args, type);
 397
 398         if (!dbus_message_append_args_valist(msg, type, args)) {
 399                 va_end(args);
 400                 err = -EIO;
 401                 goto fail;
 402         }
 403
 404         va_end(args);
 405
 406         if (timeout > 0)
 407                 timeout *= 1000;
 408
 409         if (!dbus_connection_send_with_reply(conn, msg, &c, timeout)) {
 410                 g_printerr("Sending %s failed\n", method);
 411                 err = -EIO;
 412                 goto fail;
 413         }
 414
 415         if (call != NULL)
 416                 *call = c;
 417
 418         dbus_pending_call_set_notify(c, cb, user_data, free_func);
 419         dbus_pending_call_unref(c);
 420
 421         dbus_message_unref(msg);
 422
 423         return 0;
 424
 425 fail:
 426         if (free_func && user_data)
 427                 free_func(user_data);
 428
 429         if (msg)
 430                 dbus_message_unref(msg);
 431
 432         return err;
 433 }
 434
 435 static void set_property_reply(DBusPendingCall *call, void *user_data)
 436 {
 437         DBusMessage *reply = dbus_pending_call_steal_reply(call);
 438         DBusError err;
 439
 440         dbus_error_init(&err);
 441
 442         if (dbus_set_error_from_message(&err, reply) == TRUE) {
 443                 g_printerr("%s: %s\n", err.name, err.message);
 444                 dbus_error_free(&err);
 445         }
 446
 447         dbus_message_unref(reply);
 448 }
 449
 450 static int set_property(const char *path, const char *interface,
 451                         const char *key, int type, const void *val,
 452                         DBusPendingCallNotifyFunction notify,
 453                         gpointer user_data,
 454                         DBusFreeFunction destroy)
 455 {
 456         DBusMessage *msg;
 457         DBusMessageIter iter, value;
 458         DBusPendingCall *call;
 459         const char *signature;
 460
 461         msg = dbus_message_new_method_call(OFONO_SERVICE, path, interface,
 462                                                 "SetProperty");
 463         if (msg == NULL)
 464                 return -ENOMEM;
 465
 466         dbus_message_set_auto_start(msg, FALSE);
 467
 468         dbus_message_iter_init_append(msg, &iter);
 469
 470         dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &key);
 471
 472         switch (type) {
 473         case DBUS_TYPE_BOOLEAN:
 474                 signature = DBUS_TYPE_BOOLEAN_AS_STRING;
 475                 break;
 476         default:
 477                 dbus_message_unref(msg);
 478                 return -EINVAL;
 479         }
 480
 481         dbus_message_iter_open_container(&iter, DBUS_TYPE_VARIANT,
 482                                                         signature, &value);
 483         dbus_message_iter_append_basic(&value, type, val);
 484         dbus_message_iter_close_container(&iter, &value);
 485
 486         if (dbus_connection_send_with_reply(conn, msg, &call, -1) == FALSE) {
 487                 dbus_message_unref(msg);
 488                 return -EIO;
 489         }
 490
 491         dbus_message_unref(msg);
 492
 493         if (call == NULL)
 494                 return -EINVAL;
 495
 496         dbus_pending_call_set_notify(call, notify, user_data, destroy);
 497
 498         dbus_pending_call_unref(call);
 499
 500         return 0;
 501 }
 502
 503 static void register_agent_reply(DBusPendingCall *call, void *user_data)
 504 {
 505         DBusMessage *reply = dbus_pending_call_steal_reply(call);
 506         DBusError err;
 507
 508         dbus_error_init(&err);
 509
 510         if (dbus_set_error_from_message(&err, reply) == TRUE) {
 511                 g_printerr("%s: %s\n", err.name, err.message);
 512                 dbus_error_free(&err);
 513         }
 514
 515         dbus_message_unref(reply);
 516
 517         state = TEST_STATE_RUNNING;
 518 }
 519
 520 static void register_agent()
 521 {
 522         const char *path = "/default";
 523         int status;
 524
 525         g_print("Gained STK interface, registering agent...\n");
 526
 527         status = send_with_reply(STKTEST_PATH, OFONO_STK_INTERFACE,
 528                                         "RegisterAgent", NULL,
 529                                         register_agent_reply, NULL, NULL, 1,
 530                                         DBUS_TYPE_OBJECT_PATH, &path,
 531                                         DBUS_TYPE_INVALID);
 532
 533         if (status < 0) {
 534                 g_printerr("Unable to register agent with oFono\n");
 535                 g_main_loop_quit(main_loop);
 536                 return;
 537         }
 538
 539         state = TEST_STATE_REGISTERING_AGENT;
 540 }
 541
 542 static gboolean modem_changed(DBusConnection *conn,
 543                                 DBusMessage *msg, void *user_data)
 544 {
 545         DBusMessageIter iter, value;
 546         const char *path, *key;
 547         gboolean has_stk;
 548
 549         if (dbus_message_iter_init(msg, &iter) == FALSE)
 550                 return TRUE;
 551
 552         path = dbus_message_get_path(msg);
 553
 554         if (g_str_equal(STKTEST_PATH, path) == FALSE)
 555                 return TRUE;
 556
 557         dbus_message_iter_get_basic(&iter, &key);
 558
 559         dbus_message_iter_next(&iter);
 560         dbus_message_iter_recurse(&iter, &value);
 561
 562         if (g_str_equal(key, "Interfaces") == FALSE)
 563                 return TRUE;
 564
 565         has_stk = has_stk_interface(&value);
 566
 567         switch (state) {
 568         case TEST_STATE_POWERING_UP:
 569                 if (has_stk)
 570                         register_agent();
 571                 break;
 572         case TEST_STATE_REGISTERING_AGENT:
 573         case TEST_STATE_RUNNING:
 574                 if (has_stk == FALSE)
 575                         g_printerr("Unexpectedly lost STK interface\n");
 576                 /* Fall through */
 577         case TEST_STATE_POWERING_DOWN:
 578                 break;
 579         };
 580
 581         return TRUE;
 582 }
 583
 584 static void powerup(void)
 585 {
 586         dbus_bool_t powered = TRUE;
 587
 588         state = TEST_STATE_POWERING_UP;
 589         set_property(STKTEST_PATH, OFONO_MODEM_INTERFACE, "Powered",
 590                         DBUS_TYPE_BOOLEAN, &powered,
 591                         set_property_reply, NULL, NULL);
 592 }
 593
 594 static void get_modems_reply(DBusPendingCall *call, void *user_data)
 595 {
 596         DBusMessage *reply = dbus_pending_call_steal_reply(call);
 597         DBusMessageIter iter, list;
 598         DBusError err;
 599         gboolean found = FALSE;
 600
 601         dbus_error_init(&err);
 602
 603         if (dbus_set_error_from_message(&err, reply) == TRUE) {
 604                 g_printerr("%s: %s\n", err.name, err.message);
 605                 dbus_error_free(&err);
 606                 goto done;
 607         }
 608
 609         if (dbus_message_has_signature(reply, "a(oa{sv})") == FALSE)
 610                 goto done;
 611
 612         if (dbus_message_iter_init(reply, &iter) == FALSE)
 613                 goto done;
 614
 615         dbus_message_iter_recurse(&iter, &list);
 616
 617         while (dbus_message_iter_get_arg_type(&list) == DBUS_TYPE_STRUCT) {
 618                 DBusMessageIter entry;
 619                 const char *path;
 620
 621                 dbus_message_iter_recurse(&list, &entry);
 622                 dbus_message_iter_get_basic(&entry, &path);
 623
 624                 if (g_str_equal(path, STKTEST_PATH))
 625                         found = TRUE;
 626
 627                 dbus_message_iter_next(&list);
 628         }
 629
 630 done:
 631         dbus_message_unref(reply);
 632
 633         if (found == FALSE) {
 634                 g_printerr("STK Test modem not found\n");
 635                 g_main_loop_quit(main_loop);
 636                 return;
 637         }
 638
 639         g_print("Test modem found\n");
 640
 641         modem_changed_watch = g_dbus_add_signal_watch(conn, OFONO_SERVICE,
 642                                                         STKTEST_PATH,
 643                                                         OFONO_MODEM_INTERFACE,
 644                                                         "PropertyChanged",
 645                                                         modem_changed,
 646                                                         NULL, NULL);
 647
 648         if (create_tcp() == FALSE) {
 649                 g_printerr("Unable to listen on modem emulator socket\n");
 650                 g_main_loop_quit(main_loop);
 651         }
 652
 653         powerup();
 654 }
 655
 656 static int get_modems(DBusConnection *conn)
 657 {
 658         DBusMessage *msg;
 659         DBusPendingCall *call;
 660
 661         msg = dbus_message_new_method_call(OFONO_SERVICE, "/",
 662                                         OFONO_MANAGER_INTERFACE, "GetModems");
 663         if (msg == NULL)
 664                 return -ENOMEM;
 665
 666         dbus_message_set_auto_start(msg, FALSE);
 667
 668         g_print("getting modems\n");
 669
 670         if (dbus_connection_send_with_reply(conn, msg, &call, -1) == FALSE) {
 671                 dbus_message_unref(msg);
 672                 return -EIO;
 673         }
 674
 675         dbus_message_unref(msg);
 676
 677         if (call == NULL)
 678                 return -EINVAL;
 679
 680         dbus_pending_call_set_notify(call, get_modems_reply, conn, NULL);
 681
 682         dbus_pending_call_unref(call);
 683
 684         return 0;
 685 }
 686
 687 static const GDBusMethodTable agent_methods[] = {
 688         { GDBUS_METHOD("Release", NULL, NULL, agent_release) },
 689         { GDBUS_METHOD("DisplayText",
 690                 GDBUS_ARGS({ "text", "s" }, { "icon_id", "y" },
 691                                 { "urgent", "b" }), NULL,
 692                                 agent_display_text) },
 693         { },
 694 };
 695
 696 static void ofono_connect(DBusConnection *conn, void *user_data)
 697 {
 698         g_print("starting telephony interface\n");
 699
 700         if (!g_dbus_register_interface(conn, "/default",
 701                                         OFONO_STKAGENT_INTERFACE,
 702                                         agent_methods, NULL, NULL,
 703                                         NULL, NULL)) {
 704                 g_printerr("Unable to register local agent");
 705                 g_main_loop_quit(main_loop);
 706         }
 707
 708         ofono_running = TRUE;
 709         get_modems(conn);
 710 }
 711
 712 static void ofono_disconnect(DBusConnection *conn, void *user_data)
 713 {
 714         g_print("stopping telephony interface\n");
 715
 716         g_dbus_unregister_interface(conn, "/default", OFONO_STKAGENT_INTERFACE);
 717
 718         ofono_running = FALSE;
 719
 720         g_dbus_remove_watch(conn, modem_changed_watch);
 721         modem_changed_watch = 0;
 722
 723         if (server_watch) {
 724                 g_source_remove(server_watch);
 725                 server_watch = 0;
 726         }
 727
 728         g_at_server_unref(emulator);
 729         emulator = NULL;
 730 }
 731
 732 static void sig_term(int sig)
 733 {
 734         if (__terminated > 0)
 735                 return;
 736
 737         __terminated = 1;
 738
 739         g_print("Terminating\n");
 740
 741         g_main_loop_quit(main_loop);
 742 }
 743
 744 static void disconnect_callback(DBusConnection *conn, void *user_data)
 745 {
 746         g_printerr("D-Bus disconnect\n");
 747
 748         g_main_loop_quit(main_loop);
 749 }
 750
 751 static gboolean option_version = FALSE;
 752
 753 static GOptionEntry options[] = {
 754         { "version", 'v', 0, G_OPTION_ARG_NONE, &option_version,
 755                                 "Show version information and exit" },
 756         { NULL },
 757 };
 758
 759 int main(int argc, char **argv)
 760 {
 761         GOptionContext *context;
 762         GError *error = NULL;
 763         DBusError err;
 764         guint watch;
 765         struct sigaction sa;
 766
 767         context = g_option_context_new(NULL);
 768         g_option_context_add_main_entries(context, options, NULL);
 769
 770         if (g_option_context_parse(context, &argc, &argv, &error) == FALSE) {
 771                 if (error != NULL) {
 772                         g_printerr("%s\n", error->message);
 773                         g_error_free(error);
 774                 } else
 775                         g_printerr("An unknown error occurred\n");
 776                 exit(1);
 777         }
 778
 779         g_option_context_free(context);
 780
 781         if (option_version == TRUE) {
 782                 printf("%s\n", VERSION);
 783                 exit(0);
 784         }
 785
 786         main_loop = g_main_loop_new(NULL, FALSE);
 787
 788         dbus_error_init(&err);
 789
 790         conn = g_dbus_setup_bus(DBUS_BUS_SYSTEM, NULL, &err);
 791         if (conn == NULL) {
 792                 if (dbus_error_is_set(&err) == TRUE) {
 793                         fprintf(stderr, "%s\n", err.message);
 794                         dbus_error_free(&err);
 795                 } else
 796                         fprintf(stderr, "Can't register with system bus\n");
 797                 exit(1);
 798         }
 799
 800         g_dbus_set_disconnect_function(conn, disconnect_callback, NULL, NULL);
 801
 802         memset(&sa, 0, sizeof(sa));
 803         sa.sa_handler = sig_term;
 804         sigaction(SIGINT, &sa, NULL);
 805         sigaction(SIGTERM, &sa, NULL);
 806
 807         watch = g_dbus_add_service_watch(conn, OFONO_SERVICE,
 808                                 ofono_connect, ofono_disconnect, NULL, NULL);
 809
 810         g_main_loop_run(main_loop);
 811
 812         g_dbus_remove_watch(conn, watch);
 813
 814         if (ofono_running == TRUE)
 815                 ofono_disconnect(conn, NULL);
 816
 817         dbus_connection_unref(conn);
 818
 819         g_main_loop_unref(main_loop);
 820
 821         return 0;
 822 }