« back to all changes in this revision
Viewing changes to src/libpiano/piano.c
- browse files at revision 17
- compare with another revision
- download diff
- download tarball
- view history from revision 17
- Committer: Package Import Robot
- Author(s): Luke Faraone
- Date: 2012-05-06 14:24:34 UTC
- mfrom: (1.3.9)
- Revision ID: package-import@ubuntu.com-20120506142434-74kwucnyp97msxdi
Tags: 2012.05.06-1
* New upstream version.
- JSON api support (closes: #670483, LP: #988395)
- JSON api support (closes: #670483, LP: #988395)
- files added:
- src/libpiano/request.c
- files removed:
- src/libezxml
- files modified:
- ChangeLog
added
removed
src/libpiano/piano.c
1
1
/*
2
Copyright (c) 2008-2011
2
Copyright (c) 2008-2012
3
3
Lars-Dominik Braun <lars@6xq.net>
4
4
5
5
Permission is hereby granted, free of charge, to any person obtaining a copy
29
29
#include <stdio.h>
30
30
#include <string.h>
31
31
#include <stdlib.h>
32
#include <time.h>
33
32
#include <assert.h>
34
33
#include <stdint.h>
35
34
36
/* needed for urlencode */
37
#include <waitress.h>
38
39
35
#include "piano_private.h"
40
36
#include "piano.h"
41
#include "xml.h"
42
#include "crypt.h"
43
37
#include "config.h"
44
38
45
#define PIANO_PROTOCOL_VERSION "33"
46
#define PIANO_RPC_HOST "www.pandora.com"
47
#define PIANO_RPC_PORT "80"
48
#define PIANO_RPC_PATH "/radio/xmlrpc/v" PIANO_PROTOCOL_VERSION "?"
49
#define PIANO_SEND_BUFFER_SIZE 10000
50
51
39
/* initialize piano handle
52
40
* @param piano handle
53
41
* @return nothing
54
42
*/
55
void PianoInit (PianoHandle_t *ph) {
43
void PianoInit (PianoHandle_t *ph, const char *partnerUser,
44
const char *partnerPassword, const char *device, const char *inkey,
45
const char *outkey) {
56
46
memset (ph, 0, sizeof (*ph));
57
58
/* route-id seems to be random. we're using time anyway... */
59
snprintf (ph->routeId, sizeof (ph->routeId), "%07luP",
60
(unsigned long) time (NULL) % 10000000);
47
ph->partner.user = strdup (partnerUser);
48
ph->partner.password = strdup (partnerPassword);
49
ph->partner.device = strdup (device);
50
51
gcry_cipher_open (&ph->partner.in, GCRY_CIPHER_BLOWFISH,
52
GCRY_CIPHER_MODE_ECB, 0);
53
gcry_cipher_setkey (ph->partner.in, (const unsigned char *) inkey,
54
strlen (inkey));
55
56
gcry_cipher_open (&ph->partner.out, GCRY_CIPHER_BLOWFISH,
57
GCRY_CIPHER_MODE_ECB, 0);
58
gcry_cipher_setkey (ph->partner.out, (const unsigned char *) outkey,
59
strlen (outkey));
61
60
}
62
61
63
62
/* destroy artist linked list
125
124
free (curSong->artist);
126
125
free (curSong->musicId);
127
126
free (curSong->title);
128
free (curSong->userSeed);
129
127
free (curSong->stationId);
130
128
free (curSong->album);
131
free (curSong->artistMusicId);
132
129
free (curSong->feedbackId);
133
130
free (curSong->seedId);
134
131
free (curSong->detailUrl);
163
160
164
161
/* destroy user information
165
162
*/
166
static void PianoDestroyUserInfo (PianoUserInfo_t *user) {
167
free (user->webAuthToken);
163
void PianoDestroyUserInfo (PianoUserInfo_t *user) {
168
164
free (user->authToken);
169
165
free (user->listenerId);
170
166
}
171
167
168
/* destroy partner
169
*/
170
static void PianoDestroyPartner (PianoPartner_t *partner) {
171
free (partner->user);
172
free (partner->password);
173
free (partner->device);
174
free (partner->authToken);
175
gcry_cipher_close (partner->in);
176
gcry_cipher_close (partner->out);
177
memset (partner, 0, sizeof (*partner));
178
}
179
172
180
/* frees the whole piano handle structure
173
181
* @param piano handle
174
182
* @return nothing
176
184
void PianoDestroy (PianoHandle_t *ph) {
177
185
PianoDestroyUserInfo (&ph->user);
178
186
PianoDestroyStations (ph->stations);
187
PianoDestroyPartner (&ph->partner);
179
188
/* destroy genre stations */
180
189
PianoGenreCategory_t *curGenreCat = ph->genreStations, *lastGenreCat;
181
190
while (curGenreCat != NULL) {
197
206
memset (req, 0, sizeof (*req));
198
207
}
199
208
200
/* convert audio format id to string that can be used in xml requests
201
* @param format id
202
* @return constant string
203
*/
204
static const char *PianoAudioFormatToString (PianoAudioFormat_t format) {
205
switch (format) {
206
case PIANO_AF_AACPLUS:
207
return "aacplus";
208
break;
209
210
case PIANO_AF_MP3:
211
return "mp3";
212
break;
213
214
case PIANO_AF_MP3_HI:
215
return "mp3-hifi";
216
break;
217
218
default:
219
return NULL;
220
break;
221
}
222
}
223
224
/* prepare piano request (initializes request type, urlpath and postData)
225
* @param piano handle
226
* @param request structure
227
* @param request type
228
*/
229
PianoReturn_t PianoRequest (PianoHandle_t *ph, PianoRequest_t *req,
230
PianoRequestType_t type) {
231
char xmlSendBuf[PIANO_SEND_BUFFER_SIZE];
232
/* corrected timestamp */
233
time_t timestamp = time (NULL) - ph->timeOffset;
234
235
assert (ph != NULL);
236
assert (req != NULL);
237
238
req->type = type;
239
/* no tls by default */
240
req->secure = false;
241
242
switch (req->type) {
243
case PIANO_REQUEST_LOGIN: {
244
/* authenticate user */
245
PianoRequestDataLogin_t *logindata = req->data;
246
247
assert (logindata != NULL);
248
249
switch (logindata->step) {
250
case 0:
251
snprintf (xmlSendBuf, sizeof (xmlSendBuf),
252
"<?xml version=\"1.0\"?><methodCall>"
253
"<methodName>misc.sync</methodName>"
254
"<params></params></methodCall>");
255
snprintf (req->urlPath, sizeof (req->urlPath), PIANO_RPC_PATH
256
"rid=%s&method=sync", ph->routeId);
257
break;
258
259
case 1: {
260
char *xmlencodedPassword = NULL;
261
262
req->secure = true;
263
264
/* username == email address does not contain &,<,>," */
265
if ((xmlencodedPassword =
266
PianoXmlEncodeString (logindata->password)) ==
267
NULL) {
268
return PIANO_RET_OUT_OF_MEMORY;
269
}
270
271
snprintf (xmlSendBuf, sizeof (xmlSendBuf),
272
"<?xml version=\"1.0\"?><methodCall>"
273
"<methodName>listener.authenticateListener</methodName>"
274
"<params><param><value><int>%lu</int></value></param>"
275
/* user */
276
"<param><value><string>%s</string></value></param>"
277
/* password */
278
"<param><value><string>%s</string></value></param>"
279
/* vendor */
280
"<param><value><string>html5tuner</string></value></param>"
281
"<param><value><string/></value></param>"
282
"<param><value><string/></value></param>"
283
"<param><value><string>HTML5</string></value></param>"
284
"<param><value><boolean>1</boolean></value></param>"
285
"</params></methodCall>", (unsigned long) timestamp,
286
logindata->user, xmlencodedPassword);
287
snprintf (req->urlPath, sizeof (req->urlPath), PIANO_RPC_PATH
288
"rid=%s&method=authenticateListener", ph->routeId);
289
290
free (xmlencodedPassword);
291
break;
292
}
293
}
294
break;
295
}
296
297
case PIANO_REQUEST_GET_STATIONS:
298
/* get stations, user must be authenticated */
299
assert (ph->user.listenerId != NULL);
300
301
snprintf (xmlSendBuf, sizeof (xmlSendBuf), "<?xml version=\"1.0\"?>"
302
"<methodCall><methodName>station.getStations</methodName>"
303
"<params><param><value><int>%lu</int></value></param>"
304
"<param><value><string>%s</string></value></param>"
305
"</params></methodCall>", (unsigned long) timestamp,
306
ph->user.authToken);
307
snprintf (req->urlPath, sizeof (req->urlPath), PIANO_RPC_PATH
308
"rid=%s&lid=%s&method=getStations", ph->routeId,
309
ph->user.listenerId);
310
break;
311
312
case PIANO_REQUEST_GET_PLAYLIST: {
313
/* get playlist for specified station */
314
PianoRequestDataGetPlaylist_t *reqData = req->data;
315
316
assert (reqData != NULL);
317
assert (reqData->station != NULL);
318
assert (reqData->station->id != NULL);
319
assert (reqData->format != PIANO_AF_UNKNOWN);
320
321
snprintf (xmlSendBuf, sizeof (xmlSendBuf), "<?xml version=\"1.0\"?>"
322
"<methodCall><methodName>playlist.getFragment</methodName>"
323
"<params><param><value><int>%lu</int></value></param>"
324
/* auth token */
325
"<param><value><string>%s</string></value></param>"
326
/* station id */
327
"<param><value><string>%s</string></value></param>"
328
/* total listening time */
329
"<param><value><string>0</string></value></param>"
330
/* time since last session */
331
"<param><value><string></string></value></param>"
332
/* tracking code */
333
"<param><value><string></string></value></param>"
334
/* audio format */
335
"<param><value><string>%s</string></value></param>"
336
/* delta listening time */
337
"<param><value><string>0</string></value></param>"
338
/* listening timestamp */
339
"<param><value><string>0</string></value></param>"
340
"</params></methodCall>", (unsigned long) timestamp,
341
ph->user.authToken, reqData->station->id,
342
PianoAudioFormatToString (reqData->format));
343
snprintf (req->urlPath, sizeof (req->urlPath), PIANO_RPC_PATH
344
"rid=%s&lid=%s&method=getFragment&arg1=%s&arg2=0"
345
"&arg3=&arg4=&arg5=%s&arg6=0&arg7=0", ph->routeId,
346
ph->user.listenerId, reqData->station->id,
347
PianoAudioFormatToString (reqData->format));
348
break;
349
}
350
351
case PIANO_REQUEST_ADD_FEEDBACK: {
352
/* low-level, don't use directly (see _RATE_SONG and _MOVE_SONG) */
353
PianoRequestDataAddFeedback_t *reqData = req->data;
354
355
assert (reqData != NULL);
356
assert (reqData->stationId != NULL);
357
assert (reqData->rating != PIANO_RATE_NONE);
358
359
snprintf (xmlSendBuf, sizeof (xmlSendBuf), "<?xml version=\"1.0\"?>"
360
"<methodCall><methodName>station.addFeedback</methodName>"
361
"<params><param><value><int>%lu</int></value></param>"
362
/* auth token */
363
"<param><value><string>%s</string></value></param>"
364
/* station id */
365
"<param><value><string>%s</string></value></param>"
366
/* track token */
367
"<param><value><string>%s</string></value></param>"
368
/* positive */
369
"<param><value><boolean>%i</boolean></value></param>"
370
"</params></methodCall>", (unsigned long) timestamp,
371
ph->user.authToken, reqData->stationId, reqData->trackToken,
372
(reqData->rating == PIANO_RATE_LOVE) ? 1 : 0);
373
snprintf (req->urlPath, sizeof (req->urlPath), PIANO_RPC_PATH
374
"rid=%s&lid=%s&method=addFeedback&arg1=%s&arg2=%s"
375
"&arg3=%s",
376
ph->routeId, ph->user.listenerId, reqData->stationId,
377
reqData->trackToken,
378
(reqData->rating == PIANO_RATE_LOVE) ? "true" : "false");
379
break;
380
}
381
382
case PIANO_REQUEST_RENAME_STATION: {
383
/* rename stations */
384
PianoRequestDataRenameStation_t *reqData = req->data;
385
char *urlencodedNewName, *xmlencodedNewName;
386
387
assert (reqData != NULL);
388
assert (reqData->station != NULL);
389
assert (reqData->newName != NULL);
390
391
if ((xmlencodedNewName = PianoXmlEncodeString (reqData->newName)) == NULL) {
392
return PIANO_RET_OUT_OF_MEMORY;
393
}
394
urlencodedNewName = WaitressUrlEncode (reqData->newName);
395
396
snprintf (xmlSendBuf, sizeof (xmlSendBuf), "<?xml version=\"1.0\"?>"
397
"<methodCall><methodName>station.setStationName</methodName>"
398
"<params><param><value><int>%lu</int></value></param>"
399
/* auth token */
400
"<param><value><string>%s</string></value></param>"
401
/* station id */
402
"<param><value><string>%s</string></value></param>"
403
/* new name */
404
"<param><value><string>%s</string></value></param>"
405
"</params></methodCall>", (unsigned long) timestamp,
406
ph->user.authToken, reqData->station->id,
407
xmlencodedNewName);
408
snprintf (req->urlPath, sizeof (req->urlPath), PIANO_RPC_PATH
409
"rid=%s&lid=%s&method=setStationName&arg1=%s&arg2=%s",
410
ph->routeId, ph->user.listenerId, reqData->station->id,
411
urlencodedNewName);
412
413
free (urlencodedNewName);
414
free (xmlencodedNewName);
415
break;
416
}
417
418
case PIANO_REQUEST_DELETE_STATION: {
419
/* delete station */
420
PianoStation_t *station = req->data;
421
422
assert (station != NULL);
423
424
snprintf (xmlSendBuf, sizeof (xmlSendBuf), "<?xml version=\"1.0\"?>"
425
"<methodCall><methodName>station.removeStation</methodName>"
426
"<params><param><value><int>%lu</int></value></param>"
427
/* auth token */
428
"<param><value><string>%s</string></value></param>"
429
/* station id */
430
"<param><value><string>%s</string></value></param>"
431
"</params></methodCall>", (unsigned long) timestamp,
432
ph->user.authToken, station->id);
433
snprintf (req->urlPath, sizeof (req->urlPath), PIANO_RPC_PATH
434
"rid=%s&lid=%s&method=removeStation&arg1=%s", ph->routeId,
435
ph->user.listenerId, station->id);
436
break;
437
}
438
439
case PIANO_REQUEST_SEARCH: {
440
/* search for artist/song title */
441
PianoRequestDataSearch_t *reqData = req->data;
442
char *xmlencodedSearchStr, *urlencodedSearchStr;
443
444
assert (reqData != NULL);
445
assert (reqData->searchStr != NULL);
446
447
if ((xmlencodedSearchStr = PianoXmlEncodeString (reqData->searchStr)) == NULL) {
448
return PIANO_RET_OUT_OF_MEMORY;
449
}
450
urlencodedSearchStr = WaitressUrlEncode (reqData->searchStr);
451
452
snprintf (xmlSendBuf, sizeof (xmlSendBuf), "<?xml version=\"1.0\"?>"
453
"<methodCall><methodName>music.search</methodName>"
454
"<params><param><value><int>%lu</int></value></param>"
455
/* auth token */
456
"<param><value><string>%s</string></value></param>"
457
/* search string */
458
"<param><value><string>%s</string></value></param>"
459
"</params></methodCall>", (unsigned long) timestamp,
460
ph->user.authToken, xmlencodedSearchStr);
461
snprintf (req->urlPath, sizeof (req->urlPath), PIANO_RPC_PATH
462
"rid=%s&lid=%s&method=search&arg1=%s", ph->routeId,
463
ph->user.listenerId, urlencodedSearchStr);
464
465
free (urlencodedSearchStr);
466
free (xmlencodedSearchStr);
467
break;
468
}
469
470
case PIANO_REQUEST_CREATE_STATION: {
471
/* create new station from specified musicid (type=mi, get one by
472
* performing a search) or shared station id (type=sh) */
473
PianoRequestDataCreateStation_t *reqData = req->data;
474
475
assert (reqData != NULL);
476
assert (reqData->id != NULL);
477
assert (reqData->type != NULL);
478
479
snprintf (xmlSendBuf, sizeof (xmlSendBuf), "<?xml version=\"1.0\"?>"
480
"<methodCall><methodName>station.createStation</methodName>"
481
"<params><param><value><int>%lu</int></value></param>"
482
/* auth token */
483
"<param><value><string>%s</string></value></param>"
484
/* music id */
485
"<param><value><string>%s%s</string></value></param>"
486
/* empty */
487
"<param><value><string></string></value></param>"
488
"</params></methodCall>", (unsigned long) timestamp,
489
ph->user.authToken, reqData->type, reqData->id);
490
491
snprintf (req->urlPath, sizeof (req->urlPath), PIANO_RPC_PATH
492
"rid=%s&lid=%s&method=createStation&arg1=%s%s&arg2=", ph->routeId,
493
ph->user.listenerId, reqData->type, reqData->id);
494
break;
495
}
496
497
case PIANO_REQUEST_ADD_SEED: {
498
/* add another seed to specified station */
499
PianoRequestDataAddSeed_t *reqData = req->data;
500
501
assert (reqData != NULL);
502
assert (reqData->station != NULL);
503
assert (reqData->musicId != NULL);
504
505
snprintf (xmlSendBuf, sizeof (xmlSendBuf), "<?xml version=\"1.0\"?>"
506
"<methodCall><methodName>station.addSeed</methodName><params>"
507
"<param><value><int>%lu</int></value></param>"
508
/* auth token */
509
"<param><value><string>%s</string></value></param>"
510
/* station id */
511
"<param><value><string>%s</string></value></param>"
512
/* music id */
513
"<param><value><string>%s</string></value></param>"
514
"</params></methodCall>", (unsigned long) timestamp,
515
ph->user.authToken, reqData->station->id, reqData->musicId);
516
snprintf (req->urlPath, sizeof (req->urlPath), PIANO_RPC_PATH
517
"rid=%s&lid=%s&method=addSeed&arg1=%s&arg2=%s", ph->routeId,
518
ph->user.listenerId, reqData->station->id, reqData->musicId);
519
break;
520
}
521
522
case PIANO_REQUEST_ADD_TIRED_SONG: {
523
/* ban song for a month from all stations */
524
PianoSong_t *song = req->data;
525
526
assert (song != NULL);
527
528
snprintf (xmlSendBuf, sizeof (xmlSendBuf), "<?xml version=\"1.0\"?>"
529
"<methodCall><methodName>listener.addTiredSong</methodName><params>"
530
"<param><value><int>%lu</int></value></param>"
531
"<param><value><string>%s</string></value></param>"
532
/* key */
533
"<param><value><string>%s</string></value></param>"
534
/* user seed */
535
"<param><value><string>%s</string></value></param>"
536
/* station id */
537
"<param><value><string>%s</string></value></param>"
538
"</params></methodCall>", (unsigned long) timestamp,
539
ph->user.authToken,
540
(song->musicId == NULL) ? "" : song->musicId,
541
(song->userSeed == NULL) ? "" : song->userSeed,
542
song->stationId);
543
snprintf (req->urlPath, sizeof (req->urlPath), PIANO_RPC_PATH
544
"rid=%s&lid=%s&method=addTiredSong&arg1=%s&arg2=%s&arg3=%s",
545
ph->routeId, ph->user.listenerId,
546
(song->musicId == NULL) ? "" : song->musicId,
547
(song->userSeed == NULL) ? "" : song->userSeed,
548
song->stationId);
549
break;
550
}
551
552
case PIANO_REQUEST_SET_QUICKMIX: {
553
/* select stations included in quickmix (see useQuickMix flag of
554
* PianoStation_t) */
555
char valueBuf[1000], urlArgBuf[1000];
556
PianoStation_t *curStation = ph->stations;
557
558
memset (urlArgBuf, 0, sizeof (urlArgBuf));
559
snprintf (xmlSendBuf, sizeof (xmlSendBuf), "<?xml version=\"1.0\"?>"
560
"<methodCall><methodName>station.setQuickMix</methodName><params>"
561
"<param><value><int>%lu</int></value></param>"
562
"<param><value><string>%s</string></value></param>"
563
/* quick mix type */
564
"<param><value><string>RANDOM</string></value></param>"
565
"<param><value><array><data>", (unsigned long) timestamp,
566
ph->user.authToken);
567
while (curStation != NULL) {
568
/* quick mix can't contain itself */
569
if (!curStation->useQuickMix || curStation->isQuickMix) {
570
curStation = curStation->next;
571
continue;
572
}
573
/* append to xml doc */
574
snprintf (valueBuf, sizeof (valueBuf),
575
"<value><string>%s</string></value>", curStation->id);
576
strncat (xmlSendBuf, valueBuf, sizeof (xmlSendBuf) -
577
strlen (xmlSendBuf) - 1);
578
/* append to url arg */
579
strncat (urlArgBuf, curStation->id, sizeof (urlArgBuf) -
580
strlen (urlArgBuf) - 1);
581
curStation = curStation->next;
582
/* if not last item: append "," */
583
if (curStation != NULL) {
584
strncat (urlArgBuf, "%2C", sizeof (urlArgBuf) -
585
strlen (urlArgBuf) - 1);
586
}
587
}
588
strncat (xmlSendBuf,
589
"</data></array></value></param>"
590
/* empty */
591
"<param><value><string></string></value></param>"
592
/* empty */
593
"<param><value><string></string></value></param>"
594
"</params></methodCall>",
595
sizeof (xmlSendBuf) - strlen (xmlSendBuf) - 1);
596
597
snprintf (req->urlPath, sizeof (req->urlPath), PIANO_RPC_PATH
598
"rid=%s&lid=%s&method=setQuickMix&arg1=RANDOM&arg2=%s&arg3=&arg4=",
599
ph->routeId, ph->user.listenerId, urlArgBuf);
600
break;
601
}
602
603
case PIANO_REQUEST_GET_GENRE_STATIONS:
604
/* receive list of pandora's genre stations */
605
xmlSendBuf[0] = '\0';
606
snprintf (req->urlPath, sizeof (req->urlPath), "/xml/genre?r=%lu",
607
(unsigned long) timestamp);
608
break;
609
610
case PIANO_REQUEST_TRANSFORM_STATION: {
611
/* transform shared station into private */
612
PianoStation_t *station = req->data;
613
614
assert (station != NULL);
615
616
snprintf (xmlSendBuf, sizeof (xmlSendBuf), "<?xml version=\"1.0\"?>"
617
"<methodCall><methodName>station.transformShared</methodName>"
618
"<params><param><value><int>%lu</int></value></param>"
619
/* auth token */
620
"<param><value><string>%s</string></value></param>"
621
/* station id */
622
"<param><value><string>%s</string></value></param>"
623
"</params></methodCall>", (unsigned long) timestamp,
624
ph->user.authToken, station->id);
625
snprintf (req->urlPath, sizeof (req->urlPath), PIANO_RPC_PATH
626
"rid=%s&lid=%s&method=transformShared&arg1=%s", ph->routeId,
627
ph->user.listenerId, station->id);
628
break;
629
}
630
631
case PIANO_REQUEST_EXPLAIN: {
632
/* explain why particular song was played */
633
PianoRequestDataExplain_t *reqData = req->data;
634
635
assert (reqData != NULL);
636
assert (reqData->song != NULL);
637
638
snprintf (xmlSendBuf, sizeof (xmlSendBuf), "<?xml version=\"1.0\"?>"
639
"<methodCall><methodName>playlist.narrative</methodName>"
640
"<params><param><value><int>%lu</int></value></param>"
641
/* auth token */
642
"<param><value><string>%s</string></value></param>"
643
/* station id */
644
"<param><value><string>%s</string></value></param>"
645
/* music id */
646
"<param><value><string>%s</string></value></param>"
647
"</params></methodCall>", (unsigned long) timestamp,
648
ph->user.authToken, reqData->song->stationId,
649
reqData->song->musicId);
650
snprintf (req->urlPath, sizeof (req->urlPath), PIANO_RPC_PATH
651
"rid=%s&lid=%s&method=narrative&arg1=%s&arg2=%s",
652
ph->routeId, ph->user.listenerId, reqData->song->stationId,
653
reqData->song->musicId);
654
break;
655
}
656
657
case PIANO_REQUEST_GET_SEED_SUGGESTIONS: {
658
/* find similar artists */
659
PianoRequestDataGetSeedSuggestions_t *reqData = req->data;
660
661
assert (reqData != NULL);
662
assert (reqData->musicId != NULL);
663
assert (reqData->max != 0);
664
665
snprintf (xmlSendBuf, sizeof (xmlSendBuf), "<?xml version=\"1.0\"?>"
666
"<methodCall><methodName>music.getSeedSuggestions</methodName>"
667
"<params><param><value><int>%lu</int></value></param>"
668
/* auth token */
669
"<param><value><string>%s</string></value></param>"
670
/* station id */
671
"<param><value><string>%s</string></value></param>"
672
/* seed music id */
673
"<param><value><string>%s</string></value></param>"
674
/* max */
675
"<param><value><int>%u</int></value></param>"
676
"</params></methodCall>", (unsigned long) timestamp,
677
ph->user.authToken, reqData->station->id, reqData->musicId,
678
reqData->max);
679
snprintf (req->urlPath, sizeof (req->urlPath), PIANO_RPC_PATH
680
"rid=%s&lid=%s&method=getSeedSuggestions&arg1=%s&arg2=%u",
681
ph->routeId, ph->user.listenerId, reqData->musicId, reqData->max);
682
break;
683
}
684
685
case PIANO_REQUEST_BOOKMARK_SONG: {
686
/* bookmark song */
687
PianoSong_t *song = req->data;
688
689
assert (song != NULL);
690
691
snprintf (xmlSendBuf, sizeof (xmlSendBuf), "<?xml version=\"1.0\"?>"
692
"<methodCall><methodName>station.createBookmark</methodName>"
693
"<params><param><value><int>%lu</int></value></param>"
694
/* auth token */
695
"<param><value><string>%s</string></value></param>"
696
/* station id */
697
"<param><value><string>%s</string></value></param>"
698
/* music id */
699
"<param><value><string>%s</string></value></param>"
700
"</params></methodCall>", (unsigned long) timestamp,
701
ph->user.authToken, song->stationId, song->musicId);
702
snprintf (req->urlPath, sizeof (req->urlPath), PIANO_RPC_PATH
703
"rid=%s&lid=%s&method=createBookmark&arg1=%s&arg2=%s",
704
ph->routeId, ph->user.listenerId, song->stationId,
705
song->musicId);
706
break;
707
}
708
709
case PIANO_REQUEST_BOOKMARK_ARTIST: {
710
/* bookmark artist */
711
PianoSong_t *song = req->data;
712
713
assert (song != NULL);
714
715
snprintf (xmlSendBuf, sizeof (xmlSendBuf), "<?xml version=\"1.0\"?>"
716
"<methodCall><methodName>station.createArtistBookmark</methodName>"
717
"<params><param><value><int>%lu</int></value></param>"
718
/* auth token */
719
"<param><value><string>%s</string></value></param>"
720
/* music id */
721
"<param><value><string>%s</string></value></param>"
722
"</params></methodCall>", (unsigned long) timestamp,
723
ph->user.authToken, song->artistMusicId);
724
snprintf (req->urlPath, sizeof (req->urlPath), PIANO_RPC_PATH
725
"rid=%s&lid=%s&method=createArtistBookmark&arg1=%s",
726
ph->routeId, ph->user.listenerId, song->artistMusicId);
727
break;
728
}
729
730
case PIANO_REQUEST_GET_STATION_INFO: {
731
/* get station information (seeds and feedback) */
732
PianoRequestDataGetStationInfo_t *reqData = req->data;
733
734
assert (reqData != NULL);
735
assert (reqData->station != NULL);
736
737
snprintf (xmlSendBuf, sizeof (xmlSendBuf), "<?xml version=\"1.0\"?>"
738
"<methodCall><methodName>station.getStation</methodName>"
739
"<params><param><value><int>%lu</int></value></param>"
740
/* auth token */
741
"<param><value><string>%s</string></value></param>"
742
/* station id */
743
"<param><value><string>%s</string></value></param>"
744
"</params></methodCall>", (unsigned long) timestamp,
745
ph->user.authToken, reqData->station->id);
746
snprintf (req->urlPath, sizeof (req->urlPath), PIANO_RPC_PATH
747
"rid=%s&lid=%s&method=getStation&arg1=%s",
748
ph->routeId, ph->user.listenerId, reqData->station->id);
749
break;
750
}
751
752
case PIANO_REQUEST_DELETE_FEEDBACK: {
753
PianoSong_t *song = req->data;
754
755
assert (song != NULL);
756
757
snprintf (xmlSendBuf, sizeof (xmlSendBuf), "<?xml version=\"1.0\"?>"
758
"<methodCall><methodName>station.deleteFeedback</methodName>"
759
"<params><param><value><int>%lu</int></value></param>"
760
/* auth token */
761
"<param><value><string>%s</string></value></param>"
762
/* feedback id */
763
"<param><value><string>%s</string></value></param>"
764
"</params></methodCall>", (unsigned long) timestamp,
765
ph->user.authToken, song->feedbackId);
766
snprintf (req->urlPath, sizeof (req->urlPath), PIANO_RPC_PATH
767
"rid=%s&lid=%s&method=deleteFeedback&arg1=%s",
768
ph->routeId, ph->user.listenerId, song->feedbackId);
769
break;
770
}
771
772
case PIANO_REQUEST_DELETE_SEED: {
773
PianoRequestDataDeleteSeed_t *reqData = req->data;
774
char *seedId = NULL;
775
776
assert (reqData != NULL);
777
assert (reqData->song != NULL || reqData->artist != NULL ||
778
reqData->station != NULL);
779
780
if (reqData->song != NULL) {
781
seedId = reqData->song->seedId;
782
} else if (reqData->artist != NULL) {
783
seedId = reqData->artist->seedId;
784
} else if (reqData->station != NULL) {
785
seedId = reqData->station->seedId;
786
}
787
788
assert (seedId != NULL);
789
790
snprintf (xmlSendBuf, sizeof (xmlSendBuf), "<?xml version=\"1.0\"?>"
791
"<methodCall><methodName>station.deleteSeed</methodName>"
792
"<params><param><value><int>%lu</int></value></param>"
793
/* auth token */
794
"<param><value><string>%s</string></value></param>"
795
/* seed id */
796
"<param><value><string>%s</string></value></param>"
797
"</params></methodCall>", (unsigned long) timestamp,
798
ph->user.authToken, seedId);
799
snprintf (req->urlPath, sizeof (req->urlPath), PIANO_RPC_PATH
800
"rid=%s&lid=%s&method=deleteSeed&arg1=%s",
801
ph->routeId, ph->user.listenerId, seedId);
802
break;
803
}
804
805
/* "high-level" wrapper */
806
case PIANO_REQUEST_RATE_SONG: {
807
/* love/ban song */
808
PianoRequestDataRateSong_t *reqData = req->data;
809
PianoReturn_t pRet;
810
811
assert (reqData != NULL);
812
assert (reqData->song != NULL);
813
assert (reqData->rating != PIANO_RATE_NONE);
814
815
PianoRequestDataAddFeedback_t transformedReqData;
816
transformedReqData.stationId = reqData->song->stationId;
817
transformedReqData.trackToken = reqData->song->trackToken;
818
transformedReqData.rating = reqData->rating;
819
req->data = &transformedReqData;
820
821
/* create request data (url, post data) */
822
pRet = PianoRequest (ph, req, PIANO_REQUEST_ADD_FEEDBACK);
823
/* and reset request type/data */
824
req->type = PIANO_REQUEST_RATE_SONG;
825
req->data = reqData;
826
827
return pRet;
828
break;
829
}
830
831
case PIANO_REQUEST_MOVE_SONG: {
832
/* move song to a different station, needs two requests */
833
PianoRequestDataMoveSong_t *reqData = req->data;
834
PianoRequestDataAddFeedback_t transformedReqData;
835
PianoReturn_t pRet;
836
837
assert (reqData != NULL);
838
assert (reqData->song != NULL);
839
assert (reqData->from != NULL);
840
assert (reqData->to != NULL);
841
assert (reqData->step < 2);
842
843
transformedReqData.trackToken = reqData->song->trackToken;
844
req->data = &transformedReqData;
845
846
switch (reqData->step) {
847
case 0:
848
transformedReqData.stationId = reqData->from->id;
849
transformedReqData.rating = PIANO_RATE_BAN;
850
break;
851
852
case 1:
853
transformedReqData.stationId = reqData->to->id;
854
transformedReqData.rating = PIANO_RATE_LOVE;
855
break;
856
}
857
858
/* create request data (url, post data) */
859
pRet = PianoRequest (ph, req, PIANO_REQUEST_ADD_FEEDBACK);
860
/* and reset request type/data */
861
req->type = PIANO_REQUEST_MOVE_SONG;
862
req->data = reqData;
863
864
return pRet;
865
break;
866
}
867
}
868
869
if ((req->postData = PianoEncryptString (xmlSendBuf)) == NULL) {
870
return PIANO_RET_OUT_OF_MEMORY;
871
}
872
873
return PIANO_RET_OK;
874
}
875
876
/* parse xml response and update data structures/return new data structure
877
* @param piano handle
878
* @param initialized request (expects responseData to be a NUL-terminated
879
* string)
880
*/
881
PianoReturn_t PianoResponse (PianoHandle_t *ph, PianoRequest_t *req) {
882
PianoReturn_t ret = PIANO_RET_ERR;
883
884
assert (ph != NULL);
885
assert (req != NULL);
886
887
switch (req->type) {
888
case PIANO_REQUEST_LOGIN: {
889
/* authenticate user */
890
PianoRequestDataLogin_t *reqData = req->data;
891
892
assert (req->responseData != NULL);
893
assert (reqData != NULL);
894
895
switch (reqData->step) {
896
case 0: {
897
char *cryptedTimestamp = NULL;
898
899
assert (req->responseData != NULL);
900
901
/* abusing parseNarrative; has same xml structure */
902
ret = PianoXmlParseNarrative (req->responseData, &cryptedTimestamp);
903
if (cryptedTimestamp != NULL) {
904
unsigned long timestamp = 0;
905
time_t realTimestamp = time (NULL);
906
char *decryptedTimestamp = NULL, *decryptedPos = NULL;
907
unsigned char i = 4;
908
909
if ((decryptedTimestamp = PianoDecryptString (cryptedTimestamp)) != NULL) {
910
decryptedPos = decryptedTimestamp;
911
/* skip four bytes garbage? at beginning */
912
while (i-- > 0 && *decryptedPos++ != '\0');
913
timestamp = strtoul (decryptedPos, NULL, 0);
914
ph->timeOffset = realTimestamp - timestamp;
915
916
free (decryptedTimestamp);
917
}
918
free (cryptedTimestamp);
919
}
920
ret = PIANO_RET_CONTINUE_REQUEST;
921
++reqData->step;
922
break;
923
}
924
925
case 1:
926
/* information exists when reauthenticating, destroy to
927
* avoid memleak */
928
if (ph->user.listenerId != NULL) {
929
PianoDestroyUserInfo (&ph->user);
930
}
931
ret = PianoXmlParseUserinfo (ph, req->responseData);
932
break;
933
}
934
break;
935
}
936
937
case PIANO_REQUEST_GET_STATIONS:
938
/* get stations */
939
assert (req->responseData != NULL);
940
941
ret = PianoXmlParseStations (ph, req->responseData);
942
break;
943
944
case PIANO_REQUEST_GET_PLAYLIST: {
945
/* get playlist, usually four songs */
946
PianoRequestDataGetPlaylist_t *reqData = req->data;
947
948
assert (req->responseData != NULL);
949
assert (reqData != NULL);
950
951
reqData->retPlaylist = NULL;
952
ret = PianoXmlParsePlaylist (ph, req->responseData,
953
&reqData->retPlaylist);
954
break;
955
}
956
957
case PIANO_REQUEST_RATE_SONG:
958
/* love/ban song */
959
assert (req->responseData != NULL);
960
961
ret = PianoXmlParseSimple (req->responseData);
962
if (ret == PIANO_RET_OK) {
963
PianoRequestDataRateSong_t *reqData = req->data;
964
reqData->song->rating = reqData->rating;
965
}
966
break;
967
968
case PIANO_REQUEST_ADD_FEEDBACK:
969
/* never ever use this directly, low-level call */
970
assert (0);
971
break;
972
973
case PIANO_REQUEST_MOVE_SONG: {
974
/* move song to different station */
975
PianoRequestDataMoveSong_t *reqData = req->data;
976
977
assert (req->responseData != NULL);
978
assert (reqData != NULL);
979
assert (reqData->step < 2);
980
981
ret = PianoXmlParseSimple (req->responseData);
982
if (ret == PIANO_RET_OK && reqData->step == 0) {
983
ret = PIANO_RET_CONTINUE_REQUEST;
984
++reqData->step;
985
}
986
break;
987
}
988
989
case PIANO_REQUEST_RENAME_STATION:
990
/* rename station and update PianoStation_t structure */
991
assert (req->responseData != NULL);
992
993
if ((ret = PianoXmlParseSimple (req->responseData)) == PIANO_RET_OK) {
994
PianoRequestDataRenameStation_t *reqData = req->data;
995
996
assert (reqData != NULL);
997
assert (reqData->station != NULL);
998
assert (reqData->newName != NULL);
999
1000
free (reqData->station->name);
1001
reqData->station->name = strdup (reqData->newName);
1002
}
1003
break;
1004
1005
case PIANO_REQUEST_DELETE_STATION:
1006
/* delete station from server and station list */
1007
assert (req->responseData != NULL);
1008
1009
if ((ret = PianoXmlParseSimple (req->responseData)) == PIANO_RET_OK) {
1010
PianoStation_t *station = req->data;
1011
1012
assert (station != NULL);
1013
1014
/* delete station from local station list */
1015
PianoStation_t *curStation = ph->stations, *lastStation = NULL;
1016
while (curStation != NULL) {
1017
if (curStation == station) {
1018
if (lastStation != NULL) {
1019
lastStation->next = curStation->next;
1020
} else {
1021
/* first station in list */
1022
ph->stations = curStation->next;
1023
}
1024
PianoDestroyStation (curStation);
1025
free (curStation);
1026
break;
1027
}
1028
lastStation = curStation;
1029
curStation = curStation->next;
1030
}
1031
}
1032
break;
1033
1034
case PIANO_REQUEST_SEARCH: {
1035
/* search artist/song */
1036
PianoRequestDataSearch_t *reqData = req->data;
1037
1038
assert (req->responseData != NULL);
1039
assert (reqData != NULL);
1040
1041
ret = PianoXmlParseSearch (req->responseData, &reqData->searchResult);
1042
break;
1043
}
1044
1045
case PIANO_REQUEST_CREATE_STATION: {
1046
/* create station, insert new station into station list on success */
1047
assert (req->responseData != NULL);
1048
1049
ret = PianoXmlParseCreateStation (ph, req->responseData);
1050
break;
1051
}
1052
1053
case PIANO_REQUEST_ADD_SEED: {
1054
/* add seed to station, updates station structure */
1055
PianoRequestDataAddSeed_t *reqData = req->data;
1056
1057
assert (req->responseData != NULL);
1058
assert (reqData != NULL);
1059
assert (reqData->station != NULL);
1060
1061
/* FIXME: update station data instead of replacing them */
1062
ret = PianoXmlParseAddSeed (ph, req->responseData, reqData->station);
1063
break;
1064
}
1065
1066
case PIANO_REQUEST_ADD_TIRED_SONG:
1067
case PIANO_REQUEST_SET_QUICKMIX:
1068
case PIANO_REQUEST_BOOKMARK_SONG:
1069
case PIANO_REQUEST_BOOKMARK_ARTIST:
1070
case PIANO_REQUEST_DELETE_FEEDBACK:
1071
assert (req->responseData != NULL);
1072
1073
ret = PianoXmlParseSimple (req->responseData);
1074
break;
1075
1076
case PIANO_REQUEST_GET_GENRE_STATIONS:
1077
/* get genre stations */
1078
assert (req->responseData != NULL);
1079
1080
ret = PianoXmlParseGenreExplorer (ph, req->responseData);
1081
break;
1082
1083
case PIANO_REQUEST_TRANSFORM_STATION: {
1084
/* transform shared station into private and update isCreator flag */
1085
PianoStation_t *station = req->data;
1086
1087
assert (req->responseData != NULL);
1088
assert (station != NULL);
1089
1090
/* though this call returns a bunch of "new" data only this one is
1091
* changed and important (at the moment) */
1092
if ((ret = PianoXmlParseTranformStation (req->responseData)) ==
1093
PIANO_RET_OK) {
1094
station->isCreator = 1;
1095
}
1096
break;
1097
}
1098
1099
case PIANO_REQUEST_EXPLAIN: {
1100
/* explain why song was selected */
1101
PianoRequestDataExplain_t *reqData = req->data;
1102
1103
assert (req->responseData != NULL);
1104
assert (reqData != NULL);
1105
1106
ret = PianoXmlParseNarrative (req->responseData, &reqData->retExplain);
1107
break;
1108
}
1109
1110
case PIANO_REQUEST_GET_SEED_SUGGESTIONS: {
1111
/* find similar artists */
1112
PianoRequestDataGetSeedSuggestions_t *reqData = req->data;
1113
1114
assert (req->responseData != NULL);
1115
assert (reqData != NULL);
1116
1117
ret = PianoXmlParseSeedSuggestions (req->responseData,
1118
&reqData->searchResult);
1119
break;
1120
}
1121
1122
case PIANO_REQUEST_GET_STATION_INFO: {
1123
/* get station information (seeds and feedback) */
1124
PianoRequestDataGetStationInfo_t *reqData = req->data;
1125
1126
assert (req->responseData != NULL);
1127
assert (reqData != NULL);
1128
1129
ret = PianoXmlParseGetStationInfo (req->responseData,
1130
&reqData->info);
1131
break;
1132
}
1133
1134
case PIANO_REQUEST_DELETE_SEED: {
1135
assert (req->responseData != NULL);
1136
1137
/* dummy function, checks for errors only */
1138
ret = PianoXmlParseTranformStation (req->responseData);
1139
}
1140
}
1141
1142
return ret;
1143
}
1144
1145
209
/* get station from list by id
1146
210
* @param search here
1147
211
* @param search for this
1172
236
return "Unknown.";
1173
237
break;
1174
238
1175
case PIANO_RET_XML_INVALID:
1176
return "Invalid XML.";
1177
break;
1178
1179
case PIANO_RET_AUTH_TOKEN_INVALID:
239
case PIANO_RET_INVALID_RESPONSE:
240
return "Invalid response.";
241
break;
242
243
case PIANO_RET_CONTINUE_REQUEST:
244
/* never shown to the user */
245
assert (0);
246
return "Fix your program.";
247
break;
248
249
case PIANO_RET_OUT_OF_MEMORY:
250
return "Out of memory.";
251
break;
252
253
/* pandora error messages */
254
case PIANO_RET_P_INTERNAL:
255
return "Internal error.";
256
break;
257
258
case PIANO_RET_P_CALL_NOT_ALLOWED:
259
return "Call not allowed.";
260
break;
261
262
case PIANO_RET_P_INVALID_AUTH_TOKEN:
1180
263
return "Invalid auth token.";
1181
264
break;
1182
1183
case PIANO_RET_AUTH_USER_PASSWORD_INVALID:
1184
return "Username and/or password not correct.";
1185
break;
1186
1187
case PIANO_RET_NOT_AUTHORIZED:
1188
return "Not authorized.";
1189
break;
1190
1191
case PIANO_RET_PROTOCOL_INCOMPATIBLE:
1192
return "Protocol incompatible. Please upgrade " PACKAGE ".";
1193
break;
1194
1195
case PIANO_RET_READONLY_MODE:
1196
return "Request cannot be completed at this time, please try "
1197
"again later.";
1198
break;
1199
1200
case PIANO_RET_STATION_CODE_INVALID:
1201
return "Station id is invalid.";
1202
break;
1203
1204
case PIANO_RET_IP_REJECTED:
1205
return "Your ip address was rejected. Please setup a control "
1206
"proxy (see manpage).";
1207
break;
1208
1209
case PIANO_RET_STATION_NONEXISTENT:
265
266
case PIANO_RET_P_MAINTENANCE_MODE:
267
return "Maintenance mode.";
268
break;
269
270
case PIANO_RET_P_MAX_STATIONS_REACHED:
271
return "Max number of stations reached.";
272
break;
273
274
case PIANO_RET_P_READ_ONLY_MODE:
275
return "Read only mode. Try again later.";
276
break;
277
278
case PIANO_RET_P_STATION_DOES_NOT_EXIST:
1210
279
return "Station does not exist.";
1211
280
break;
1212
281
1213
case PIANO_RET_OUT_OF_MEMORY:
1214
return "Out of memory.";
1215
break;
1216
1217
case PIANO_RET_OUT_OF_SYNC:
1218
return "Out of sync. Please correct your system's time.";
1219
break;
1220
1221
case PIANO_RET_PLAYLIST_END:
1222
return "Playlist end.";
1223
break;
1224
1225
case PIANO_RET_QUICKMIX_NOT_PLAYABLE:
1226
return "Quickmix not playable.";
1227
break;
1228
1229
case PIANO_RET_REMOVING_TOO_MANY_SEEDS:
1230
return "Last seed cannot be removed.";
282
case PIANO_RET_P_INVALID_PARTNER_LOGIN:
283
return "Invalid partner login.";
1231
284
break;
1232
285
1233
286
default:
Loggerhead is a web-based interface for Breezy
Version: 2.0.1