common/JackMetadata.cpp

   1 /*
   2   Copyright (C) 2011 David Robillard
   3   Copyright (C) 2013 Paul Davis
   4
   5   This program is free software; you can redistribute it and/or modify it
   6   under the terms of the GNU Lesser General Public License as published by
   7   the Free Software Foundation; either version 2.1 of the License, or (at
   8   your option) any later version.
   9
  10   This program is distributed in the hope that it will be useful, but WITHOUT
  11   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
  13   License for more details.
  14
  15   You should have received a copy of the GNU Lesser General Public License
  16   along with this program; if not, write to the Free Software Foundation,
  17   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18 */
  19
  20 #include "JackMetadata.h"
  21
  22 #include "JackClient.h"
  23
  24 #include <string.h>
  25 #include <limits.h>
  26
  27
  28 LIB_EXPORT const char* JACK_METADATA_PRETTY_NAME = "http://jackaudio.org/metadata/pretty-name";
  29 LIB_EXPORT const char* JACK_METADATA_HARDWARE = "http://jackaudio.org/metadata/hardware";
  30 LIB_EXPORT const char* JACK_METADATA_CONNECTED = "http://jackaudio.org/metadata/connected";
  31 LIB_EXPORT const char* JACK_METADATA_PORT_GROUP = "http://jackaudio.org/metadata/port-group";
  32 LIB_EXPORT const char* JACK_METADATA_ICON_SMALL = "http://jackaudio.org/metadata/icon-small";
  33 LIB_EXPORT const char* JACK_METADATA_ICON_LARGE = "http://jackaudio.org/metadata/icon-large";
  34
  35
  36 namespace Jack
  37 {
  38
  39 JackMetadata::JackMetadata(const char* server_name)
  40 #if HAVE_DB
  41     : fDB(NULL), fDBenv(NULL)
  42 #endif
  43 {
  44     PropertyInit(server_name);
  45 }
  46
  47 JackMetadata::~JackMetadata()
  48 {
  49 #if HAVE_DB
  50     if (fDB) {
  51         fDB->close (fDB, 0);
  52         fDB = NULL;
  53     }
  54     if (fDBenv) {
  55         fDBenv->close (fDBenv, 0);
  56         fDBenv = 0;
  57     }
  58 #endif
  59 }
  60
  61 int JackMetadata::PropertyInit(const char* server_name)
  62 {
  63 #if HAVE_DB
  64
  65     int ret;
  66     char dbpath[PATH_MAX + 1];
  67
  68     /* idempotent */
  69
  70     if (fDBenv) {
  71         return 0;
  72     }
  73
  74     if ((ret = db_env_create (&fDBenv, 0)) != 0) {
  75         jack_error ("cannot initialize DB environment: %s\n", db_strerror (ret));
  76         return -1;
  77     }
  78
  79     if ((ret = fDBenv->open (fDBenv, jack_server_dir /*FIXME:(server_name, server_dir)*/, DB_CREATE | DB_INIT_LOCK | DB_INIT_MPOOL | DB_THREAD, 0)) != 0) {
  80         jack_error ("cannot open DB environment: %s", db_strerror (ret));
  81         return -1;
  82     }
  83
  84     if ((ret = db_create (&fDB, fDBenv, 0)) != 0) {
  85         jack_error ("Cannot initialize metadata DB (%s)", db_strerror (ret));
  86         return -1;
  87     }
  88
  89     snprintf (dbpath, sizeof(dbpath), "%s/%s", jack_server_dir /*FIXME:(server_name, server_dir)*/, "metadata.db");
  90
  91     if ((ret = fDB->open (fDB, NULL, dbpath, NULL, DB_HASH, DB_CREATE | DB_THREAD, 0666)) != 0) {
  92         jack_error ("Cannot open metadata DB at %s: %s", dbpath, db_strerror (ret));
  93         fDB->close (fDB, 0);
  94         fDB = NULL;
  95         return -1;
  96     }
  97
  98     return 0;
  99
 100 #else // !HAVE_DB
 101     return -1;
 102 #endif
 103 }
 104
 105 int JackMetadata::PropertyChangeNotify(JackClient* client, jack_uuid_t subject, const char* key, jack_property_change_t change)
 106 {
 107     /* the engine passes in a NULL client when it removes metadata during port or client removal
 108      */
 109
 110     if (client == NULL) {
 111         return 0;
 112     }
 113
 114     return client->PropertyChangeNotify(subject, key, change);
 115 }
 116
 117 #if HAVE_DB
 118 void JackMetadata::MakeKeyDbt(DBT* dbt, jack_uuid_t subject, const char* key)
 119 {
 120     char ustr[JACK_UUID_STRING_SIZE];
 121     size_t len1, len2;
 122
 123     memset (dbt, 0, sizeof(DBT));
 124     memset (ustr, 0, JACK_UUID_STRING_SIZE);
 125     jack_uuid_unparse (subject, ustr);
 126     len1 = JACK_UUID_STRING_SIZE;
 127     len2 = strlen (key) + 1;
 128     dbt->size = len1 + len2;
 129     dbt->data = malloc (dbt->size);
 130     memcpy (dbt->data, ustr, len1);         // copy subject+null
 131     memcpy ((char *)dbt->data + len1, key, len2);   // copy key+null
 132 }
 133 #endif
 134
 135 int JackMetadata::SetProperty(JackClient* client, jack_uuid_t subject, const char* key, const char* value, const char* type)
 136 {
 137 #if HAVE_DB
 138
 139     DBT d_key;
 140     DBT data;
 141     int ret;
 142     size_t len1, len2;
 143     jack_property_change_t change;
 144
 145     if (!key || key[0] == '\0') {
 146         jack_error ("empty key string for metadata not allowed");
 147         return -1;
 148     }
 149
 150     if (!value || value[0] == '\0') {
 151         jack_error ("empty value string for metadata not allowed");
 152         return -1;
 153     }
 154
 155     if (PropertyInit(NULL)) {
 156         return -1;
 157     }
 158
 159     /* build a key */
 160
 161     MakeKeyDbt(&d_key, subject, key);
 162
 163     /* build data */
 164
 165     memset (&data, 0, sizeof(data));
 166
 167     len1 = strlen (value) + 1;
 168     if (type && type[0] != '\0') {
 169         len2 = strlen (type) + 1;
 170     } else {
 171         len2 = 0;
 172     }
 173
 174     data.size = len1 + len2;
 175     data.data = malloc (data.size);
 176     memcpy (data.data, value, len1);
 177
 178     if (len2) {
 179         memcpy ((char *)data.data + len1, type, len2);
 180     }
 181
 182     if (fDB->exists (fDB, NULL, &d_key, 0) == DB_NOTFOUND) {
 183         change = PropertyCreated;
 184     } else {
 185         change = PropertyChanged;
 186     }
 187
 188     if ((ret = fDB->put (fDB, NULL, &d_key, &data, 0)) != 0) {
 189         char ustr[JACK_UUID_STRING_SIZE];
 190         jack_uuid_unparse (subject, ustr);
 191         jack_error ("Cannot store metadata for %s/%s (%s)", ustr, key, db_strerror (ret));
 192         if (d_key.size > 0) {
 193             free (d_key.data);
 194         }
 195         if (data.size  > 0) {
 196             free (data.data);
 197         }
 198         return -1;
 199     }
 200
 201     PropertyChangeNotify(client, subject, key, change);
 202
 203     if (d_key.size > 0) {
 204         free (d_key.data);
 205     }
 206     if (data.size  > 0) {
 207         free (data.data);
 208     }
 209
 210     return 0;
 211
 212 #else // !HAVE_DB
 213     return -1;
 214 #endif
 215 }
 216
 217 int JackMetadata::GetProperty(jack_uuid_t subject, const char* key, char** value, char** type)
 218 {
 219 #if HAVE_DB
 220
 221     DBT d_key;
 222     DBT data;
 223     int ret;
 224     size_t len1, len2;
 225
 226     if (key == NULL || key[0] == '\0') {
 227         return -1;
 228     }
 229
 230     if (PropertyInit(NULL)) {
 231         return -1;
 232     }
 233
 234     /* build a key */
 235
 236     MakeKeyDbt(&d_key, subject, key);
 237
 238     /* setup data DBT */
 239
 240     memset (&data, 0, sizeof(data));
 241     data.flags = DB_DBT_MALLOC;
 242
 243     if ((ret = fDB->get (fDB, NULL, &d_key, &data, 0)) != 0) {
 244         if (ret != DB_NOTFOUND) {
 245             char ustr[JACK_UUID_STRING_SIZE];
 246             jack_uuid_unparse (subject, ustr);
 247             jack_error ("Cannot retrieve metadata for %s/%s (%s)", ustr, key, db_strerror (ret));
 248         }
 249         if (d_key.size > 0) {
 250             free (d_key.data);
 251         }
 252         if (data.size  > 0) {
 253             free (data.data);
 254         }
 255         return -1;
 256     }
 257
 258     /* result must have at least 1 char plus 1 null to be valid
 259        (old rule was:
 260          result must have at least 2 chars plus 2 nulls to be valid
 261        )
 262      */
 263
 264     if (data.size < 2) {
 265         if (d_key.size > 0) {
 266             free (d_key.data);
 267         }
 268         if (data.size  > 0) {
 269             free (data.data);
 270         }
 271         return -1;
 272     }
 273
 274     len1 = strlen ((const char*)data.data) + 1;
 275     (*value) = (char*)malloc (len1);
 276     memcpy (*value, data.data, len1);
 277
 278     if (len1 < data.size) {
 279         len2 = strlen ((const char*)data.data + len1) + 1;
 280
 281         (*type) = (char*)malloc (len2);
 282         memcpy (*type, (const char *)data.data + len1, len2);
 283     } else {
 284         /* no type specified, assume default */
 285         *type = NULL;
 286     }
 287
 288     if (d_key.size > 0) {
 289         free (d_key.data);
 290     }
 291     if (data.size  > 0) {
 292         free (data.data);
 293     }
 294
 295     return 0;
 296
 297 #else // !HAVE_DB
 298     return -1;
 299 #endif
 300 }
 301
 302 int JackMetadata::GetProperties(jack_uuid_t subject, jack_description_t* desc)
 303 {
 304 #if HAVE_DB
 305
 306     DBT key;
 307     DBT data;
 308     DBC* cursor;
 309     int ret;
 310     size_t len1, len2;
 311     size_t cnt = 0;
 312     char ustr[JACK_UUID_STRING_SIZE];
 313     size_t props_size = 0;
 314     jack_property_t* prop;
 315
 316     desc->properties = NULL;
 317     desc->property_cnt = 0;
 318
 319     memset (ustr, 0, JACK_UUID_STRING_SIZE);
 320     jack_uuid_unparse (subject, ustr);
 321
 322     if (PropertyInit(NULL)) {
 323         return -1;
 324     }
 325
 326
 327     if ((ret = fDB->cursor (fDB, NULL, &cursor, 0)) != 0) {
 328         jack_error ("Cannot create cursor for metadata search (%s)", db_strerror (ret));
 329         return -1;
 330     }
 331
 332     memset (&key, 0, sizeof(key));
 333     memset (&data, 0, sizeof(data));
 334     data.flags = DB_DBT_MALLOC;
 335
 336     while ((ret = cursor->get (cursor, &key, &data, DB_NEXT)) == 0) {
 337
 338         /* require 2 extra chars (data+null) for key,
 339            which is composed of UUID str plus a key name
 340          */
 341
 342         if (key.size < JACK_UUID_STRING_SIZE + 2) {
 343             /* if (key.size  > 0) free(key.data); */
 344             if (data.size > 0) {
 345                 free (data.data);
 346             }
 347             continue;
 348         }
 349
 350         if (memcmp (ustr, key.data, JACK_UUID_STRING_SIZE) != 0) {
 351             /* not relevant */
 352             /* if (key.size  > 0) free(key.data); */
 353             if (data.size > 0) {
 354                 free (data.data);
 355             }
 356             continue;
 357         }
 358
 359         /* result must have at least 1 char plus 1 null to be valid
 360            (old rule was:
 361              result must have at least 2 chars plus 2 nulls to be valid
 362            )
 363         */
 364
 365         if (data.size < 2) {
 366             /* if (key.size  > 0) free(key.data); */
 367             if (data.size > 0) {
 368                 free (data.data);
 369             }
 370             continue;
 371         }
 372
 373         /* realloc array if necessary */
 374
 375         if (cnt == props_size) {
 376             if (props_size == 0) {
 377                 props_size = 8; /* a rough guess at a likely upper bound for the number of properties */
 378             } else {
 379                 props_size *= 2;
 380             }
 381
 382             desc->properties = (jack_property_t*)realloc (desc->properties, sizeof(jack_property_t) * props_size);
 383         }
 384
 385         prop = &desc->properties[cnt];
 386
 387         /* store UUID/subject */
 388
 389         jack_uuid_copy (&desc->subject, subject);
 390
 391         /* copy key (without leading UUID as subject */
 392
 393         len1 = key.size - JACK_UUID_STRING_SIZE;
 394         prop->key = (char*)malloc (len1);
 395         memcpy ((char*)prop->key, (const char *)key.data + JACK_UUID_STRING_SIZE, len1);
 396
 397         /* copy data (which contains 1 or 2 null terminated strings, the value
 398            and optionally a MIME type.
 399          */
 400
 401         len1 = strlen ((const char*)data.data) + 1;
 402         prop->data = (char*)malloc (len1);
 403         memcpy ((char*)prop->data, data.data, len1);
 404
 405         if (len1 < data.size) {
 406             len2 = strlen ((const char *)data.data + len1) + 1;
 407
 408             prop->type = (char*)malloc (len2);
 409             memcpy ((char*)prop->type, (const char *)data.data + len1, len2);
 410         } else {
 411             /* no type specified, assume default */
 412             prop->type = NULL;
 413         }
 414
 415         /* if (key.size  > 0) free(key.data);  */
 416         if (data.size > 0) {
 417             free (data.data);
 418         }
 419
 420         ++cnt;
 421     }
 422
 423     cursor->close (cursor);
 424     desc->property_cnt = cnt;
 425
 426     return cnt;
 427
 428 #else // !HAVE_DB
 429     return -1;
 430 #endif
 431 }
 432
 433 int JackMetadata::GetAllProperties(jack_description_t** descriptions)
 434 {
 435 #if HAVE_DB
 436
 437     DBT key;
 438     DBT data;
 439     DBC* cursor;
 440     int ret;
 441     size_t dcnt = 0;
 442     size_t dsize = 0;
 443     size_t n = 0;
 444     jack_description_t* desc = NULL;
 445     jack_uuid_t uuid = JACK_UUID_EMPTY_INITIALIZER;
 446     jack_description_t* current_desc = NULL;
 447     jack_property_t* current_prop = NULL;
 448     size_t len1, len2;
 449
 450     if (PropertyInit(NULL)) {
 451         return -1;
 452     }
 453
 454     if ((ret = fDB->cursor (fDB, NULL, &cursor, 0)) != 0) {
 455         jack_error ("Cannot create cursor for metadata search (%s)", db_strerror (ret));
 456         return -1;
 457     }
 458
 459     memset (&key, 0, sizeof(key));
 460     memset (&data, 0, sizeof(data));
 461     data.flags = DB_DBT_MALLOC;
 462
 463     dsize = 8; /* initial guess at number of descriptions we need */
 464     dcnt = 0;
 465     desc = (jack_description_t*)malloc (dsize * sizeof(jack_description_t));
 466
 467     while ((ret = cursor->get (cursor, &key, &data, DB_NEXT)) == 0) {
 468
 469         /* require 2 extra chars (data+null) for key,
 470            which is composed of UUID str plus a key name
 471          */
 472
 473         if (key.size < JACK_UUID_STRING_SIZE + 2) {
 474             /* if (key.size  > 0) free(key.data);  */
 475             if (data.size > 0) {
 476                 free (data.data);
 477             }
 478             continue;
 479         }
 480
 481         if (jack_uuid_parse ((const char *)key.data, &uuid) != 0) {
 482             continue;
 483         }
 484
 485         /* do we have an existing description for this UUID */
 486
 487         for (n = 0; n < dcnt; ++n) {
 488             if (jack_uuid_compare (uuid, desc[n].subject) == 0) {
 489                 break;
 490             }
 491         }
 492
 493         if (n == dcnt) {
 494             /* we do not have an existing description, so grow the array */
 495
 496             if (dcnt == dsize) {
 497                 dsize *= 2;
 498                 desc = (jack_description_t*)realloc (desc, sizeof(jack_description_t) * dsize);
 499             }
 500
 501             /* initialize */
 502
 503             desc[n].property_size = 0;
 504             desc[n].property_cnt = 0;
 505             desc[n].properties = NULL;
 506
 507             /* set up UUID */
 508
 509             jack_uuid_copy (&desc[n].subject, uuid);
 510             dcnt++;
 511         }
 512
 513         current_desc = &desc[n];
 514
 515         /* see if there is room for the new property or if we need to realloc
 516          */
 517
 518         if (current_desc->property_cnt == current_desc->property_size) {
 519             if (current_desc->property_size == 0) {
 520                 current_desc->property_size = 8;
 521             } else {
 522                 current_desc->property_size *= 2;
 523             }
 524
 525             current_desc->properties = (jack_property_t*)realloc (current_desc->properties, sizeof(jack_property_t) * current_desc->property_size);
 526         }
 527
 528         current_prop = &current_desc->properties[current_desc->property_cnt++];
 529
 530         /* copy key (without leading UUID) */
 531
 532         len1 = key.size - JACK_UUID_STRING_SIZE;
 533         current_prop->key = (char*)malloc (len1);
 534         memcpy ((char*)current_prop->key, (const char *)key.data + JACK_UUID_STRING_SIZE, len1);
 535
 536         /* copy data (which contains 1 or 2 null terminated strings, the value
 537            and optionally a MIME type.
 538          */
 539
 540         len1 = strlen ((const char *)data.data) + 1;
 541         current_prop->data = (char*)malloc (len1);
 542         memcpy ((char*)current_prop->data, data.data, len1);
 543
 544         if (len1 < data.size) {
 545             len2 = strlen ((const char *)data.data + len1) + 1;
 546
 547             current_prop->type = (char*)malloc (len2);
 548             memcpy ((char*)current_prop->type, (const char *)data.data + len1, len2);
 549         } else {
 550             /* no type specified, assume default */
 551             current_prop->type = NULL;
 552         }
 553
 554         /* if (key.size  > 0) free(key.data);  */
 555         if (data.size > 0) {
 556             free (data.data);
 557         }
 558     }
 559
 560     cursor->close (cursor);
 561
 562     (*descriptions) = desc;
 563
 564     return dcnt;
 565
 566 #else // !HAVE_DB
 567     return -1;
 568 #endif
 569 }
 570
 571 int JackMetadata::GetDescription(jack_uuid_t subject, jack_description_t* desc)
 572 {
 573     return 0;
 574 }
 575
 576 int JackMetadata::GetAllDescriptions(jack_description_t** descs)
 577 {
 578     return 0;
 579 }
 580
 581 void JackMetadata::FreeDescription(jack_description_t* desc, int free_actual_description_too)
 582 {
 583     uint32_t n;
 584
 585     for (n = 0; n < desc->property_cnt; ++n) {
 586         free ((char*)desc->properties[n].key);
 587         free ((char*)desc->properties[n].data);
 588         if (desc->properties[n].type) {
 589             free ((char*)desc->properties[n].type);
 590         }
 591     }
 592
 593     free (desc->properties);
 594
 595     if (free_actual_description_too) {
 596         free (desc);
 597     }
 598 }
 599
 600 int JackMetadata::RemoveProperty(JackClient* client, jack_uuid_t subject, const char* key)
 601 {
 602 #if HAVE_DB
 603
 604     DBT d_key;
 605     int ret;
 606
 607     if (PropertyInit(NULL)) {
 608         return -1;
 609     }
 610
 611     MakeKeyDbt(&d_key, subject, key);
 612     if ((ret = fDB->del (fDB, NULL, &d_key, 0)) != 0) {
 613         jack_error ("Cannot delete key %s (%s)", key, db_strerror (ret));
 614         if (d_key.size > 0) {
 615             free (d_key.data);
 616         }
 617         return -1;
 618     }
 619
 620     PropertyChangeNotify(client, subject, key, PropertyDeleted);
 621
 622     if (d_key.size > 0) {
 623         free (d_key.data);
 624     }
 625
 626     return 0;
 627
 628 #else // !HAVE_DB
 629     return -1;
 630 #endif
 631 }
 632
 633 int JackMetadata::RemoveProperties(JackClient* client, jack_uuid_t subject)
 634 {
 635 #if HAVE_DB
 636
 637     DBT key;
 638     DBT data;
 639     DBC* cursor;
 640     int ret;
 641     char ustr[JACK_UUID_STRING_SIZE];
 642     int retval = 0;
 643     uint32_t cnt = 0;
 644
 645     memset (ustr, 0, JACK_UUID_STRING_SIZE);
 646     jack_uuid_unparse (subject, ustr);
 647
 648     if (PropertyInit(NULL)) {
 649         return -1;
 650     }
 651
 652     if ((ret = fDB->cursor (fDB, NULL, &cursor, 0)) != 0) {
 653         jack_error ("Cannot create cursor for metadata search (%s)", db_strerror (ret));
 654         return -1;
 655     }
 656
 657     memset (&key, 0, sizeof(key));
 658     memset (&data, 0, sizeof(data));
 659     data.flags = DB_DBT_MALLOC;
 660
 661     while ((ret = cursor->get (cursor, &key, &data, DB_NEXT)) == 0) {
 662
 663         /* require 2 extra chars (data+null) for key,
 664            which is composed of UUID str plus a key name
 665          */
 666
 667         if (key.size < JACK_UUID_STRING_SIZE + 2) {
 668             /* if (key.size  > 0) free(key.data); */
 669             if (data.size > 0) {
 670                 free (data.data);
 671             }
 672             continue;
 673         }
 674
 675         if (memcmp (ustr, key.data, JACK_UUID_STRING_SIZE) != 0) {
 676             /* not relevant */
 677             /* if (key.size  > 0) free(key.data); */
 678             if (data.size > 0) {
 679                 free (data.data);
 680             }
 681             continue;
 682         }
 683
 684         if ((ret = cursor->del (cursor, 0)) != 0) {
 685             jack_error ("cannot delete property (%s)", db_strerror (ret));
 686             /* don't return -1 here since this would leave things
 687                even more inconsistent. wait till the cursor is finished
 688              */
 689             retval = -1;
 690         }
 691         cnt++;
 692
 693         /* if (key.size  > 0) free(key.data);  */
 694         if (data.size > 0) {
 695             free (data.data);
 696         }
 697     }
 698
 699     cursor->close (cursor);
 700
 701     if (cnt) {
 702         PropertyChangeNotify(client, subject, NULL, PropertyDeleted);
 703     }
 704
 705     if (retval) {
 706         return -1;
 707     }
 708
 709     return cnt;
 710
 711 #else // !HAVE_DB
 712     return -1;
 713 #endif
 714 }
 715
 716 int JackMetadata::RemoveAllProperties(JackClient* client)
 717 {
 718 #if HAVE_DB
 719
 720     int ret;
 721     jack_uuid_t empty_uuid = JACK_UUID_EMPTY_INITIALIZER;
 722
 723     if (PropertyInit(NULL)) {
 724         return -1;
 725     }
 726
 727     if ((ret = fDB->truncate (fDB, NULL, NULL, 0)) != 0) {
 728         jack_error ("Cannot clear properties (%s)", db_strerror (ret));
 729         return -1;
 730     }
 731
 732     PropertyChangeNotify(client, empty_uuid, NULL, PropertyDeleted);
 733
 734     return 0;
 735
 736 #else // !HAVE_DB
 737     return -1;
 738 #endif
 739 }
 740
 741 } // end of namespace
 742
 743
 744