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