mdw@git.distorted.org.uk Git - disorder/blob - lib/trackdb-playlists.c

   1 /*
   2  * This file is part of DisOrder
   3  * Copyright (C) 2008 Richard Kettlewell
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  18  * USA
  19  */
  20 /** @file lib/trackdb-playlists.c
  21  * @brief Track database playlist support
  22  *
  23  * This file implements reading and modification of playlists, including access
  24  * control, but not locking or event logging (at least yet).
  25  */
  26 #include "common.h"
  27
  28 #include <errno.h>
  29
  30 #include "trackdb-int.h"
  31 #include "mem.h"
  32 #include "log.h"
  33 #include "configuration.h"
  34 #include "vector.h"
  35 #include "eventlog.h"
  36
  37 static int trackdb_playlist_get_tid(const char *name,
  38                                     const char *who,
  39                                     char ***tracksp,
  40                                     int *ntracksp,
  41                                     char **sharep,
  42                                     DB_TXN *tid);
  43 static int trackdb_playlist_set_tid(const char *name,
  44                                     const char *who,
  45                                     char **tracks,
  46                                     int ntracks,
  47                                     const char *share,
  48                                     DB_TXN *tid);
  49 static int trackdb_playlist_list_tid(const char *who,
  50                                      char ***playlistsp,
  51                                      int *nplaylistsp,
  52                                      DB_TXN *tid);
  53 static int trackdb_playlist_delete_tid(const char *name,
  54                                        const char *who,
  55                                        DB_TXN *tid);
  56
  57 /** @brief Parse a playlist name
  58  * @param name Playlist name
  59  * @param ownerp Where to put owner, or NULL
  60  * @param sharep Where to put default sharing, or NULL
  61  * @return 0 on success, -1 on error
  62  *
  63  * Playlists take the form USER.PLAYLIST or just PLAYLIST.  The PLAYLIST part
  64  * is alphanumeric and nonempty.  USER is a username (see valid_username()).
  65  */
  66 int playlist_parse_name(const char *name,
  67                         char **ownerp,
  68                         char **sharep) {
  69   const char *dot = strchr(name, '.'), *share;
  70   char *owner;
  71
  72   if(dot) {
  73     /* Owned playlist */
  74     owner = xstrndup(name, dot - name);
  75     if(!valid_username(owner))
  76       return -1;
  77     if(!valid_username(dot + 1))
  78       return -1;
  79     share = "private";
  80   } else {
  81     /* Shared playlist */
  82     if(!valid_username(name))
  83       return -1;
  84     owner = 0;
  85     share = "shared";
  86   }
  87   if(ownerp)
  88     *ownerp = owner;
  89   if(sharep)
  90     *sharep = xstrdup(share);
  91   return 0;
  92 }
  93
  94 /** @brief Check read access rights
  95  * @param name Playlist name
  96  * @param who Who wants to read
  97  * @param share Playlist share status
  98  */
  99 static int playlist_may_read(const char *name,
 100                              const char *who,
 101                              const char *share) {
 102   char *owner;
 103
 104   if(playlist_parse_name(name, &owner, 0))
 105     return 0;
 106   /* Anyone can read shared playlists */
 107   if(!owner)
 108     return 1;
 109   /* You can always read playlists you own */
 110   if(!strcmp(owner, who))
 111     return 1;
 112   /* You can read public playlists */
 113   if(!strcmp(share, "public"))
 114     return 1;
 115   /* Anything else is prohibited */
 116   return 0;
 117 }
 118
 119 /** @brief Check modify access rights
 120  * @param name Playlist name
 121  * @param who Who wants to modify
 122  * @param share Playlist share status
 123  */
 124 static int playlist_may_write(const char *name,
 125                               const char *who,
 126                               const char attribute((unused)) *share) {
 127   char *owner;
 128
 129   if(playlist_parse_name(name, &owner, 0))
 130     return 0;
 131   /* Anyone can modify shared playlists */
 132   if(!owner)
 133     return 1;
 134   /* You can always modify playlists you own */
 135   if(!strcmp(owner, who))
 136     return 1;
 137   /* Anything else is prohibited */
 138   return 0;
 139 }
 140
 141 /** @brief Get playlist data
 142  * @param name Name of playlist
 143  * @param who Who wants to know
 144  * @param tracksp Where to put list of tracks, or NULL
 145  * @param ntracksp Where to put count of tracks, or NULL
 146  * @param sharep Where to put sharing type, or NULL
 147  * @return 0 on success, non-0 on error
 148  *
 149  * Possible return values:
 150  * - @c 0 on success
 151  * - @c ENOENT if the playlist doesn't exist
 152  * - @c EINVAL if the playlist name is invalid
 153  * - @c EACCES if the playlist cannot be read by @p who
 154  */
 155 int trackdb_playlist_get(const char *name,
 156                          const char *who,
 157                          char ***tracksp,
 158                          int *ntracksp,
 159                          char **sharep) {
 160   int e;
 161
 162   if(playlist_parse_name(name, 0, 0)) {
 163     disorder_error(0, "invalid playlist name '%s'", name);
 164     return EINVAL;
 165   }
 166   WITH_TRANSACTION(trackdb_playlist_get_tid(name, who,
 167                                             tracksp, ntracksp, sharep,
 168                                             tid));
 169   /* Don't expose libdb error codes too much */
 170   if(e == DB_NOTFOUND)
 171     e = ENOENT;
 172   return e;
 173 }
 174
 175 static int trackdb_playlist_get_tid(const char *name,
 176                                     const char *who,
 177                                     char ***tracksp,
 178                                     int *ntracksp,
 179                                     char **sharep,
 180                                     DB_TXN *tid) {
 181   struct kvp *k;
 182   int e, ntracks;
 183   const char *s;
 184
 185   if((e = trackdb_getdata(trackdb_playlistsdb, name, &k, tid)))
 186     return e;
 187   /* Get sharability */
 188   if(!(s = kvp_get(k, "sharing"))) {
 189     disorder_error(0, "playlist '%s' has no 'sharing' key", name);
 190     s = "private";
 191   }
 192   /* Check the read is allowed */
 193   if(!playlist_may_read(name, who, s))
 194     return EACCES;
 195   /* Return sharability */
 196   if(sharep)
 197     *sharep = xstrdup(s);
 198   /* Get track count */
 199   if(!(s = kvp_get(k, "count"))) {
 200     disorder_error(0, "playlist '%s' has no 'count' key", name);
 201     s = "0";
 202   }
 203   ntracks = atoi(s);
 204   if(ntracks < 0) {
 205     disorder_error(0, "playlist '%s' has negative count", name);
 206     ntracks = 0;
 207   }
 208   /* Return track count */
 209   if(ntracksp)
 210     *ntracksp = ntracks;
 211   if(tracksp) {
 212     /* Get track list */
 213     char **tracks = xcalloc(ntracks + 1, sizeof (char *));
 214     char b[16];
 215
 216     for(int n = 0; n < ntracks; ++n) {
 217       snprintf(b, sizeof b, "%d", n);
 218       if(!(s = kvp_get(k, b))) {
 219         disorder_error(0, "playlist '%s' lacks track %d", name, n);
 220         s = "unknown";
 221       }
 222       tracks[n] = xstrdup(s);
 223     }
 224     tracks[ntracks] = 0;
 225     /* Return track list */
 226     *tracksp = tracks;
 227   }
 228   return 0;
 229 }
 230
 231 /** @brief Modify or create a playlist
 232  * @param name Playlist name
 233  * @param who User modifying playlist
 234  * @param tracks List of tracks to set, or NULL to leave alone
 235  * @param ntracks Length of @p tracks
 236  * @param share Sharing status, or NULL to leave alone
 237  * @return 0 on success, non-0 on error
 238  *
 239  * If the playlist exists it is just modified.
 240  *
 241  * If the playlist does not exist it is created.  The default set of tracks is
 242  * none, and the default sharing is private (if it is an owned one) or shared
 243  * (otherwise).
 244  *
 245  * If neither @c tracks nor @c share are set then we only do an access check.
 246  * The database is never modified (even to create the playlist) in this
 247  * situation.
 248  *
 249  * Possible return values:
 250  * - @c 0 on success
 251  * - @c EINVAL if the playlist name is invalid
 252  * - @c EACCES if the playlist cannot be modified by @p who
 253  */
 254 int trackdb_playlist_set(const char *name,
 255                          const char *who,
 256                          char **tracks,
 257                          int ntracks,
 258                          const char *share) {
 259   int e;
 260   char *owner;
 261
 262   if(playlist_parse_name(name, &owner, 0)) {
 263     disorder_error(0, "invalid playlist name '%s'", name);
 264     return EINVAL;
 265   }
 266   /* Check valid share types */
 267   if(share) {
 268     if(owner) {
 269       /* Playlists with an owner must be public or private */
 270       if(strcmp(share, "public")
 271          && strcmp(share, "private")) {
 272         disorder_error(0, "playlist '%s' must be public or private", name);
 273         return EINVAL;
 274       }
 275     } else {
 276       /* Playlists with no owner must be shared */
 277       if(strcmp(share, "shared")) {
 278         disorder_error(0, "playlist '%s' must be shared", name);
 279         return EINVAL;
 280       }
 281     }
 282   }
 283   /* We've checked as much as we can for now, now go and attempt the change */
 284   WITH_TRANSACTION(trackdb_playlist_set_tid(name, who, tracks, ntracks, share,
 285                                             tid));
 286   return e;
 287 }
 288
 289 static int trackdb_playlist_set_tid(const char *name,
 290                                     const char *who,
 291                                     char **tracks,
 292                                     int ntracks,
 293                                     const char *share,
 294                                     DB_TXN *tid) {
 295   struct kvp *k;
 296   int e;
 297   const char *s;
 298   const char *event = "playlist_modified";
 299
 300   if((e = trackdb_getdata(trackdb_playlistsdb, name, &k, tid))
 301      && e != DB_NOTFOUND)
 302     return e;
 303   /* If the playlist doesn't exist set some defaults */
 304   if(e == DB_NOTFOUND) {
 305     char *defshare, *owner;
 306
 307     if(playlist_parse_name(name, &owner, &defshare))
 308       return EINVAL;
 309     /* Can't create a non-shared playlist belonging to someone else.  In fact
 310      * this should be picked up by playlist_may_write() below but it's clearer
 311      * to do it here. */
 312     if(owner && strcmp(owner, who))
 313       return EACCES;
 314     k = 0;
 315     kvp_set(&k, "count", 0);
 316     kvp_set(&k, "sharing", defshare);
 317     event = "playlist_created";
 318   }
 319   /* Check that the modification is allowed */
 320   if(!(s = kvp_get(k, "sharing"))) {
 321     disorder_error(0, "playlist '%s' has no 'sharing' key", name);
 322     s = "private";
 323   }
 324   if(!playlist_may_write(name, who, s))
 325     return EACCES;
 326   /* If no change was requested then don't even create */
 327   if(!share && !tracks)
 328     return 0;
 329   /* Set the new values */
 330   if(share)
 331     kvp_set(&k, "sharing", share);
 332   if(tracks) {
 333     char b[16];
 334     int oldcount, n;
 335
 336     /* Sanity check track count */
 337     if(ntracks < 0 || ntracks > config->playlist_max) {
 338       disorder_error(0, "invalid track count %d", ntracks);
 339       return EINVAL;
 340     }
 341     /* Set the tracks */
 342     for(n = 0; n < ntracks; ++n) {
 343       snprintf(b, sizeof b, "%d", n);
 344       kvp_set(&k, b, tracks[n]);
 345     }
 346     /* Get the old track count */
 347     if((s = kvp_get(k, "count")))
 348       oldcount = atoi(s);
 349     else
 350       oldcount = 0;
 351     /* Delete old slots */
 352     for(; n < oldcount; ++n) {
 353       snprintf(b, sizeof b, "%d", n);
 354       kvp_set(&k, b, NULL);
 355     }
 356     /* Set the new count */
 357     snprintf(b, sizeof b, "%d", ntracks);
 358     kvp_set(&k, "count", b);
 359   }
 360   /* Store the resulting record */
 361   e = trackdb_putdata(trackdb_playlistsdb, name, k, tid, 0);
 362   /* Log the event */
 363   if(!e)
 364     eventlog(event, name, kvp_get(k, "sharing"), (char *)0);
 365   return e;
 366 }
 367
 368 /** @brief Get a list of playlists
 369  * @param who Who wants to know
 370  * @param playlistsp Where to put list of playlists
 371  * @param nplaylistsp Where to put count of playlists, or NULL
 372  */
 373 void trackdb_playlist_list(const char *who,
 374                            char ***playlistsp,
 375                            int *nplaylistsp) {
 376   int e;
 377
 378   WITH_TRANSACTION(trackdb_playlist_list_tid(who, playlistsp, nplaylistsp,
 379                                              tid));
 380 }
 381
 382 static int trackdb_playlist_list_tid(const char *who,
 383                                      char ***playlistsp,
 384                                      int *nplaylistsp,
 385                                      DB_TXN *tid) {
 386   struct vector v[1];
 387   DBC *c;
 388   DBT k[1], d[1];
 389   int e;
 390
 391   vector_init(v);
 392   c = trackdb_opencursor(trackdb_playlistsdb, tid);
 393   memset(k, 0, sizeof k);
 394   while(!(e = c->c_get(c, k, prepare_data(d), DB_NEXT))) {
 395     char *name = xstrndup(k->data, k->size), *owner;
 396     const char *share = kvp_get(kvp_urldecode(d->data, d->size),
 397                                 "sharing");
 398
 399     /* Extract owner; malformed names are skipped */
 400     if(playlist_parse_name(name, &owner, 0)) {
 401       disorder_error(0, "invalid playlist name '%s' found in database", name);
 402       continue;
 403     }
 404     if(!share) {
 405       disorder_error(0, "playlist '%s' has no 'sharing' key", name);
 406       continue;
 407     }
 408     /* Always list public and shared playlists
 409      * Only list private ones to their owner
 410      * Don't list anything else
 411      */
 412     if(!strcmp(share, "public")
 413        || !strcmp(share, "shared")
 414        || (!strcmp(share, "private")
 415            && owner && !strcmp(owner, who)))
 416       vector_append(v, name);
 417   }
 418   trackdb_closecursor(c);
 419   switch(e) {
 420   case DB_NOTFOUND:
 421     break;
 422   case DB_LOCK_DEADLOCK:
 423     return e;
 424   default:
 425     disorder_fatal(0, "c->c_get: %s", db_strerror(e));
 426   }
 427   vector_terminate(v);
 428   if(playlistsp)
 429     *playlistsp = v->vec;
 430   if(nplaylistsp)
 431     *nplaylistsp = v->nvec;
 432   return 0;
 433 }
 434
 435 /** @brief Delete a playlist
 436  * @param name Playlist name
 437  * @param who Who is deleting it
 438  * @return 0 on success, non-0 on error
 439  *
 440  * Possible return values:
 441  * - @c 0 on success
 442  * - @c EINVAL if the playlist name is invalid
 443  * - @c EACCES if the playlist cannot be modified by @p who
 444  * - @c ENOENT if the playlist doesn't exist
 445  */
 446 int trackdb_playlist_delete(const char *name,
 447                             const char *who) {
 448   int e;
 449   char *owner;
 450
 451   if(playlist_parse_name(name, &owner, 0)) {
 452     disorder_error(0, "invalid playlist name '%s'", name);
 453     return EINVAL;
 454   }
 455   /* We've checked as much as we can for now, now go and attempt the change */
 456   WITH_TRANSACTION(trackdb_playlist_delete_tid(name, who, tid));
 457   if(e == DB_NOTFOUND)
 458     e = ENOENT;
 459   return e;
 460 }
 461
 462 static int trackdb_playlist_delete_tid(const char *name,
 463                                        const char *who,
 464                                        DB_TXN *tid) {
 465   struct kvp *k;
 466   int e;
 467   const char *s;
 468
 469   if((e = trackdb_getdata(trackdb_playlistsdb, name, &k, tid)))
 470     return e;
 471   /* Check that modification is allowed */
 472   if(!(s = kvp_get(k, "sharing"))) {
 473     disorder_error(0, "playlist '%s' has no 'sharing' key", name);
 474     s = "private";
 475   }
 476   if(!playlist_may_write(name, who, s))
 477     return EACCES;
 478   /* Delete the playlist */
 479   e = trackdb_delkey(trackdb_playlistsdb, name, tid);
 480   if(!e)
 481     eventlog("playlist_deleted", name, 0);
 482   return e;
 483 }
 484
 485 /*
 486 Local Variables:
 487 c-basic-offset:2
 488 comment-column:40
 489 fill-column:79
 490 indent-tabs-mode:nil
 491 End:
 492 */