dbus.c

   1 /*
   2  * dbus.c - awesome dbus support
   3  *
   4  * Copyright © 2008 Julien Danjou <julien@danjou.info>
   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 "dbus.h"
  23 #include "client.h"
  24
  25 #ifdef WITH_DBUS
  26
  27 #include <ev.h>
  28 #include <dbus/dbus.h>
  29 #include <unistd.h>
  30 #include <fcntl.h>
  31
  32 #include "event.h"
  33
  34 static DBusConnection *dbus_connection_session = NULL;
  35 static DBusConnection *dbus_connection_system = NULL;
  36 ev_io dbusio_ses = { .fd = -1 };
  37 ev_io dbusio_sys = { .fd = -1 };
  38
  39 static void
  40 a_dbus_cleanup_bus(DBusConnection *dbus_connection, ev_io *dbusio)
  41 {
  42     if(!dbus_connection)
  43         return;
  44
  45     if(dbusio->fd >= 0)
  46     {
  47         ev_ref(EV_DEFAULT_UC);
  48         ev_io_stop(EV_DEFAULT_UC_ dbusio);
  49         dbusio->fd = -1;
  50     }
  51
  52     /* This is a shared connection owned by libdbus
  53      * Do not close it, only unref
  54      */
  55     dbus_connection_unref(dbus_connection);
  56 }
  57
  58 static int
  59 a_dbus_message_iter(DBusMessageIter *iter)
  60 {
  61     int nargs = 0;
  62
  63     do
  64     {
  65         switch(dbus_message_iter_get_arg_type(iter))
  66         {
  67           default:
  68             lua_pushnil(globalconf.L);
  69             nargs++;
  70             break;
  71           case DBUS_TYPE_INVALID:
  72             break;
  73           case DBUS_TYPE_VARIANT:
  74             {
  75                 DBusMessageIter subiter;
  76                 dbus_message_iter_recurse(iter, &subiter);
  77                 a_dbus_message_iter(&subiter);
  78             }
  79             nargs++;
  80             break;
  81           case DBUS_TYPE_DICT_ENTRY:
  82             {
  83                 DBusMessageIter subiter;
  84
  85                 /* initialize a sub iterator */
  86                 dbus_message_iter_recurse(iter, &subiter);
  87                 /* create a new table to store the dict */
  88                 a_dbus_message_iter(&subiter);
  89             }
  90             nargs++;
  91             break;
  92           case DBUS_TYPE_STRUCT:
  93             {
  94                 DBusMessageIter subiter;
  95                 /* initialize a sub iterator */
  96                 dbus_message_iter_recurse(iter, &subiter);
  97
  98                 int n = a_dbus_message_iter(&subiter);
  99
 100                 /* create a new table to store all the value */
 101                 lua_createtable(globalconf.L, n, 0);
 102                 /* move the table before array elements */
 103                 lua_insert(globalconf.L, - n - 1);
 104
 105                 for(int i = n; i > 0; i--)
 106                     lua_rawseti(globalconf.L, - i - 1, i);
 107             }
 108             nargs++;
 109             break;
 110           case DBUS_TYPE_ARRAY:
 111             {
 112                 int array_type = dbus_message_iter_get_element_type(iter);
 113
 114                 if(dbus_type_is_fixed(array_type))
 115                 {
 116                     DBusMessageIter sub;
 117                     dbus_message_iter_recurse(iter, &sub);
 118
 119                     switch(array_type)
 120                     {
 121                       int datalen = 0;
 122 #define DBUS_MSG_HANDLE_ARRAY_TYPE_NUMBER(type, dbustype) \
 123                       case dbustype: \
 124                         { \
 125                             const type *data; \
 126                             dbus_message_iter_get_fixed_array(&sub, &data, &datalen); \
 127                             lua_createtable(globalconf.L, datalen, 0); \
 128                             for(int i = 0; i < datalen; i++) \
 129                             { \
 130                                 lua_pushnumber(globalconf.L, data[i]); \
 131                                 lua_rawseti(globalconf.L, -2, i + 1); \
 132                             } \
 133                         } \
 134                         break;
 135                       DBUS_MSG_HANDLE_ARRAY_TYPE_NUMBER(int16_t, DBUS_TYPE_INT16)
 136                       DBUS_MSG_HANDLE_ARRAY_TYPE_NUMBER(uint16_t, DBUS_TYPE_UINT16)
 137                       DBUS_MSG_HANDLE_ARRAY_TYPE_NUMBER(int32_t, DBUS_TYPE_INT32)
 138                       DBUS_MSG_HANDLE_ARRAY_TYPE_NUMBER(uint32_t, DBUS_TYPE_UINT32)
 139                       DBUS_MSG_HANDLE_ARRAY_TYPE_NUMBER(int64_t, DBUS_TYPE_INT64)
 140                       DBUS_MSG_HANDLE_ARRAY_TYPE_NUMBER(uint64_t, DBUS_TYPE_UINT64)
 141                       DBUS_MSG_HANDLE_ARRAY_TYPE_NUMBER(double, DBUS_TYPE_DOUBLE)
 142 #undef DBUS_MSG_HANDLE_ARRAY_TYPE_NUMBER
 143                       case DBUS_TYPE_BYTE:
 144                         {
 145                             const char *c;
 146                             dbus_message_iter_get_fixed_array(&sub, &c, &datalen);
 147                             lua_pushlstring(globalconf.L, c, datalen);
 148                         }
 149                         break;
 150                       case DBUS_TYPE_BOOLEAN:
 151                         {
 152                             const dbus_bool_t *b;
 153                             dbus_message_iter_get_fixed_array(&sub, &b, &datalen);
 154                             lua_createtable(globalconf.L, datalen, 0);
 155                             for(int i = 0; i < datalen; i++)
 156                             {
 157                                 lua_pushboolean(globalconf.L, b[i]);
 158                                 lua_rawseti(globalconf.L, -2, i + 1);
 159                             }
 160                         }
 161                         break;
 162                     }
 163                 }
 164                 else if(array_type == DBUS_TYPE_DICT_ENTRY)
 165                 {
 166                     DBusMessageIter subiter;
 167                     /* initialize a sub iterator */
 168                     dbus_message_iter_recurse(iter, &subiter);
 169
 170                     /* get the keys and the values
 171                      * n is the number of entry in dict */
 172                     int n = a_dbus_message_iter(&subiter);
 173
 174                     /* create a new table to store all the value */
 175                     lua_createtable(globalconf.L, n, 0);
 176                     /* move the table before array elements */
 177                     lua_insert(globalconf.L, - (n * 2) - 1);
 178
 179                     for(int i = 0; i < n; i ++)
 180                         lua_rawset(globalconf.L, - (n * 2) - 1 + i * 2);
 181                 }
 182                 else
 183                 {
 184                     DBusMessageIter subiter;
 185                     /* prepare to dig into the array*/
 186                     dbus_message_iter_recurse(iter, &subiter);
 187
 188                     /* now iterate over every element of the array */
 189                     int n = a_dbus_message_iter(&subiter);
 190
 191                     /* create a new table to store all the value */
 192                     lua_createtable(globalconf.L, n, 0);
 193                     /* move the table before array elements */
 194                     lua_insert(globalconf.L, - n - 1);
 195
 196                     for(int i = n; i > 0; i--)
 197                         lua_rawseti(globalconf.L, - i - 1, i);
 198                 }
 199             }
 200             nargs++;
 201             break;
 202           case DBUS_TYPE_BOOLEAN:
 203             {
 204                 dbus_bool_t b;
 205                 dbus_message_iter_get_basic(iter, &b);
 206                 lua_pushboolean(globalconf.L, b);
 207             }
 208             nargs++;
 209             break;
 210           case DBUS_TYPE_BYTE:
 211             {
 212                 char c;
 213                 dbus_message_iter_get_basic(iter, &c);
 214                 lua_pushlstring(globalconf.L, &c, 1);
 215             }
 216             nargs++;
 217             break;
 218 #define DBUS_MSG_HANDLE_TYPE_NUMBER(type, dbustype) \
 219           case dbustype: \
 220             { \
 221                 type ui; \
 222                 dbus_message_iter_get_basic(iter, &ui); \
 223                 lua_pushnumber(globalconf.L, ui); \
 224             } \
 225             nargs++; \
 226             break;
 227           DBUS_MSG_HANDLE_TYPE_NUMBER(int16_t, DBUS_TYPE_INT16)
 228           DBUS_MSG_HANDLE_TYPE_NUMBER(uint16_t, DBUS_TYPE_UINT16)
 229           DBUS_MSG_HANDLE_TYPE_NUMBER(int32_t, DBUS_TYPE_INT32)
 230           DBUS_MSG_HANDLE_TYPE_NUMBER(uint32_t, DBUS_TYPE_UINT32)
 231           DBUS_MSG_HANDLE_TYPE_NUMBER(int64_t, DBUS_TYPE_INT64)
 232           DBUS_MSG_HANDLE_TYPE_NUMBER(uint64_t, DBUS_TYPE_UINT64)
 233 #undef DBUS_MSG_HANDLE_TYPE_NUMBER
 234           case DBUS_TYPE_STRING:
 235             {
 236                 char *s;
 237                 dbus_message_iter_get_basic(iter, &s);
 238                 lua_pushstring(globalconf.L, s);
 239             }
 240             nargs++;
 241             break;
 242         }
 243     } while(dbus_message_iter_next(iter));
 244
 245     return nargs;
 246 }
 247
 248 static void
 249 a_dbus_process_request(DBusConnection *dbus_connection, DBusMessage *msg)
 250 {
 251     if(globalconf.hooks.dbus == LUA_REFNIL)
 252         return;
 253
 254     lua_createtable(globalconf.L, 0, 5);
 255
 256     switch(dbus_message_get_type(msg))
 257     {
 258       case DBUS_MESSAGE_TYPE_SIGNAL:
 259         lua_pushliteral(globalconf.L, "signal");
 260         break;
 261       case DBUS_MESSAGE_TYPE_METHOD_CALL:
 262         lua_pushliteral(globalconf.L, "method_call");
 263         break;
 264       case DBUS_MESSAGE_TYPE_METHOD_RETURN:
 265         lua_pushliteral(globalconf.L, "method_return");
 266         break;
 267       case DBUS_MESSAGE_TYPE_ERROR:
 268         lua_pushliteral(globalconf.L, "error");
 269         break;
 270       default:
 271         lua_pushliteral(globalconf.L, "unknown");
 272         break;
 273     }
 274
 275     lua_setfield(globalconf.L, -2, "type");
 276
 277     const char *s = dbus_message_get_interface(msg);
 278     lua_pushstring(globalconf.L, NONULL(s));
 279     lua_setfield(globalconf.L, -2, "interface");
 280
 281     s = dbus_message_get_path(msg);
 282     lua_pushstring(globalconf.L, NONULL(s));
 283     lua_setfield(globalconf.L, -2, "path");
 284
 285     s = dbus_message_get_member(msg);
 286     lua_pushstring(globalconf.L, NONULL(s));
 287     lua_setfield(globalconf.L, -2, "member");
 288
 289     if(dbus_connection == dbus_connection_system)
 290         lua_pushliteral(globalconf.L, "system");
 291     else
 292         lua_pushliteral(globalconf.L, "session");
 293     lua_setfield(globalconf.L, -2, "bus");
 294
 295     /* + 1 for the table above */
 296     DBusMessageIter iter;
 297     int nargs = 1;
 298
 299     if(dbus_message_iter_init(msg, &iter))
 300         nargs += a_dbus_message_iter(&iter);
 301
 302     if(dbus_message_get_no_reply(msg))
 303         luaA_dofunction(globalconf.L, globalconf.hooks.dbus, nargs, 0);
 304     else
 305     {
 306         int n = lua_gettop(globalconf.L) - nargs;
 307         luaA_dofunction(globalconf.L, globalconf.hooks.dbus, nargs, LUA_MULTRET);
 308         n -= lua_gettop(globalconf.L);
 309
 310         DBusMessage *reply = dbus_message_new_method_return(msg);
 311
 312         dbus_message_iter_init_append(reply, &iter);
 313
 314         /* i is negative */
 315         for(int i = n; i < 0; i += 2)
 316         {
 317             /* i is the type name, i+1 the value */
 318             size_t len;
 319             const char *type = lua_tolstring(globalconf.L, i, &len);
 320
 321             if(!type || len != 1)
 322                 break;
 323
 324             switch(*type)
 325             {
 326               case DBUS_TYPE_BOOLEAN:
 327                 {
 328                     dbus_bool_t  b = lua_toboolean(globalconf.L, i + 1);
 329                     dbus_message_iter_append_basic(&iter, DBUS_TYPE_BOOLEAN, &b);
 330                 }
 331                 break;
 332 #define DBUS_MSG_RETURN_HANDLE_TYPE_STRING(dbustype) \
 333               case dbustype: \
 334                 if((s = lua_tostring(globalconf.L, i + 1))) \
 335                     dbus_message_iter_append_basic(&iter, dbustype, &s); \
 336                 break;
 337               DBUS_MSG_RETURN_HANDLE_TYPE_STRING(DBUS_TYPE_STRING)
 338               DBUS_MSG_RETURN_HANDLE_TYPE_STRING(DBUS_TYPE_BYTE)
 339 #undef DBUS_MSG_RETURN_HANDLE_TYPE_STRING
 340 #define DBUS_MSG_RETURN_HANDLE_TYPE_NUMBER(type, dbustype) \
 341               case dbustype: \
 342                 { \
 343                     type num = lua_tonumber(globalconf.L, i + 1); \
 344                     dbus_message_iter_append_basic(&iter, dbustype, &num); \
 345                 } \
 346                 break;
 347               DBUS_MSG_RETURN_HANDLE_TYPE_NUMBER(int16_t, DBUS_TYPE_INT16)
 348               DBUS_MSG_RETURN_HANDLE_TYPE_NUMBER(uint16_t, DBUS_TYPE_UINT16)
 349               DBUS_MSG_RETURN_HANDLE_TYPE_NUMBER(int32_t, DBUS_TYPE_INT32)
 350               DBUS_MSG_RETURN_HANDLE_TYPE_NUMBER(uint32_t, DBUS_TYPE_UINT32)
 351               DBUS_MSG_RETURN_HANDLE_TYPE_NUMBER(int64_t, DBUS_TYPE_INT64)
 352               DBUS_MSG_RETURN_HANDLE_TYPE_NUMBER(uint64_t, DBUS_TYPE_UINT64)
 353               DBUS_MSG_RETURN_HANDLE_TYPE_NUMBER(double, DBUS_TYPE_DOUBLE)
 354 #undef DBUS_MSG_RETURN_HANDLE_TYPE_NUMBER
 355             }
 356
 357             lua_remove(globalconf.L, i);
 358             lua_remove(globalconf.L, i + 1);
 359         }
 360
 361         dbus_connection_send(dbus_connection, reply, NULL);
 362         dbus_message_unref(reply);
 363     }
 364 }
 365
 366 static void
 367 a_dbus_process_requests_on_bus(DBusConnection *dbus_connection, ev_io *dbusio)
 368 {
 369     DBusMessage *msg;
 370     int nmsg = 0;
 371
 372     while(true)
 373     {
 374         dbus_connection_read_write(dbus_connection, 0);
 375
 376         if(!(msg = dbus_connection_pop_message(dbus_connection)))
 377             break;
 378
 379         if(dbus_message_is_signal(msg, DBUS_INTERFACE_LOCAL, "Disconnected"))
 380         {
 381             a_dbus_cleanup_bus(dbus_connection, dbusio);
 382             dbus_message_unref(msg);
 383             return;
 384         }
 385         else
 386             a_dbus_process_request(dbus_connection, msg);
 387
 388         dbus_message_unref(msg);
 389
 390         nmsg++;
 391     }
 392
 393     if(nmsg)
 394         dbus_connection_flush(dbus_connection);
 395
 396     awesome_refresh();
 397 }
 398
 399 static void
 400 a_dbus_process_requests_session(EV_P_ ev_io *w, int revents)
 401 {
 402     a_dbus_process_requests_on_bus(dbus_connection_session, w);
 403 }
 404
 405 static void
 406 a_dbus_process_requests_system(EV_P_ ev_io *w, int revents)
 407 {
 408     a_dbus_process_requests_on_bus(dbus_connection_system, w);
 409 }
 410
 411 static bool
 412 a_dbus_request_name(DBusConnection *dbus_connection, const char *name)
 413 {
 414     DBusError err;
 415
 416     if(!dbus_connection)
 417         return false;
 418
 419     dbus_error_init(&err);
 420
 421     int ret = dbus_bus_request_name(dbus_connection, name, 0, &err);
 422
 423     if(dbus_error_is_set(&err))
 424     {
 425         warn("failed to request D-Bus name: %s", err.message);
 426         dbus_error_free(&err);
 427         return false;
 428     }
 429
 430     switch(ret)
 431     {
 432       case DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER:
 433         return true;
 434       case DBUS_REQUEST_NAME_REPLY_ALREADY_OWNER:
 435         warn("already primary D-Bus name owner for %s", name);
 436         return true;
 437     }
 438     return false;
 439 }
 440
 441 static bool
 442 a_dbus_release_name(DBusConnection *dbus_connection, const char *name)
 443 {
 444     DBusError err;
 445
 446     if(!dbus_connection)
 447         return false;
 448
 449     dbus_error_init(&err);
 450
 451     int ret = dbus_bus_release_name(dbus_connection, name, &err);
 452
 453     if(dbus_error_is_set(&err))
 454     {
 455         warn("failed to release D-Bus name: %s", err.message);
 456         dbus_error_free(&err);
 457         return false;
 458     }
 459
 460     switch(ret)
 461     {
 462       case DBUS_RELEASE_NAME_REPLY_NOT_OWNER:
 463         warn("not primary D-Bus name owner for %s", name);
 464         return false;
 465       case DBUS_RELEASE_NAME_REPLY_NON_EXISTENT:
 466         warn("non existent D-Bus name: %s", name);
 467         return false;
 468     }
 469     return true;
 470 }
 471
 472 static DBusConnection *
 473 a_dbus_connect(DBusBusType type, const char *type_name,
 474                ev_io *dbusio, void *cb)
 475 {
 476     int fd;
 477     DBusConnection *dbus_connection;
 478     DBusError err;
 479
 480     dbus_error_init(&err);
 481
 482     dbus_connection = dbus_bus_get(type, &err);
 483     if(dbus_error_is_set(&err))
 484     {
 485         warn("D-Bus session bus %s failed: %s", type_name, err.message);
 486         dbus_connection = NULL;
 487         dbus_error_free(&err);
 488     }
 489     else
 490     {
 491         if(dbus_connection_get_unix_fd(dbus_connection, &fd))
 492         {
 493             fcntl(fd, F_SETFD, FD_CLOEXEC);
 494
 495             ev_io_init(dbusio, cb, fd, EV_READ);
 496             ev_io_start(EV_DEFAULT_UC_ dbusio);
 497             ev_unref(EV_DEFAULT_UC);
 498         }
 499         else
 500         {
 501             warn("cannot get D-Bus connection file descriptor");
 502             a_dbus_cleanup_bus(dbus_connection, dbusio);
 503         }
 504     }
 505
 506     return dbus_connection;
 507 }
 508
 509 void
 510 a_dbus_init(void)
 511 {
 512     dbus_connection_session = a_dbus_connect(DBUS_BUS_SESSION, "session",
 513                                              &dbusio_ses, a_dbus_process_requests_session);
 514     dbus_connection_system = a_dbus_connect(DBUS_BUS_SYSTEM, "system",
 515                                             &dbusio_sys, a_dbus_process_requests_system);
 516 }
 517
 518 void
 519 a_dbus_cleanup(void)
 520 {
 521     a_dbus_cleanup_bus(dbus_connection_session, &dbusio_ses);
 522     a_dbus_cleanup_bus(dbus_connection_system, &dbusio_sys);
 523 }
 524
 525 static DBusConnection *
 526 a_dbus_bus_getbyname(const char *name, size_t len)
 527 {
 528     switch(a_tokenize(name, len))
 529     {
 530       case A_TK_SYSTEM:
 531         return dbus_connection_system;
 532       case A_TK_SESSION:
 533         return dbus_connection_session;
 534       default:
 535         return NULL;
 536     }
 537 }
 538
 539 /** Register a D-Bus name to receive message from.
 540  * \param L The Lua VM state.
 541  * \return The number of elements pushed on stack.
 542  * \luastack
 543  * \lparam A string indicating if we are using system or session bus.
 544  * \lparam A string with the name of the D-Bus name to register. Note that
 545  * org.awesome is registered by default.
 546  * \lreturn True if everything worked fine, false otherwise.
 547  */
 548 static int
 549 luaA_dbus_request_name(lua_State *L)
 550 {
 551     size_t len;
 552     const char *bus = luaL_checklstring(L, 1, &len);
 553     const char *name = luaL_checkstring(L, 2);
 554     DBusConnection *dbus_connection = a_dbus_bus_getbyname(bus, len);
 555     lua_pushboolean(L, a_dbus_request_name(dbus_connection, name));
 556     return 1;
 557 }
 558
 559 /** Release a D-Bus name.
 560  * \param L The Lua VM state.
 561  * \return The number of elements pushed on stack.
 562  * \luastack
 563  * \lparam A string indicating if we are using system or session bus.
 564  * \lparam A string with the name of the D-Bus name to unregister.
 565  * \lreturn True if everything worked fine, false otherwise.
 566  */
 567 static int
 568 luaA_dbus_release_name(lua_State *L)
 569 {
 570     size_t len;
 571     const char *bus = luaL_checklstring(L, 1, &len);
 572     const char *name = luaL_checkstring(L, 2);
 573     DBusConnection *dbus_connection = a_dbus_bus_getbyname(bus, len);
 574     lua_pushboolean(L, a_dbus_release_name(dbus_connection, name));
 575     return 1;
 576 }
 577
 578 /** Add a match rule to match messages going through the message bus.
 579  * \param L The Lua VM state.
 580  * \return The number of elements pushed on stack.
 581  * \luastack
 582  * \lparam A string indicating if we are using system or session bus.
 583  * \lparam A string with the name of the match rule.
 584  */
 585 static int
 586 luaA_dbus_add_match(lua_State *L)
 587 {
 588     size_t len;
 589     const char *bus = luaL_checklstring(L, 1, &len);
 590     const char *name = luaL_checkstring(L, 2);
 591     DBusConnection *dbus_connection = a_dbus_bus_getbyname(bus, len);
 592
 593     if(dbus_connection)
 594     {
 595         dbus_bus_add_match(dbus_connection, name, NULL);
 596         dbus_connection_flush(dbus_connection);
 597     }
 598
 599     return 0;
 600 }
 601
 602 /** Remove a previously added match rule "by value"
 603  * (the most recently-added identical rule gets removed).
 604  * \param L The Lua VM state.
 605  * \return The number of elements pushed on stack.
 606  * \luastack
 607  * \lparam A string indicating if we are using system or session bus.
 608  * \lparam A string with the name of the match rule.
 609  */
 610 static int
 611 luaA_dbus_remove_match(lua_State *L)
 612 {
 613     size_t len;
 614     const char *bus = luaL_checklstring(L, 1, &len);
 615     const char *name = luaL_checkstring(L, 2);
 616     DBusConnection *dbus_connection = a_dbus_bus_getbyname(bus, len);
 617
 618     if(dbus_connection)
 619     {
 620         dbus_bus_remove_match(dbus_connection, name, NULL);
 621         dbus_connection_flush(dbus_connection);
 622     }
 623
 624     return 0;
 625 }
 626
 627 const struct luaL_reg awesome_dbus_lib[] =
 628 {
 629     { "request_name", luaA_dbus_request_name },
 630     { "release_name", luaA_dbus_release_name },
 631     { "add_match", luaA_dbus_add_match },
 632     { "remove_match", luaA_dbus_remove_match },
 633     { NULL, NULL }
 634 };
 635
 636 #else /* HAVE_DBUS */
 637
 638 void
 639 a_dbus_init(void)
 640 {
 641 }
 642
 643 void
 644 a_dbus_cleanup(void)
 645 {
 646 }
 647
 648 #endif
 649 // vim: filetype=c:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=80