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   return disorder_simple(c, NULL, "move", track, disorder__integer, delta, (char *)NULL);
 164 }
 165
 166 int disorder_moveafter(disorder_client *c, const char *target, char **ids, int nids) {
 167   return disorder_simple(c, NULL, "moveafter", target, disorder__list, ids, nids, (char *)NULL);
 168 }
 169
 170 int disorder_new_tracks(disorder_client *c, long max, char ***tracksp, int *ntracksp) {
 171   int rc = disorder_simple(c, NULL, "new", disorder__integer, max, (char *)NULL);
 172   if(rc)
 173     return rc;
 174   if(readlist(c, tracksp, ntracksp))
 175     return -1;
 176   return 0;
 177 }
 178
 179 int disorder_nop(disorder_client *c) {
 180   return disorder_simple(c, NULL, "nop", (char *)NULL);
 181 }
 182
 183 int disorder_part(disorder_client *c, const char *track, const char *context, const char *part, char **partp) {
 184   char **v;
 185   int nv, rc = disorder_simple_split(c, &v, &nv, 1, "part", track, context, part, (char *)NULL);
 186   if(rc)
 187     return rc;
 188   *partp = v[0];
 189   v[0] = NULL;
 190   free_strings(nv, v);
 191   return 0;
 192 }
 193
 194 int disorder_pause(disorder_client *c) {
 195   return disorder_simple(c, NULL, "pause", (char *)NULL);
 196 }
 197
 198 int disorder_play(disorder_client *c, const char *track, char **idp) {
 199   return disorder_simple(c, idp, "play", track, (char *)NULL);
 200 }
 201
 202 int disorder_playafter(disorder_client *c, const char *target, char **tracks, int ntracks) {
 203   return disorder_simple(c, NULL, "playafter", target, disorder__list, tracks, ntracks, (char *)NULL);
 204 }
 205
 206 int disorder_playing(disorder_client *c, struct queue_entry **playingp) {
 207   return onequeue(c, "playing", playingp);
 208 }
 209
 210 int disorder_playlist_delete(disorder_client *c, const char *playlist) {
 211   return disorder_simple(c, NULL, "playlist-delete", playlist, (char *)NULL);
 212 }
 213
 214 int disorder_playlist_get(disorder_client *c, const char *playlist, char ***tracksp, int *ntracksp) {
 215   int rc = disorder_simple(c, NULL, "playlist-get", playlist, (char *)NULL);
 216   if(rc)
 217     return rc;
 218   if(readlist(c, tracksp, ntracksp))
 219     return -1;
 220   return 0;
 221 }
 222
 223 int disorder_playlist_get_share(disorder_client *c, const char *playlist, char **sharep) {
 224   return disorder_simple(c, sharep, "playlist-get-share", playlist, (char *)NULL);
 225 }
 226
 227 int disorder_playlist_lock(disorder_client *c, const char *playlist) {
 228   return disorder_simple(c, NULL, "playlist-lock", playlist, (char *)NULL);
 229 }
 230
 231 int disorder_playlist_set(disorder_client *c, const char *playlist, char **tracks, int ntracks) {
 232   return disorder_simple(c, NULL, "playlist-set", playlist, disorder__body, tracks, ntracks, (char *)NULL);
 233 }
 234
 235 int disorder_playlist_set_share(disorder_client *c, const char *playlist, const char *share) {
 236   return disorder_simple(c, NULL, "playlist-set-share", playlist, share, (char *)NULL);
 237 }
 238
 239 int disorder_playlist_unlock(disorder_client *c) {
 240   return disorder_simple(c, NULL, "playlist-unlock", (char *)NULL);
 241 }
 242
 243 int disorder_playlists(disorder_client *c, char ***playlistsp, int *nplaylistsp) {
 244   int rc = disorder_simple(c, NULL, "playlists", (char *)NULL);
 245   if(rc)
 246     return rc;
 247   if(readlist(c, playlistsp, nplaylistsp))
 248     return -1;
 249   return 0;
 250 }
 251
 252 int disorder_prefs(disorder_client *c, const char *track, struct kvp **prefsp) {
 253   return pairlist(c, prefsp, "prefs", track, (char *)NULL);
 254 }
 255
 256 int disorder_queue(disorder_client *c, struct queue_entry **queuep) {
 257   int rc = disorder_simple(c, NULL, "queue", (char *)NULL);
 258   if(rc)
 259     return rc;
 260   if(readqueue(c, queuep))
 261     return -1;
 262   return 0;
 263 }
 264
 265 int disorder_random_disable(disorder_client *c) {
 266   return disorder_simple(c, NULL, "random-disable", (char *)NULL);
 267 }
 268
 269 int disorder_random_enable(disorder_client *c) {
 270   return disorder_simple(c, NULL, "random-enable", (char *)NULL);
 271 }
 272
 273 int disorder_random_enabled(disorder_client *c, int *enabledp) {
 274   char **v;
 275   int nv, rc = disorder_simple_split(c, &v, &nv, 1, "random-enabled", (char *)NULL);
 276   if(rc)
 277     return rc;
 278   if(boolean("random-enabled", v[0], enabledp))
 279     return -1;
 280   free_strings(nv, v);
 281   return 0;
 282 }
 283
 284 int disorder_recent(disorder_client *c, struct queue_entry **recentp) {
 285   int rc = disorder_simple(c, NULL, "recent", (char *)NULL);
 286   if(rc)
 287     return rc;
 288   if(readqueue(c, recentp))
 289     return -1;
 290   return 0;
 291 }
 292
 293 int disorder_reconfigure(disorder_client *c) {
 294   return disorder_simple(c, NULL, "reconfigure", (char *)NULL);
 295 }
 296
 297 int disorder_register(disorder_client *c, const char *username, const char *password, const char *email, char **confirmationp) {
 298   char **v;
 299   int nv, rc = disorder_simple_split(c, &v, &nv, 1, "register", username, password, email, (char *)NULL);
 300   if(rc)
 301     return rc;
 302   *confirmationp = v[0];
 303   v[0] = NULL;
 304   free_strings(nv, v);
 305   return 0;
 306 }
 307
 308 int disorder_reminder(disorder_client *c, const char *username) {
 309   return disorder_simple(c, NULL, "reminder", username, (char *)NULL);
 310 }
 311
 312 int disorder_remove(disorder_client *c, const char *id) {
 313   return disorder_simple(c, NULL, "remove", id, (char *)NULL);
 314 }
 315
 316 int disorder_rescan(disorder_client *c) {
 317   return disorder_simple(c, NULL, "rescan", (char *)NULL);
 318 }
 319
 320 int disorder_resolve(disorder_client *c, const char *track, char **resolvedp) {
 321   char **v;
 322   int nv, rc = disorder_simple_split(c, &v, &nv, 1, "resolve", track, (char *)NULL);
 323   if(rc)
 324     return rc;
 325   *resolvedp = v[0];
 326   v[0] = NULL;
 327   free_strings(nv, v);
 328   return 0;
 329 }
 330
 331 int disorder_resume(disorder_client *c) {
 332   return disorder_simple(c, NULL, "resume", (char *)NULL);
 333 }
 334
 335 int disorder_revoke(disorder_client *c) {
 336   return disorder_simple(c, NULL, "revoke", (char *)NULL);
 337 }
 338
 339 int disorder_rtp_address(disorder_client *c, char **addressp, char **portp) {
 340   char **v;
 341   int nv, rc = disorder_simple_split(c, &v, &nv, 2, "rtp-address", (char *)NULL);
 342   if(rc)
 343     return rc;
 344   *addressp = v[0];
 345   v[0] = NULL;
 346   *portp = v[1];
 347   v[1] = NULL;
 348   free_strings(nv, v);
 349   return 0;
 350 }
 351
 352 int disorder_scratch(disorder_client *c, const char *id) {
 353   return disorder_simple(c, NULL, "scratch", id, (char *)NULL);
 354 }
 355
 356 int disorder_schedule_add_play(disorder_client *c, time_t when, const char *priority, const char *track) {
 357   return disorder_simple(c, NULL, "schedule-add", disorder__time, when, priority, "play", track, (char *)NULL);
 358 }
 359
 360 int disorder_schedule_add_set_global(disorder_client *c, time_t when, const char *priority, const char *pref, const char *value) {
 361   return disorder_simple(c, NULL, "schedule-add", disorder__time, when, priority, "set-global", pref, value, (char *)NULL);
 362 }
 363
 364 int disorder_schedule_add_unset_global(disorder_client *c, time_t when, const char *priority, const char *pref) {
 365   return disorder_simple(c, NULL, "schedule-add", disorder__time, when, priority, "set-global", pref, (char *)NULL);
 366 }
 367
 368 int disorder_schedule_del(disorder_client *c, const char *event) {
 369   return disorder_simple(c, NULL, "schedule-del", event, (char *)NULL);
 370 }
 371
 372 int disorder_schedule_get(disorder_client *c, const char *id, struct kvp **actiondatap) {
 373   return pairlist(c, actiondatap, "schedule-get", id, (char *)NULL);
 374 }
 375
 376 int disorder_schedule_list(disorder_client *c, char ***idsp, int *nidsp) {
 377   int rc = disorder_simple(c, NULL, "schedule-list", (char *)NULL);
 378   if(rc)
 379     return rc;
 380   if(readlist(c, idsp, nidsp))
 381     return -1;
 382   return 0;
 383 }
 384
 385 int disorder_search(disorder_client *c, const char *terms, char ***tracksp, int *ntracksp) {
 386   int rc = disorder_simple(c, NULL, "search", terms, (char *)NULL);
 387   if(rc)
 388     return rc;
 389   if(readlist(c, tracksp, ntracksp))
 390     return -1;
 391   return 0;
 392 }
 393
 394 int disorder_set(disorder_client *c, const char *track, const char *pref, const char *value) {
 395   return disorder_simple(c, NULL, "set", track, pref, value, (char *)NULL);
 396 }
 397
 398 int disorder_set_global(disorder_client *c, const char *pref, const char *value) {
 399   return disorder_simple(c, NULL, "set-global", pref, value, (char *)NULL);
 400 }
 401
 402 int disorder_shutdown(disorder_client *c) {
 403   return disorder_simple(c, NULL, "shutdown", (char *)NULL);
 404 }
 405
 406 int disorder_stats(disorder_client *c, char ***statsp, int *nstatsp) {
 407   int rc = disorder_simple(c, NULL, "stats", (char *)NULL);
 408   if(rc)
 409     return rc;
 410   if(readlist(c, statsp, nstatsp))
 411     return -1;
 412   return 0;
 413 }
 414
 415 int disorder_tags(disorder_client *c, char ***tagsp, int *ntagsp) {
 416   int rc = disorder_simple(c, NULL, "tags", (char *)NULL);
 417   if(rc)
 418     return rc;
 419   if(readlist(c, tagsp, ntagsp))
 420     return -1;
 421   return 0;
 422 }
 423
 424 int disorder_unset(disorder_client *c, const char *track, const char *pref) {
 425   return disorder_simple(c, NULL, "unset", track, pref, (char *)NULL);
 426 }
 427
 428 int disorder_unset_global(disorder_client *c, const char *pref) {
 429   return disorder_simple(c, NULL, "unset-global", pref, (char *)NULL);
 430 }
 431
 432 int disorder_userinfo(disorder_client *c, const char *username, const char *property, char **valuep) {
 433   char **v;
 434   int nv, rc = disorder_simple_split(c, &v, &nv, 1, "userinfo", username, property, (char *)NULL);
 435   if(rc)
 436     return rc;
 437   *valuep = v[0];
 438   v[0] = NULL;
 439   free_strings(nv, v);
 440   return 0;
 441 }
 442
 443 int disorder_users(disorder_client *c, char ***usersp, int *nusersp) {
 444   int rc = disorder_simple(c, NULL, "users", (char *)NULL);
 445   if(rc)
 446     return rc;
 447   if(readlist(c, usersp, nusersp))
 448     return -1;
 449   return 0;
 450 }
 451
 452 int disorder_version(disorder_client *c, char **versionp) {
 453   char **v;
 454   int nv, rc = disorder_simple_split(c, &v, &nv, 1, "version", (char *)NULL);
 455   if(rc)
 456     return rc;
 457   *versionp = v[0];
 458   v[0] = NULL;
 459   free_strings(nv, v);
 460   return 0;
 461 }
 462
 463 int disorder_set_volume(disorder_client *c, long left, long right) {
 464   return disorder_simple(c, NULL, "volume", disorder__integer, left, disorder__integer, right, (char *)NULL);
 465 }
 466
 467 int disorder_get_volume(disorder_client *c, long *leftp, long *rightp) {
 468   char **v;
 469   int nv, rc = disorder_simple_split(c, &v, &nv, 2, "volume", (char *)NULL);
 470   if(rc)
 471     return rc;
 472   *leftp = atol(v[0]);
 473   *rightp = atol(v[1]);
 474   free_strings(nv, v);
 475   return 0;
 476 }
 477