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_from_registry(globalconf.L, globalconf.hooks.dbus, nargs, 0);
 304     else
 305     {
 306         int n = lua_gettop(globalconf.L) - nargs;
 307         luaA_dofunction_from_registry(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
 397 static void
 398 a_dbus_process_requests_session(EV_P_ ev_io *w, int revents)
 399 {
 400     a_dbus_process_requests_on_bus(dbus_connection_session, w);
 401 }
 402
 403 static void
 404 a_dbus_process_requests_system(EV_P_ ev_io *w, int revents)
 405 {
 406     a_dbus_process_requests_on_bus(dbus_connection_system, w);
 407 }
 408
 409 static bool
 410 a_dbus_request_name(DBusConnection *dbus_connection, const char *name)
 411 {
 412     DBusError err;
 413
 414     if(!dbus_connection)
 415         return false;
 416
 417     dbus_error_init(&err);
 418
 419     int ret = dbus_bus_request_name(dbus_connection, name, 0, &err);
 420
 421     if(dbus_error_is_set(&err))
 422     {
 423         warn("failed to request D-Bus name: %s", err.message);
 424         dbus_error_free(&err);
 425         return false;
 426     }
 427
 428     switch(ret)
 429     {
 430       case DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER:
 431         return true;
 432       case DBUS_REQUEST_NAME_REPLY_ALREADY_OWNER:
 433         warn("already primary D-Bus name owner for %s", name);
 434         return true;
 435     }
 436     return false;
 437 }
 438
 439 static bool
 440 a_dbus_release_name(DBusConnection *dbus_connection, const char *name)
 441 {
 442     DBusError err;
 443
 444     if(!dbus_connection)
 445         return false;
 446
 447     dbus_error_init(&err);
 448
 449     int ret = dbus_bus_release_name(dbus_connection, name, &err);
 450
 451     if(dbus_error_is_set(&err))
 452     {
 453         warn("failed to release D-Bus name: %s", err.message);
 454         dbus_error_free(&err);
 455         return false;
 456     }
 457
 458     switch(ret)
 459     {
 460       case DBUS_RELEASE_NAME_REPLY_NOT_OWNER:
 461         warn("not primary D-Bus name owner for %s", name);
 462         return false;
 463       case DBUS_RELEASE_NAME_REPLY_NON_EXISTENT:
 464         warn("non existent D-Bus name: %s", name);
 465         return false;
 466     }
 467     return true;
 468 }
 469
 470 static DBusConnection *
 471 a_dbus_connect(DBusBusType type, const char *type_name,
 472                ev_io *dbusio, void *cb)
 473 {
 474     int fd;
 475     DBusConnection *dbus_connection;
 476     DBusError err;
 477
 478     dbus_error_init(&err);
 479
 480     dbus_connection = dbus_bus_get(type, &err);
 481     if(dbus_error_is_set(&err))
 482     {
 483         warn("D-Bus session bus %s failed: %s", type_name, err.message);
 484         dbus_connection = NULL;
 485         dbus_error_free(&err);
 486     }
 487     else
 488     {
 489         dbus_connection_set_exit_on_disconnect(dbus_connection, false);
 490         if(dbus_connection_get_unix_fd(dbus_connection, &fd))
 491         {
 492             fcntl(fd, F_SETFD, FD_CLOEXEC);
 493
 494             ev_io_init(dbusio, cb, fd, EV_READ);
 495             ev_io_start(EV_DEFAULT_UC_ dbusio);
 496             ev_unref(EV_DEFAULT_UC);
 497         }
 498         else
 499         {
 500             warn("cannot get D-Bus connection file descriptor");
 501             a_dbus_cleanup_bus(dbus_connection, dbusio);
 502         }
 503     }
 504
 505     return dbus_connection;
 506 }
 507
 508 void
 509 a_dbus_init(void)
 510 {
 511     dbus_connection_session = a_dbus_connect(DBUS_BUS_SESSION, "session",
 512                                              &dbusio_ses, a_dbus_process_requests_session);
 513     dbus_connection_system = a_dbus_connect(DBUS_BUS_SYSTEM, "system",
 514                                             &dbusio_sys, a_dbus_process_requests_system);
 515 }
 516
 517 void
 518 a_dbus_cleanup(void)
 519 {
 520     a_dbus_cleanup_bus(dbus_connection_session, &dbusio_ses);
 521     a_dbus_cleanup_bus(dbus_connection_system, &dbusio_sys);
 522 }
 523
 524 static DBusConnection *
 525 a_dbus_bus_getbyname(const char *name, size_t len)
 526 {
 527     switch(a_tokenize(name, len))
 528     {
 529       case A_TK_SYSTEM:
 530         return dbus_connection_system;
 531       case A_TK_SESSION:
 532         return dbus_connection_session;
 533       default:
 534         return NULL;
 535     }
 536 }
 537
 538 /** Register a D-Bus name to receive message from.
 539  * \param L The Lua VM state.
 540  * \return The number of elements pushed on stack.
 541  * \luastack
 542  * \lparam A string indicating if we are using system or session bus.
 543  * \lparam A string with the name of the D-Bus name to register.
 544  * \lreturn True if everything worked fine, false otherwise.
 545  */
 546 static int
 547 luaA_dbus_request_name(lua_State *L)
 548 {
 549     size_t len;
 550     const char *bus = luaL_checklstring(L, 1, &len);
 551     const char *name = luaL_checkstring(L, 2);
 552     DBusConnection *dbus_connection = a_dbus_bus_getbyname(bus, len);
 553     lua_pushboolean(L, a_dbus_request_name(dbus_connection, name));
 554     return 1;
 555 }
 556
 557 /** Release a D-Bus name.
 558  * \param L The Lua VM state.
 559  * \return The number of elements pushed on stack.
 560  * \luastack
 561  * \lparam A string indicating if we are using system or session bus.
 562  * \lparam A string with the name of the D-Bus name to unregister.
 563  * \lreturn True if everything worked fine, false otherwise.
 564  */
 565 static int
 566 luaA_dbus_release_name(lua_State *L)
 567 {
 568     size_t len;
 569     const char *bus = luaL_checklstring(L, 1, &len);
 570     const char *name = luaL_checkstring(L, 2);
 571     DBusConnection *dbus_connection = a_dbus_bus_getbyname(bus, len);
 572     lua_pushboolean(L, a_dbus_release_name(dbus_connection, name));
 573     return 1;
 574 }
 575
 576 /** Add a match rule to match messages going through the message bus.
 577  * \param L The Lua VM state.
 578  * \return The number of elements pushed on stack.
 579  * \luastack
 580  * \lparam A string indicating if we are using system or session bus.
 581  * \lparam A string with the name of the match rule.
 582  */
 583 static int
 584 luaA_dbus_add_match(lua_State *L)
 585 {
 586     size_t len;
 587     const char *bus = luaL_checklstring(L, 1, &len);
 588     const char *name = luaL_checkstring(L, 2);
 589     DBusConnection *dbus_connection = a_dbus_bus_getbyname(bus, len);
 590
 591     if(dbus_connection)
 592     {
 593         dbus_bus_add_match(dbus_connection, name, NULL);
 594         dbus_connection_flush(dbus_connection);
 595     }
 596
 597     return 0;
 598 }
 599
 600 /** Remove a previously added match rule "by value"
 601  * (the most recently-added identical rule gets removed).
 602  * \param L The Lua VM state.
 603  * \return The number of elements pushed on stack.
 604  * \luastack
 605  * \lparam A string indicating if we are using system or session bus.
 606  * \lparam A string with the name of the match rule.
 607  */
 608 static int
 609 luaA_dbus_remove_match(lua_State *L)
 610 {
 611     size_t len;
 612     const char *bus = luaL_checklstring(L, 1, &len);
 613     const char *name = luaL_checkstring(L, 2);
 614     DBusConnection *dbus_connection = a_dbus_bus_getbyname(bus, len);
 615
 616     if(dbus_connection)
 617     {
 618         dbus_bus_remove_match(dbus_connection, name, NULL);
 619         dbus_connection_flush(dbus_connection);
 620     }
 621
 622     return 0;
 623 }
 624
 625 const struct luaL_reg awesome_dbus_lib[] =
 626 {
 627     { "request_name", luaA_dbus_request_name },
 628     { "release_name", luaA_dbus_release_name },
 629     { "add_match", luaA_dbus_add_match },
 630     { "remove_match", luaA_dbus_remove_match },
 631     { NULL, NULL }
 632 };
 633
 634 #else /* HAVE_DBUS */
 635
 636 void
 637 a_dbus_init(void)
 638 {
 639 }
 640
 641 void
 642 a_dbus_cleanup(void)
 643 {
 644 }
 645
 646 #endif
 647 // vim: filetype=c:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=80