mdw@git.distorted.org.uk Git - 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
  24 int disorder_adopt(disorder_client *c, const char *id) {
  25   return disorder_simple(c, NULL, "adopt", id, (char *)NULL);
  26 }
  27
  28 int disorder_adduser(disorder_client *c, const char *user, const char *password, const char *rights) {
  29   return disorder_simple(c, NULL, "adduser", user, password, rights, (char *)NULL);
  30 }
  31
  32 int disorder_allfiles(disorder_client *c, const char *dir, const char *re, char ***filesp, int *nfilesp) {
  33   int rc = disorder_simple(c, NULL, "allfiles", dir, re, (char *)NULL);
  34   if(rc)
  35     return rc;
  36   if(readlist(c, filesp, nfilesp))
  37     return -1;
  38   return 0;
  39 }
  40
  41 int disorder_confirm(disorder_client *c, const char *confirmation) {
  42   char **v, *r;
  43   int nv;
  44   int rc = disorder_simple(c, &r, "confirm", confirmation, (char *)NULL);
  45   if(rc)
  46     return rc;
  47   v = split(r, &nv, SPLIT_QUOTES, 0, 0);
  48   if(nv != 1) {
  49     disorder_error(0, "malformed reply to %s", "confirm");
  50     return -1;
  51   }
  52   c->user = v[0];
  53   return 0;
  54 }
  55
  56 int disorder_cookie(disorder_client *c, const char *cookie) {
  57   char **v, *r;
  58   int nv;
  59   int rc = disorder_simple(c, &r, "cookie", cookie, (char *)NULL);
  60   if(rc)
  61     return rc;
  62   v = split(r, &nv, SPLIT_QUOTES, 0, 0);
  63   if(nv != 1) {
  64     disorder_error(0, "malformed reply to %s", "cookie");
  65     return -1;
  66   }
  67   c->user = v[0];
  68   return 0;
  69 }
  70
  71 int disorder_deluser(disorder_client *c, const char *user) {
  72   return disorder_simple(c, NULL, "deluser", user, (char *)NULL);
  73 }
  74
  75 int disorder_dirs(disorder_client *c, const char *dir, const char *re, char ***filesp, int *nfilesp) {
  76   int rc = disorder_simple(c, NULL, "dirs", dir, re, (char *)NULL);
  77   if(rc)
  78     return rc;
  79   if(readlist(c, filesp, nfilesp))
  80     return -1;
  81   return 0;
  82 }
  83
  84 int disorder_disable(disorder_client *c) {
  85   return disorder_simple(c, NULL, "disable", (char *)NULL);
  86 }
  87
  88 int disorder_edituser(disorder_client *c, const char *username, const char *property, const char *value) {
  89   return disorder_simple(c, NULL, "edituser", username, property, value, (char *)NULL);
  90 }
  91
  92 int disorder_enable(disorder_client *c) {
  93   return disorder_simple(c, NULL, "enable", (char *)NULL);
  94 }
  95
  96 int disorder_enabled(disorder_client *c, int *enabledp) {
  97   char **v, *r;
  98   int nv;
  99   int rc = disorder_simple(c, &r, "enabled", (char *)NULL);
 100   if(rc)
 101     return rc;
 102   v = split(r, &nv, SPLIT_QUOTES, 0, 0);
 103   if(nv != 1) {
 104     disorder_error(0, "malformed reply to %s", "enabled");
 105     return -1;
 106   }
 107   if(boolean("enabled", v[0], enabledp))
 108     return -1;
 109   return 0;
 110 }
 111
 112 int disorder_exists(disorder_client *c, const char *track, int *existsp) {
 113   char **v, *r;
 114   int nv;
 115   int rc = disorder_simple(c, &r, "exists", track, (char *)NULL);
 116   if(rc)
 117     return rc;
 118   v = split(r, &nv, SPLIT_QUOTES, 0, 0);
 119   if(nv != 1) {
 120     disorder_error(0, "malformed reply to %s", "exists");
 121     return -1;
 122   }
 123   if(boolean("exists", v[0], existsp))
 124     return -1;
 125   return 0;
 126 }
 127
 128 int disorder_files(disorder_client *c, const char *dir, const char *re, char ***filesp, int *nfilesp) {
 129   int rc = disorder_simple(c, NULL, "files", dir, re, (char *)NULL);
 130   if(rc)
 131     return rc;
 132   if(readlist(c, filesp, nfilesp))
 133     return -1;
 134   return 0;
 135 }
 136
 137 int disorder_get(disorder_client *c, const char *track, const char *pref, char **valuep) {
 138   char **v, *r;
 139   int nv;
 140   int rc = disorder_simple(c, &r, "get", track, pref, (char *)NULL);
 141   if(rc)
 142     return rc;
 143   v = split(r, &nv, SPLIT_QUOTES, 0, 0);
 144   if(nv != 1) {
 145     disorder_error(0, "malformed reply to %s", "get");
 146     return -1;
 147   }
 148   *valuep = v[0];
 149   return 0;
 150 }
 151
 152 int disorder_get_global(disorder_client *c, const char *pref, char **valuep) {
 153   char **v, *r;
 154   int nv;
 155   int rc = disorder_simple(c, &r, "get-global", pref, (char *)NULL);
 156   if(rc)
 157     return rc;
 158   v = split(r, &nv, SPLIT_QUOTES, 0, 0);
 159   if(nv != 1) {
 160     disorder_error(0, "malformed reply to %s", "get-global");
 161     return -1;
 162   }
 163   *valuep = v[0];
 164   return 0;
 165 }
 166
 167 int disorder_length(disorder_client *c, const char *track, long *lengthp) {
 168   char **v, *r;
 169   int nv;
 170   int rc = disorder_simple(c, &r, "length", track, (char *)NULL);
 171   if(rc)
 172     return rc;
 173   v = split(r, &nv, SPLIT_QUOTES, 0, 0);
 174   if(nv != 1) {
 175     disorder_error(0, "malformed reply to %s", "length");
 176     return -1;
 177   }
 178   *lengthp = atol(v[0]);
 179   return 0;
 180 }
 181
 182 int disorder_make_cookie(disorder_client *c, char **cookiep) {
 183   char **v, *r;
 184   int nv;
 185   int rc = disorder_simple(c, &r, "make-cookie", (char *)NULL);
 186   if(rc)
 187     return rc;
 188   v = split(r, &nv, SPLIT_QUOTES, 0, 0);
 189   if(nv != 1) {
 190     disorder_error(0, "malformed reply to %s", "make-cookie");
 191     return -1;
 192   }
 193   *cookiep = v[0];
 194   return 0;
 195 }
 196
 197 int disorder_move(disorder_client *c, const char *track, long delta) {
 198   char buf_delta[16];
 199   byte_snprintf(buf_delta, sizeof buf_delta, "%ld", delta);
 200   return disorder_simple(c, NULL, "move", track, buf_delta, (char *)NULL);
 201 }
 202
 203 int disorder_moveafter(disorder_client *c, const char *target, char **ids, int nids) {
 204   return disorder_simple(c, NULL, "moveafter", target, disorder_list, ids, nids, (char *)NULL);
 205 }
 206
 207 int disorder_new_tracks(disorder_client *c, long max, char ***tracksp, int *ntracksp) {
 208   char buf_max[16];
 209   byte_snprintf(buf_max, sizeof buf_max, "%ld", max);
 210   int rc = disorder_simple(c, NULL, "new", buf_max, (char *)NULL);
 211   if(rc)
 212     return rc;
 213   if(readlist(c, tracksp, ntracksp))
 214     return -1;
 215   return 0;
 216 }
 217
 218 int disorder_nop(disorder_client *c) {
 219   return disorder_simple(c, NULL, "nop", (char *)NULL);
 220 }
 221
 222 int disorder_part(disorder_client *c, const char *track, const char *context, const char *part, char **partp) {
 223   char **v, *r;
 224   int nv;
 225   int rc = disorder_simple(c, &r, "part", track, context, part, (char *)NULL);
 226   if(rc)
 227     return rc;
 228   v = split(r, &nv, SPLIT_QUOTES, 0, 0);
 229   if(nv != 1) {
 230     disorder_error(0, "malformed reply to %s", "part");
 231     return -1;
 232   }
 233   *partp = v[0];
 234   return 0;
 235 }
 236
 237 int disorder_pause(disorder_client *c) {
 238   return disorder_simple(c, NULL, "pause", (char *)NULL);
 239 }
 240
 241 int disorder_play(disorder_client *c, const char *track, char **idp) {
 242   return disorder_simple(c, idp, "play", track, (char *)NULL);
 243 }
 244
 245 int disorder_playafter(disorder_client *c, const char *target, char **tracks, int ntracks) {
 246   return disorder_simple(c, NULL, "playafter", target, disorder_list, tracks, ntracks, (char *)NULL);
 247 }
 248
 249 int disorder_playing(disorder_client *c, struct queue_entry **playingp) {
 250   return onequeue(c, "playing", playingp);
 251 }
 252
 253 int disorder_playlist_delete(disorder_client *c, const char *playlist) {
 254   return disorder_simple(c, NULL, "playlist-delete", playlist, (char *)NULL);
 255 }
 256
 257 int disorder_playlist_get(disorder_client *c, const char *playlist, char ***tracksp, int *ntracksp) {
 258   int rc = disorder_simple(c, NULL, "playlist-get", playlist, (char *)NULL);
 259   if(rc)
 260     return rc;
 261   if(readlist(c, tracksp, ntracksp))
 262     return -1;
 263   return 0;
 264 }
 265
 266 int disorder_playlist_get_share(disorder_client *c, const char *playlist, char **sharep) {
 267   return disorder_simple(c, sharep, "playlist-get-share", playlist, (char *)NULL);
 268 }
 269
 270 int disorder_playlist_lock(disorder_client *c, const char *playlist) {
 271   return disorder_simple(c, NULL, "playlist-lock", playlist, (char *)NULL);
 272 }
 273
 274 int disorder_playlist_set(disorder_client *c, const char *playlist, char **tracks, int ntracks) {
 275   return disorder_simple(c, NULL, "playlist-set", playlist, disorder_body, tracks, ntracks, (char *)NULL);
 276 }
 277
 278 int disorder_playlist_set_share(disorder_client *c, const char *playlist, const char *share) {
 279   return disorder_simple(c, NULL, "playlist-set-share", playlist, share, (char *)NULL);
 280 }
 281
 282 int disorder_playlist_unlock(disorder_client *c) {
 283   return disorder_simple(c, NULL, "playlist-unlock", (char *)NULL);
 284 }
 285
 286 int disorder_playlists(disorder_client *c, char ***playlistsp, int *nplaylistsp) {
 287   int rc = disorder_simple(c, NULL, "playlists", (char *)NULL);
 288   if(rc)
 289     return rc;
 290   if(readlist(c, playlistsp, nplaylistsp))
 291     return -1;
 292   return 0;
 293 }
 294
 295 int disorder_prefs(disorder_client *c, const char *track, struct kvp **prefsp) {
 296   return pairlist(c, prefsp, "prefs", track, (char *)NULL);
 297 }
 298
 299 int disorder_queue(disorder_client *c, struct queue_entry **queuep) {
 300   int rc = disorder_simple(c, NULL, "queue", (char *)NULL);
 301   if(rc)
 302     return rc;
 303   if(readqueue(c, queuep))
 304     return -1;
 305   return 0;
 306 }
 307
 308 int disorder_random_disable(disorder_client *c) {
 309   return disorder_simple(c, NULL, "random-disable", (char *)NULL);
 310 }
 311
 312 int disorder_random_enable(disorder_client *c) {
 313   return disorder_simple(c, NULL, "random-enable", (char *)NULL);
 314 }
 315
 316 int disorder_random_enabled(disorder_client *c, int *enabledp) {
 317   char **v, *r;
 318   int nv;
 319   int rc = disorder_simple(c, &r, "random-enabled", (char *)NULL);
 320   if(rc)
 321     return rc;
 322   v = split(r, &nv, SPLIT_QUOTES, 0, 0);
 323   if(nv != 1) {
 324     disorder_error(0, "malformed reply to %s", "random-enabled");
 325     return -1;
 326   }
 327   if(boolean("random-enabled", v[0], enabledp))
 328     return -1;
 329   return 0;
 330 }
 331
 332 int disorder_recent(disorder_client *c, struct queue_entry **recentp) {
 333   int rc = disorder_simple(c, NULL, "recent", (char *)NULL);
 334   if(rc)
 335     return rc;
 336   if(readqueue(c, recentp))
 337     return -1;
 338   return 0;
 339 }
 340
 341 int disorder_reconfigure(disorder_client *c) {
 342   return disorder_simple(c, NULL, "reconfigure", (char *)NULL);
 343 }
 344
 345 int disorder_register(disorder_client *c, const char *username, const char *password, const char *email, char **confirmationp) {
 346   char **v, *r;
 347   int nv;
 348   int rc = disorder_simple(c, &r, "register", username, password, email, (char *)NULL);
 349   if(rc)
 350     return rc;
 351   v = split(r, &nv, SPLIT_QUOTES, 0, 0);
 352   if(nv != 1) {
 353     disorder_error(0, "malformed reply to %s", "register");
 354     return -1;
 355   }
 356   *confirmationp = v[0];
 357   return 0;
 358 }
 359
 360 int disorder_reminder(disorder_client *c, const char *username) {
 361   return disorder_simple(c, NULL, "reminder", username, (char *)NULL);
 362 }
 363
 364 int disorder_remove(disorder_client *c, const char *id) {
 365   return disorder_simple(c, NULL, "remove", id, (char *)NULL);
 366 }
 367
 368 int disorder_rescan(disorder_client *c) {
 369   return disorder_simple(c, NULL, "rescan", (char *)NULL);
 370 }
 371
 372 int disorder_resolve(disorder_client *c, const char *track, char **resolvedp) {
 373   char **v, *r;
 374   int nv;
 375   int rc = disorder_simple(c, &r, "resolve", track, (char *)NULL);
 376   if(rc)
 377     return rc;
 378   v = split(r, &nv, SPLIT_QUOTES, 0, 0);
 379   if(nv != 1) {
 380     disorder_error(0, "malformed reply to %s", "resolve");
 381     return -1;
 382   }
 383   *resolvedp = v[0];
 384   return 0;
 385 }
 386
 387 int disorder_resume(disorder_client *c) {
 388   return disorder_simple(c, NULL, "resume", (char *)NULL);
 389 }
 390
 391 int disorder_revoke(disorder_client *c) {
 392   return disorder_simple(c, NULL, "revoke", (char *)NULL);
 393 }
 394
 395 int disorder_rtp_address(disorder_client *c, char **addressp, char **portp) {
 396   char **v, *r;
 397   int nv;
 398   int rc = disorder_simple(c, &r, "rtp-address", (char *)NULL);
 399   if(rc)
 400     return rc;
 401   v = split(r, &nv, SPLIT_QUOTES, 0, 0);
 402   if(nv != 2) {
 403     disorder_error(0, "malformed reply to %s", "rtp-address");
 404     return -1;
 405   }
 406   *addressp = v[0];
 407   *portp = v[1];
 408   return 0;
 409 }
 410
 411 int disorder_scratch(disorder_client *c, const char *id) {
 412   return disorder_simple(c, NULL, "scratch", id, (char *)NULL);
 413 }
 414
 415 int disorder_schedule_add_play(disorder_client *c, time_t when, const char *priority, const char *track) {
 416   char buf_when[16];
 417   byte_snprintf(buf_when, sizeof buf_when, "%lld", (long long)when);
 418   return disorder_simple(c, NULL, "schedule-add", buf_when, priority, "play", track, (char *)NULL);
 419 }
 420
 421 int disorder_schedule_add_set_global(disorder_client *c, time_t when, const char *priority, const char *pref, const char *value) {
 422   char buf_when[16];
 423   byte_snprintf(buf_when, sizeof buf_when, "%lld", (long long)when);
 424   return disorder_simple(c, NULL, "schedule-add", buf_when, priority, "set-global", pref, value, (char *)NULL);
 425 }
 426
 427 int disorder_schedule_add_unset_global(disorder_client *c, time_t when, const char *priority, const char *pref) {
 428   char buf_when[16];
 429   byte_snprintf(buf_when, sizeof buf_when, "%lld", (long long)when);
 430   return disorder_simple(c, NULL, "schedule-add", buf_when, priority, "set-global", pref, (char *)NULL);
 431 }
 432
 433 int disorder_schedule_del(disorder_client *c, const char *event) {
 434   return disorder_simple(c, NULL, "schedule-del", event, (char *)NULL);
 435 }
 436
 437 int disorder_schedule_get(disorder_client *c, const char *id, struct kvp **actiondatap) {
 438   return pairlist(c, actiondatap, "schedule-get", id, (char *)NULL);
 439 }
 440
 441 int disorder_schedule_list(disorder_client *c, char ***idsp, int *nidsp) {
 442   int rc = disorder_simple(c, NULL, "schedule-list", (char *)NULL);
 443   if(rc)
 444     return rc;
 445   if(readlist(c, idsp, nidsp))
 446     return -1;
 447   return 0;
 448 }
 449
 450 int disorder_search(disorder_client *c, const char *terms, char ***tracksp, int *ntracksp) {
 451   int rc = disorder_simple(c, NULL, "search", terms, (char *)NULL);
 452   if(rc)
 453     return rc;
 454   if(readlist(c, tracksp, ntracksp))
 455     return -1;
 456   return 0;
 457 }
 458
 459 int disorder_set(disorder_client *c, const char *track, const char *pref, const char *value) {
 460   return disorder_simple(c, NULL, "set", track, pref, value, (char *)NULL);
 461 }
 462
 463 int disorder_set_global(disorder_client *c, const char *pref, const char *value) {
 464   return disorder_simple(c, NULL, "set-global", pref, value, (char *)NULL);
 465 }
 466
 467 int disorder_shutdown(disorder_client *c) {
 468   return disorder_simple(c, NULL, "shutdown", (char *)NULL);
 469 }
 470
 471 int disorder_stats(disorder_client *c, char ***statsp, int *nstatsp) {
 472   int rc = disorder_simple(c, NULL, "stats", (char *)NULL);
 473   if(rc)
 474     return rc;
 475   if(readlist(c, statsp, nstatsp))
 476     return -1;
 477   return 0;
 478 }
 479
 480 int disorder_tags(disorder_client *c, char ***tagsp, int *ntagsp) {
 481   int rc = disorder_simple(c, NULL, "tags", (char *)NULL);
 482   if(rc)
 483     return rc;
 484   if(readlist(c, tagsp, ntagsp))
 485     return -1;
 486   return 0;
 487 }
 488
 489 int disorder_unset(disorder_client *c, const char *track, const char *pref) {
 490   return disorder_simple(c, NULL, "unset", track, pref, (char *)NULL);
 491 }
 492
 493 int disorder_unset_global(disorder_client *c, const char *pref) {
 494   return disorder_simple(c, NULL, "unset-global", pref, (char *)NULL);
 495 }
 496
 497 int disorder_userinfo(disorder_client *c, const char *username, const char *property, char **valuep) {
 498   char **v, *r;
 499   int nv;
 500   int rc = disorder_simple(c, &r, "userinfo", username, property, (char *)NULL);
 501   if(rc)
 502     return rc;
 503   v = split(r, &nv, SPLIT_QUOTES, 0, 0);
 504   if(nv != 1) {
 505     disorder_error(0, "malformed reply to %s", "userinfo");
 506     return -1;
 507   }
 508   *valuep = v[0];
 509   return 0;
 510 }
 511
 512 int disorder_users(disorder_client *c, char ***usersp, int *nusersp) {
 513   int rc = disorder_simple(c, NULL, "users", (char *)NULL);
 514   if(rc)
 515     return rc;
 516   if(readlist(c, usersp, nusersp))
 517     return -1;
 518   return 0;
 519 }
 520
 521 int disorder_version(disorder_client *c, char **versionp) {
 522   char **v, *r;
 523   int nv;
 524   int rc = disorder_simple(c, &r, "version", (char *)NULL);
 525   if(rc)
 526     return rc;
 527   v = split(r, &nv, SPLIT_QUOTES, 0, 0);
 528   if(nv != 1) {
 529     disorder_error(0, "malformed reply to %s", "version");
 530     return -1;
 531   }
 532   *versionp = v[0];
 533   return 0;
 534 }
 535
 536 int disorder_set_volume(disorder_client *c, long left, long right) {
 537   char buf_left[16];
 538   byte_snprintf(buf_left, sizeof buf_left, "%ld", left);
 539   char buf_right[16];
 540   byte_snprintf(buf_right, sizeof buf_right, "%ld", right);
 541   return disorder_simple(c, NULL, "volume", buf_left, buf_right, (char *)NULL);
 542 }
 543
 544 int disorder_get_volume(disorder_client *c, long *leftp, long *rightp) {
 545   char **v, *r;
 546   int nv;
 547   int rc = disorder_simple(c, &r, "volume", (char *)NULL);
 548   if(rc)
 549     return rc;
 550   v = split(r, &nv, SPLIT_QUOTES, 0, 0);
 551   if(nv != 2) {
 552     disorder_error(0, "malformed reply to %s", "volume");
 553     return -1;
 554   }
 555   *leftp = atol(v[0]);
 556   *rightp = atol(v[1]);
 557   return 0;
 558 }
 559