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