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