chiark - git - mdw - disorder/blob - lib/client-stubs.c

   1 /*
   2  * Automatically generated file, see scripts/protocol
   3  *
   4  * DO NOT EDIT.
   5  */
   6 /*
   7  * This file is part of DisOrder.
   8  * Copyright (C) 2010-11 Richard Kettlewell
   9  *
  10  * This program is free software: you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation, either version 3 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  22  */
  23 /** @file lib/client-stubs.c
  24  * @brief Generated client API implementation
  25  */
  26
  27 int disorder_adopt(disorder_client *c, const char *id) {
  28   return disorder_simple(c, NULL, "adopt", id, (char *)NULL);
  29 }
  30
  31 int disorder_adduser(disorder_client *c, const char *user, const char *password, const char *rights) {
  32   return disorder_simple(c, NULL, "adduser", user, password, rights, (char *)NULL);
  33 }
  34
  35 int disorder_allfiles(disorder_client *c, const char *dir, const char *re, char ***filesp, int *nfilesp) {
  36   int rc = disorder_simple(c, NULL, "allfiles", dir, re, (char *)NULL);
  37   if(rc)
  38     return rc;
  39   if(readlist(c, filesp, nfilesp))
  40     return -1;
  41   return 0;
  42 }
  43
  44 int disorder_confirm(disorder_client *c, const char *confirmation) {
  45   char **v;
  46   int nv, rc = disorder_simple_split(c, &v, &nv, 1, "confirm", confirmation, (char *)NULL);
  47   if(rc)
  48     return rc;
  49   c->user = v[0];
  50   v[0] = NULL;
  51   free_strings(nv, v);
  52   return 0;
  53 }
  54
  55 int disorder_cookie(disorder_client *c, const char *cookie) {
  56   char **v;
  57   int nv, rc = disorder_simple_split(c, &v, &nv, 1, "cookie", cookie, (char *)NULL);
  58   if(rc)
  59     return rc;
  60   c->user = v[0];
  61   v[0] = NULL;
  62   free_strings(nv, v);
  63   return 0;
  64 }
  65
  66 int disorder_deluser(disorder_client *c, const char *user) {
  67   return disorder_simple(c, NULL, "deluser", user, (char *)NULL);
  68 }
  69
  70 int disorder_dirs(disorder_client *c, const char *dir, const char *re, char ***filesp, int *nfilesp) {
  71   int rc = disorder_simple(c, NULL, "dirs", dir, re, (char *)NULL);
  72   if(rc)
  73     return rc;
  74   if(readlist(c, filesp, nfilesp))
  75     return -1;
  76   return 0;
  77 }
  78
  79 int disorder_disable(disorder_client *c) {
  80   return disorder_simple(c, NULL, "disable", (char *)NULL);
  81 }
  82
  83 int disorder_edituser(disorder_client *c, const char *username, const char *property, const char *value) {
  84   return disorder_simple(c, NULL, "edituser", username, property, value, (char *)NULL);
  85 }
  86
  87 int disorder_enable(disorder_client *c) {
  88   return disorder_simple(c, NULL, "enable", (char *)NULL);
  89 }
  90
  91 int disorder_enabled(disorder_client *c, int *enabledp) {
  92   char **v;
  93   int nv, rc = disorder_simple_split(c, &v, &nv, 1, "enabled", (char *)NULL);
  94   if(rc)
  95     return rc;
  96   if(boolean("enabled", v[0], enabledp))
  97     return -1;
  98   free_strings(nv, v);
  99   return 0;
 100 }
 101
 102 int disorder_exists(disorder_client *c, const char *track, int *existsp) {
 103   char **v;
 104   int nv, rc = disorder_simple_split(c, &v, &nv, 1, "exists", track, (char *)NULL);
 105   if(rc)
 106     return rc;
 107   if(boolean("exists", v[0], existsp))
 108     return -1;
 109   free_strings(nv, v);
 110   return 0;
 111 }
 112
 113 int disorder_files(disorder_client *c, const char *dir, const char *re, char ***filesp, int *nfilesp) {
 114   int rc = disorder_simple(c, NULL, "files", dir, re, (char *)NULL);
 115   if(rc)
 116     return rc;
 117   if(readlist(c, filesp, nfilesp))
 118     return -1;
 119   return 0;
 120 }
 121
 122 int disorder_get(disorder_client *c, const char *track, const char *pref, char **valuep) {
 123   char **v;
 124   int nv, rc = disorder_simple_split(c, &v, &nv, 1, "get", track, pref, (char *)NULL);
 125   if(rc)
 126     return rc;
 127   *valuep = v[0];
 128   v[0] = NULL;
 129   free_strings(nv, v);
 130   return 0;
 131 }
 132
 133 int disorder_get_global(disorder_client *c, const char *pref, char **valuep) {
 134   char **v;
 135   int nv, rc = disorder_simple_split(c, &v, &nv, 1, "get-global", pref, (char *)NULL);
 136   if(rc)
 137     return rc;
 138   *valuep = v[0];
 139   v[0] = NULL;
 140   free_strings(nv, v);
 141   return 0;
 142 }
 143
 144 int disorder_length(disorder_client *c, const char *track, long *lengthp) {
 145   char **v;
 146   int nv, rc = disorder_simple_split(c, &v, &nv, 1, "length", track, (char *)NULL);
 147   if(rc)
 148     return rc;
 149   *lengthp = atol(v[0]);
 150   free_strings(nv, v);
 151   return 0;
 152 }
 153
 154 int disorder_make_cookie(disorder_client *c, char **cookiep) {
 155   char **v;
 156   int nv, rc = disorder_simple_split(c, &v, &nv, 1, "make-cookie", (char *)NULL);
 157   if(rc)
 158     return rc;
 159   *cookiep = v[0];
 160   v[0] = NULL;
 161   free_strings(nv, v);
 162   return 0;
 163 }
 164
 165 int disorder_move(disorder_client *c, const char *track, long delta) {
 166   return disorder_simple(c, NULL, "move", track, disorder__integer, delta, (char *)NULL);
 167 }
 168
 169 int disorder_moveafter(disorder_client *c, const char *target, char **ids, int nids) {
 170   return disorder_simple(c, NULL, "moveafter", target, disorder__list, ids, nids, (char *)NULL);
 171 }
 172
 173 int disorder_new_tracks(disorder_client *c, long max, char ***tracksp, int *ntracksp) {
 174   int rc = disorder_simple(c, NULL, "new", disorder__integer, max, (char *)NULL);
 175   if(rc)
 176     return rc;
 177   if(readlist(c, tracksp, ntracksp))
 178     return -1;
 179   return 0;
 180 }
 181
 182 int disorder_nop(disorder_client *c) {
 183   return disorder_simple(c, NULL, "nop", (char *)NULL);
 184 }
 185
 186 int disorder_part(disorder_client *c, const char *track, const char *context, const char *part, char **partp) {
 187   char **v;
 188   int nv, rc = disorder_simple_split(c, &v, &nv, 1, "part", track, context, part, (char *)NULL);
 189   if(rc)
 190     return rc;
 191   *partp = v[0];
 192   v[0] = NULL;
 193   free_strings(nv, v);
 194   return 0;
 195 }
 196
 197 int disorder_pause(disorder_client *c) {
 198   return disorder_simple(c, NULL, "pause", (char *)NULL);
 199 }
 200
 201 int disorder_play(disorder_client *c, const char *track, char **idp) {
 202   return disorder_simple(c, idp, "play", track, (char *)NULL);
 203 }
 204
 205 int disorder_playafter(disorder_client *c, const char *target, char **tracks, int ntracks) {
 206   return disorder_simple(c, NULL, "playafter", target, disorder__list, tracks, ntracks, (char *)NULL);
 207 }
 208
 209 int disorder_playing(disorder_client *c, struct queue_entry **playingp) {
 210   return onequeue(c, "playing", playingp);
 211 }
 212
 213 int disorder_playlist_delete(disorder_client *c, const char *playlist) {
 214   return disorder_simple(c, NULL, "playlist-delete", playlist, (char *)NULL);
 215 }
 216
 217 int disorder_playlist_get(disorder_client *c, const char *playlist, char ***tracksp, int *ntracksp) {
 218   int rc = disorder_simple(c, NULL, "playlist-get", playlist, (char *)NULL);
 219   if(rc)
 220     return rc;
 221   if(readlist(c, tracksp, ntracksp))
 222     return -1;
 223   return 0;
 224 }
 225
 226 int disorder_playlist_get_share(disorder_client *c, const char *playlist, char **sharep) {
 227   return disorder_simple(c, sharep, "playlist-get-share", playlist, (char *)NULL);
 228 }
 229
 230 int disorder_playlist_lock(disorder_client *c, const char *playlist) {
 231   return disorder_simple(c, NULL, "playlist-lock", playlist, (char *)NULL);
 232 }
 233
 234 int disorder_playlist_set(disorder_client *c, const char *playlist, char **tracks, int ntracks) {
 235   return disorder_simple(c, NULL, "playlist-set", playlist, disorder__body, tracks, ntracks, (char *)NULL);
 236 }
 237
 238 int disorder_playlist_set_share(disorder_client *c, const char *playlist, const char *share) {
 239   return disorder_simple(c, NULL, "playlist-set-share", playlist, share, (char *)NULL);
 240 }
 241
 242 int disorder_playlist_unlock(disorder_client *c) {
 243   return disorder_simple(c, NULL, "playlist-unlock", (char *)NULL);
 244 }
 245
 246 int disorder_playlists(disorder_client *c, char ***playlistsp, int *nplaylistsp) {
 247   int rc = disorder_simple(c, NULL, "playlists", (char *)NULL);
 248   if(rc)
 249     return rc;
 250   if(readlist(c, playlistsp, nplaylistsp))
 251     return -1;
 252   return 0;
 253 }
 254
 255 int disorder_prefs(disorder_client *c, const char *track, struct kvp **prefsp) {
 256   return pairlist(c, prefsp, "prefs", track, (char *)NULL);
 257 }
 258
 259 int disorder_queue(disorder_client *c, struct queue_entry **queuep) {
 260   int rc = disorder_simple(c, NULL, "queue", (char *)NULL);
 261   if(rc)
 262     return rc;
 263   if(readqueue(c, queuep))
 264     return -1;
 265   return 0;
 266 }
 267
 268 int disorder_random_disable(disorder_client *c) {
 269   return disorder_simple(c, NULL, "random-disable", (char *)NULL);
 270 }
 271
 272 int disorder_random_enable(disorder_client *c) {
 273   return disorder_simple(c, NULL, "random-enable", (char *)NULL);
 274 }
 275
 276 int disorder_random_enabled(disorder_client *c, int *enabledp) {
 277   char **v;
 278   int nv, rc = disorder_simple_split(c, &v, &nv, 1, "random-enabled", (char *)NULL);
 279   if(rc)
 280     return rc;
 281   if(boolean("random-enabled", v[0], enabledp))
 282     return -1;
 283   free_strings(nv, v);
 284   return 0;
 285 }
 286
 287 int disorder_recent(disorder_client *c, struct queue_entry **recentp) {
 288   int rc = disorder_simple(c, NULL, "recent", (char *)NULL);
 289   if(rc)
 290     return rc;
 291   if(readqueue(c, recentp))
 292     return -1;
 293   return 0;
 294 }
 295
 296 int disorder_reconfigure(disorder_client *c) {
 297   return disorder_simple(c, NULL, "reconfigure", (char *)NULL);
 298 }
 299
 300 int disorder_register(disorder_client *c, const char *username, const char *password, const char *email, char **confirmationp) {
 301   char **v;
 302   int nv, rc = disorder_simple_split(c, &v, &nv, 1, "register", username, password, email, (char *)NULL);
 303   if(rc)
 304     return rc;
 305   *confirmationp = v[0];
 306   v[0] = NULL;
 307   free_strings(nv, v);
 308   return 0;
 309 }
 310
 311 int disorder_reminder(disorder_client *c, const char *username) {
 312   return disorder_simple(c, NULL, "reminder", username, (char *)NULL);
 313 }
 314
 315 int disorder_remove(disorder_client *c, const char *id) {
 316   return disorder_simple(c, NULL, "remove", id, (char *)NULL);
 317 }
 318
 319 int disorder_rescan(disorder_client *c) {
 320   return disorder_simple(c, NULL, "rescan", (char *)NULL);
 321 }
 322
 323 int disorder_resolve(disorder_client *c, const char *track, char **resolvedp) {
 324   char **v;
 325   int nv, rc = disorder_simple_split(c, &v, &nv, 1, "resolve", track, (char *)NULL);
 326   if(rc)
 327     return rc;
 328   *resolvedp = v[0];
 329   v[0] = NULL;
 330   free_strings(nv, v);
 331   return 0;
 332 }
 333
 334 int disorder_resume(disorder_client *c) {
 335   return disorder_simple(c, NULL, "resume", (char *)NULL);
 336 }
 337
 338 int disorder_revoke(disorder_client *c) {
 339   return disorder_simple(c, NULL, "revoke", (char *)NULL);
 340 }
 341
 342 int disorder_rtp_address(disorder_client *c, char **addressp, char **portp) {
 343   char **v;
 344   int nv, rc = disorder_simple_split(c, &v, &nv, 2, "rtp-address", (char *)NULL);
 345   if(rc)
 346     return rc;
 347   *addressp = v[0];
 348   v[0] = NULL;
 349   *portp = v[1];
 350   v[1] = NULL;
 351   free_strings(nv, v);
 352   return 0;
 353 }
 354
 355 int disorder_scratch(disorder_client *c, const char *id) {
 356   return disorder_simple(c, NULL, "scratch", id, (char *)NULL);
 357 }
 358
 359 int disorder_schedule_add_play(disorder_client *c, time_t when, const char *priority, const char *track) {
 360   return disorder_simple(c, NULL, "schedule-add", disorder__time, when, priority, "play", track, (char *)NULL);
 361 }
 362
 363 int disorder_schedule_add_set_global(disorder_client *c, time_t when, const char *priority, const char *pref, const char *value) {
 364   return disorder_simple(c, NULL, "schedule-add", disorder__time, when, priority, "set-global", pref, value, (char *)NULL);
 365 }
 366
 367 int disorder_schedule_add_unset_global(disorder_client *c, time_t when, const char *priority, const char *pref) {
 368   return disorder_simple(c, NULL, "schedule-add", disorder__time, when, priority, "set-global", pref, (char *)NULL);
 369 }
 370
 371 int disorder_schedule_del(disorder_client *c, const char *event) {
 372   return disorder_simple(c, NULL, "schedule-del", event, (char *)NULL);
 373 }
 374
 375 int disorder_schedule_get(disorder_client *c, const char *id, struct kvp **actiondatap) {
 376   return pairlist(c, actiondatap, "schedule-get", id, (char *)NULL);
 377 }
 378
 379 int disorder_schedule_list(disorder_client *c, char ***idsp, int *nidsp) {
 380   int rc = disorder_simple(c, NULL, "schedule-list", (char *)NULL);
 381   if(rc)
 382     return rc;
 383   if(readlist(c, idsp, nidsp))
 384     return -1;
 385   return 0;
 386 }
 387
 388 int disorder_search(disorder_client *c, const char *terms, char ***tracksp, int *ntracksp) {
 389   int rc = disorder_simple(c, NULL, "search", terms, (char *)NULL);
 390   if(rc)
 391     return rc;
 392   if(readlist(c, tracksp, ntracksp))
 393     return -1;
 394   return 0;
 395 }
 396
 397 int disorder_set(disorder_client *c, const char *track, const char *pref, const char *value) {
 398   return disorder_simple(c, NULL, "set", track, pref, value, (char *)NULL);
 399 }
 400
 401 int disorder_set_global(disorder_client *c, const char *pref, const char *value) {
 402   return disorder_simple(c, NULL, "set-global", pref, value, (char *)NULL);
 403 }
 404
 405 int disorder_shutdown(disorder_client *c) {
 406   return disorder_simple(c, NULL, "shutdown", (char *)NULL);
 407 }
 408
 409 int disorder_stats(disorder_client *c, char ***statsp, int *nstatsp) {
 410   int rc = disorder_simple(c, NULL, "stats", (char *)NULL);
 411   if(rc)
 412     return rc;
 413   if(readlist(c, statsp, nstatsp))
 414     return -1;
 415   return 0;
 416 }
 417
 418 int disorder_tags(disorder_client *c, char ***tagsp, int *ntagsp) {
 419   int rc = disorder_simple(c, NULL, "tags", (char *)NULL);
 420   if(rc)
 421     return rc;
 422   if(readlist(c, tagsp, ntagsp))
 423     return -1;
 424   return 0;
 425 }
 426
 427 int disorder_unset(disorder_client *c, const char *track, const char *pref) {
 428   return disorder_simple(c, NULL, "unset", track, pref, (char *)NULL);
 429 }
 430
 431 int disorder_unset_global(disorder_client *c, const char *pref) {
 432   return disorder_simple(c, NULL, "unset-global", pref, (char *)NULL);
 433 }
 434
 435 int disorder_userinfo(disorder_client *c, const char *username, const char *property, char **valuep) {
 436   char **v;
 437   int nv, rc = disorder_simple_split(c, &v, &nv, 1, "userinfo", username, property, (char *)NULL);
 438   if(rc)
 439     return rc;
 440   *valuep = v[0];
 441   v[0] = NULL;
 442   free_strings(nv, v);
 443   return 0;
 444 }
 445
 446 int disorder_users(disorder_client *c, char ***usersp, int *nusersp) {
 447   int rc = disorder_simple(c, NULL, "users", (char *)NULL);
 448   if(rc)
 449     return rc;
 450   if(readlist(c, usersp, nusersp))
 451     return -1;
 452   return 0;
 453 }
 454
 455 int disorder_version(disorder_client *c, char **versionp) {
 456   char **v;
 457   int nv, rc = disorder_simple_split(c, &v, &nv, 1, "version", (char *)NULL);
 458   if(rc)
 459     return rc;
 460   *versionp = v[0];
 461   v[0] = NULL;
 462   free_strings(nv, v);
 463   return 0;
 464 }
 465
 466 int disorder_set_volume(disorder_client *c, long left, long right) {
 467   return disorder_simple(c, NULL, "volume", disorder__integer, left, disorder__integer, right, (char *)NULL);
 468 }
 469
 470 int disorder_get_volume(disorder_client *c, long *leftp, long *rightp) {
 471   char **v;
 472   int nv, rc = disorder_simple_split(c, &v, &nv, 2, "volume", (char *)NULL);
 473   if(rc)
 474     return rc;
 475   *leftp = atol(v[0]);
 476   *rightp = atol(v[1]);
 477   free_strings(nv, v);
 478   return 0;
 479 }
 480