?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Update - Macedonian Translation by Arangel Angov <arangel@linux.net.mk>
[rhythmbox.git] / daapsharing / rb-daap-share.c
blobfe40480f04e72cb631f5e8f8c45c3189595e4b90
1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
2 *
3 * Implmentation of DAAP (iTunes Music Sharing) sharing
4 *
5 * Copyright (C) 2005 Charles Schmidt <cschmidt2@emich.edu>
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 */
22
23 #include "config.h"
24
25 #include <time.h>
26 #include <string.h>
27
28 #include <glib/gi18n.h>
29 #include <gtk/gtk.h>
30 #include <libsoup/soup.h>
31 #include <libsoup/soup-address.h>
32 #include <libsoup/soup-message.h>
33 #include <libsoup/soup-uri.h>
34 #include <libsoup/soup-server.h>
35 #include <libsoup/soup-server-auth.h>
36 #include <libsoup/soup-server-message.h>
37 #include <libgnomevfs/gnome-vfs.h>
38
39 #include "rb-daap-share.h"
40 #include "rb-daap-structure.h"
41 #include "rb-daap-mdns-publisher.h"
42 #include "rb-daap-dialog.h"
43
44 #include "rb-playlist-source.h"
45 #include "rb-debug.h"
46 #include "eel-gconf-extensions.h"
47 #include "rb-file-helpers.h"
48
49 static void rb_daap_share_set_property (GObject *object,
50 guint prop_id,
51 const GValue *value,
52 GParamSpec *pspec);
53 static void rb_daap_share_get_property (GObject *object,
54 guint prop_id,
55 GValue *value,
56 GParamSpec *pspec);
57 static void rb_daap_share_dispose (GObject *object);
58 static void rb_daap_share_maybe_restart (RBDAAPShare *share);
59 static gboolean rb_daap_share_publish_start (RBDAAPShare *share);
60 static gboolean rb_daap_share_publish_stop (RBDAAPShare *share);
61 static gboolean rb_daap_share_server_start (RBDAAPShare *share);
62 static gboolean rb_daap_share_server_stop (RBDAAPShare *share);
63 static void rb_daap_share_playlist_created (RBPlaylistManager *mgr,
64 RBSource *playlist,
65 RBDAAPShare *share);
66 static void rb_daap_share_process_playlist (RBSource *playlist,
67 RBDAAPShare *share);
68 static void rb_daap_share_playlist_destroyed (RBDAAPShare *share,
69 RBSource *source);
70 static void rb_daap_share_forget_playlist (gpointer data,
71 RBDAAPShare *share);
72
73 #define STANDARD_DAAP_PORT 3689
74
75 /* HTTP chunk size used to send files to clients */
76 #define DAAP_SHARE_CHUNK_SIZE 16384
77
78 typedef enum {
79 RB_DAAP_SHARE_AUTH_METHOD_NONE = 0,
80 RB_DAAP_SHARE_AUTH_METHOD_NAME_AND_PASSWORD = 1,
81 RB_DAAP_SHARE_AUTH_METHOD_PASSWORD = 2
82 } RBDAAPShareAuthMethod;
83
84 struct RBDAAPSharePrivate {
85 gchar *name;
86 guint port;
87 char *password;
88 RBDAAPShareAuthMethod auth_method;
89
90 /* mdns/dns-sd publishing things */
91 gboolean server_active;
92 gboolean published;
93 RBDaapMdnsPublisher *publisher;
94
95 /* http server things */
96 SoupServer *server;
97 guint revision_number;
98
99 GHashTable *session_ids;
100
101 /* db things */
102 RhythmDB *db;
103 RhythmDBEntryType entry_type;
104 gulong entry_added_id;
105 gulong entry_deleted_id;
106 gulong entry_changed_id;
107
108 /* playlist things */
109 RBPlaylistManager *playlist_manager;
110 guint next_playlist_id;
111 GList *playlist_ids; /* contains RBPlaylistIDs */
112 };
113
114 #define RB_DAAP_SHARE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), RB_TYPE_DAAP_SHARE, RBDAAPSharePrivate))
115
116 typedef struct {
117 RBSource *source;
118 gint32 id;
119 } RBPlaylistID;
120
121 enum {
122 PROP_0,
123 PROP_NAME,
124 PROP_PASSWORD,
125 PROP_DB,
126 PROP_PLAYLIST_MANAGER,
127 PROP_ENTRY_TYPE
128 };
129
130 G_DEFINE_TYPE (RBDAAPShare, rb_daap_share, G_TYPE_OBJECT)
131
132 static void
133 rb_daap_share_class_init (RBDAAPShareClass *klass)
134 {
135 GObjectClass *object_class = G_OBJECT_CLASS (klass);
136
137 object_class->get_property = rb_daap_share_get_property;
138 object_class->set_property = rb_daap_share_set_property;
139 object_class->dispose = rb_daap_share_dispose;
140
141 g_object_class_install_property (object_class,
142 PROP_NAME,
143 g_param_spec_string ("name",
144 "Name",
145 "Share Name",
146 NULL,
147 G_PARAM_READWRITE));
148 g_object_class_install_property (object_class,
149 PROP_PASSWORD,
150 g_param_spec_string ("password",
151 "Authentication password",
152 "Authentication password",
153 NULL,
154 G_PARAM_READWRITE));
155 g_object_class_install_property (object_class,
156 PROP_DB,
157 g_param_spec_object ("db",
158 "RhythmDB",
159 "RhythmDB object",
160 RHYTHMDB_TYPE,
161 G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
162 g_object_class_install_property (object_class,
163 PROP_PLAYLIST_MANAGER,
164 g_param_spec_object ("playlist-manager",
165 "Playlist Manager",
166 "Playlist manager object",
167 RB_TYPE_PLAYLIST_MANAGER,
168 G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
169 g_object_class_install_property (object_class,
170 PROP_ENTRY_TYPE,
171 g_param_spec_boxed ("entry-type",
172 "Entry type",
173 "Type of entries to be shared",
174 RHYTHMDB_TYPE_ENTRY_TYPE,
175 G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
176
177 g_type_class_add_private (klass, sizeof (RBDAAPSharePrivate));
178 }
179
180 static void
181 rb_daap_share_set_name (RBDAAPShare *share,
182 const char *name)
183 {
184 GError *error;
185 gboolean res;
186
187 g_return_if_fail (share != NULL);
188
189 g_free (share->priv->name);
190 share->priv->name = g_strdup (name);
191
192 error = NULL;
193 res = rb_daap_mdns_publisher_set_name (share->priv->publisher, name, &error);
194 if (error != NULL) {
195 g_warning ("Unable to change MDNS service name: %s", error->message);
196 g_error_free (error);
197 }
198 }
199
200 static void
201 published_cb (RBDaapMdnsPublisher *publisher,
202 const char *name,
203 RBDAAPShare *share)
204 {
205 if (share->priv->name == NULL || name == NULL) {
206 return;
207 }
208
209 if (strcmp (name, share->priv->name) == 0) {
210 rb_debug ("mDNS publish successful");
211 share->priv->published = TRUE;
212 }
213 }
214
215 static void
216 name_collision_cb (RBDaapMdnsPublisher *publisher,
217 const char *name,
218 RBDAAPShare *share)
219 {
220 char *new_name;
221
222 if (share->priv->name == NULL || name == NULL) {
223 return;
224 }
225
226 if (strcmp (name, share->priv->name) == 0) {
227 rb_debug ("Duplicate share name on mDNS");
228
229 GDK_THREADS_ENTER ();
230 new_name = rb_daap_collision_dialog_new_run (NULL, share->priv->name);
231 GDK_THREADS_LEAVE ();
232
233 rb_daap_share_set_name (share, new_name);
234 g_free (new_name);
235 }
236
237 return;
238 }
239
240 static void
241 rb_daap_share_init (RBDAAPShare *share)
242 {
243 share->priv = RB_DAAP_SHARE_GET_PRIVATE (share);
244
245 share->priv->revision_number = 5;
246
247 share->priv->auth_method = RB_DAAP_SHARE_AUTH_METHOD_NONE;
248 share->priv->publisher = rb_daap_mdns_publisher_new ();
249 g_signal_connect_object (share->priv->publisher,
250 "published",
251 G_CALLBACK (published_cb),
252 share, 0);
253 g_signal_connect_object (share->priv->publisher,
254 "name-collision",
255 G_CALLBACK (name_collision_cb),
256 share, 0);
257
258 }
259
260 static void
261 rb_daap_share_set_password (RBDAAPShare *share,
262 const char *password)
263 {
264 g_return_if_fail (share != NULL);
265
266 if (share->priv->password && password &&
267 strcmp (password, share->priv->password) == 0) {
268 return;
269 }
270
271 g_free (share->priv->password);
272 share->priv->password = g_strdup (password);
273 if (password != NULL) {
274 share->priv->auth_method = RB_DAAP_SHARE_AUTH_METHOD_PASSWORD;
275 } else {
276 share->priv->auth_method = RB_DAAP_SHARE_AUTH_METHOD_NONE;
277 }
278
279 rb_daap_share_maybe_restart (share);
280 }
281
282 static void
283 rb_daap_share_set_db (RBDAAPShare *share,
284 RhythmDB *db)
285 {
286 if (share->priv->db != NULL) {
287 g_object_unref (share->priv->db);
288 }
289
290 share->priv->db = db;
291
292 if (share->priv->db != NULL) {
293 g_object_ref (share->priv->db);
294 }
295 }
296
297 static void
298 rb_daap_share_set_playlist_manager (RBDAAPShare *share,
299 RBPlaylistManager *playlist_manager)
300 {
301 GList *playlists;
302
303 g_return_if_fail (share != NULL);
304
305 if (share->priv->playlist_manager != NULL) {
306 g_object_unref (share->priv->playlist_manager);
307 g_signal_handlers_disconnect_by_func (share->priv->playlist_manager,
308 G_CALLBACK (rb_daap_share_playlist_created),
309 share);
310 }
311
312 share->priv->playlist_manager = playlist_manager;
313
314 if (share->priv->playlist_manager != NULL) {
315 g_object_ref (share->priv->playlist_manager);
316
317 g_signal_connect_object (G_OBJECT (share->priv->playlist_manager),
318 "playlist_added",
319 G_CALLBACK (rb_daap_share_playlist_created),
320 share, 0);
321
322 /* Currently, there are no playlists when this object is created, but in
323 * case it changes..
324 */
325 playlists = rb_playlist_manager_get_playlists (share->priv->playlist_manager);
326 g_list_foreach (playlists, (GFunc) rb_daap_share_process_playlist, share);
327 g_list_free (playlists);
328 }
329 }
330
331 static void
332 rb_daap_share_set_property (GObject *object,
333 guint prop_id,
334 const GValue *value,
335 GParamSpec *pspec)
336 {
337 RBDAAPShare *share = RB_DAAP_SHARE (object);
338
339 switch (prop_id) {
340 case PROP_NAME:
341 rb_daap_share_set_name (share, g_value_get_string (value));
342 break;
343 case PROP_PASSWORD:
344 rb_daap_share_set_password (share, g_value_get_string (value));
345 break;
346 case PROP_DB:
347 rb_daap_share_set_db (share, g_value_get_object (value));
348 break;
349 case PROP_PLAYLIST_MANAGER:
350 rb_daap_share_set_playlist_manager (share, g_value_get_object (value));
351 break;
352 case PROP_ENTRY_TYPE:
353 share->priv->entry_type = g_value_get_boxed (value);
354 break;
355 default:
356 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
357 break;
358 }
359 }
360
361 static void
362 rb_daap_share_get_property (GObject *object,
363 guint prop_id,
364 GValue *value,
365 GParamSpec *pspec)
366 {
367 RBDAAPShare *share = RB_DAAP_SHARE (object);
368
369 switch (prop_id) {
370 case PROP_NAME:
371 g_value_set_string (value, share->priv->name);
372 break;
373 case PROP_PASSWORD:
374 g_value_set_string (value, share->priv->password);
375 break;
376 case PROP_DB:
377 g_value_set_object (value, share->priv->db);
378 break;
379 case PROP_PLAYLIST_MANAGER:
380 g_value_set_object (value, share->priv->playlist_manager);
381 break;
382 case PROP_ENTRY_TYPE:
383 g_value_set_boxed (value, share->priv->entry_type);
384 break;
385 default:
386 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
387 break;
388 }
389 }
390
391 static gint
392 _find_by_id (gconstpointer a, gconstpointer b)
393 {
394 RBPlaylistID *ai = (RBPlaylistID *)a;
395 gint bv = GPOINTER_TO_INT (b);
396 return (ai->id - bv);
397 }
398
399 static gint
400 _find_by_source (gconstpointer a, gconstpointer b)
401 {
402 RBPlaylistID *ai = (RBPlaylistID *)a;
403 RBSource *bs = (RBSource *)b;
404 return (ai->source - bs);
405 }
406
407 static void
408 rb_daap_share_playlist_created (RBPlaylistManager *manager,
409 RBSource *source,
410 RBDAAPShare *share)
411 {
412 rb_daap_share_process_playlist (source, share);
413 }
414
415 static void
416 rb_daap_share_process_playlist (RBSource *source,
417 RBDAAPShare *share)
418 {
419 RBPlaylistID *id;
420
421 /* make sure we're not going insane.. */
422 g_assert (g_list_find_custom (share->priv->playlist_ids,
423 source,
424 _find_by_source) == NULL);
425
426 g_object_weak_ref (G_OBJECT (source),
427 (GWeakNotify) rb_daap_share_playlist_destroyed,
428 share);
429 id = g_new0 (RBPlaylistID, 1);
430 id->source = source;
431 id->id = share->priv->next_playlist_id++;
432 share->priv->playlist_ids = g_list_append (share->priv->playlist_ids, id);
433
434 /* if we knew how to send updates to clients, we'd probably do something here */
435 }
436
437 static void
438 rb_daap_share_playlist_destroyed (RBDAAPShare *share,
439 RBSource *source)
440 {
441 GList *id;
442
443 id = g_list_find_custom (share->priv->playlist_ids, source, _find_by_source);
444 if (!id)
445 return;
446
447 share->priv->playlist_ids = g_list_remove_link (share->priv->playlist_ids, id);
448 g_free (id->data);
449 g_list_free_1 (id);
450 }
451
452 static void
453 rb_daap_share_forget_playlist (gpointer data,
454 RBDAAPShare *share)
455 {
456 RBPlaylistID *id = (RBPlaylistID *)data;
457 g_object_weak_unref (G_OBJECT (id->source),
458 (GWeakNotify) rb_daap_share_playlist_destroyed,
459 share);
460 }
461
462 static void
463 rb_daap_share_dispose (GObject *object)
464 {
465 RBDAAPShare *share = RB_DAAP_SHARE (object);
466
467 if (share->priv->published) {
468 rb_daap_share_publish_stop (share);
469 }
470
471 if (share->priv->server_active) {
472 rb_daap_share_server_stop (share);
473 }
474
475 g_free (share->priv->name);
476 g_object_unref (share->priv->db);
477 g_object_unref (share->priv->playlist_manager);
478
479 g_list_foreach (share->priv->playlist_ids, (GFunc) rb_daap_share_forget_playlist, share);
480 g_list_foreach (share->priv->playlist_ids, (GFunc) g_free, NULL);
481
482 if (share->priv->publisher) {
483 g_object_unref (share->priv->publisher);
484 }
485
486 G_OBJECT_CLASS (rb_daap_share_parent_class)->dispose (object);
487 }
488
489 RBDAAPShare *
490 rb_daap_share_new (const char *name,
491 const char *password,
492 RhythmDB *db,
493 RhythmDBEntryType entry_type,
494 RBPlaylistManager *playlist_manager)
495 {
496 RBDAAPShare *share;
497
498 share = RB_DAAP_SHARE (g_object_new (RB_TYPE_DAAP_SHARE,
499 "name", name,
500 "password", password,
501 "db", db,
502 "playlist-manager", playlist_manager,
503 "entry-type", entry_type,
504 NULL));
505
506 rb_daap_share_server_start (share);
507 rb_daap_share_publish_start (share);
508
509 return share;
510 }
511
512 static void
513 message_add_standard_headers (SoupMessage *message)
514 {
515 gchar *s;
516 time_t t;
517 struct tm *tm;
518
519 soup_message_add_header (message->response_headers, "DAAP-Server", "Rhythmbox " VERSION);
520
521 soup_message_add_header (message->response_headers, "Content-Type", "application/x-dmap-tagged");
522
523 t = time (NULL);
524 tm = gmtime (&t);
525 s = g_new (gchar, 100);
526 strftime (s, 100, "%a, %d %b %Y %T GMT", tm);
527 soup_message_add_header (message->response_headers, "Date", s);
528 g_free (s);
529 }
530
531 static void
532 message_set_from_rb_daap_structure (SoupMessage *message,
533 GNode *structure)
534 {
535 gchar *resp;
536 guint length;
537
538 resp = rb_daap_structure_serialize (structure, &length);
539
540 if (resp == NULL) {
541 rb_debug ("serialize gave us null?\n");
542 return;
543 }
544
545 message->response.owner = SOUP_BUFFER_SYSTEM_OWNED;
546 message->response.length = length;
547 message->response.body = resp;
548
549 message_add_standard_headers (message);
550
551 soup_message_set_status (message, SOUP_STATUS_OK);
552 soup_server_message_set_encoding (SOUP_SERVER_MESSAGE (message), SOUP_TRANSFER_CONTENT_LENGTH);
553 }
554
555 #define DMAP_STATUS_OK 200
556
557 #define DMAP_VERSION 2.0
558 #define DAAP_VERSION 3.0
559 #define DMAP_TIMEOUT 1800
560
561 static void
562 server_info_cb (RBDAAPShare *share,
563 SoupServerContext *context,
564 SoupMessage *message)
565 {
566 /* MSRV server info response
567 * MSTT status
568 * MPRO dmap version
569 * APRO daap version
570 * MINM name
571 * MSAU authentication method
572 * MSLR login required
573 * MSTM timeout interval
574 * MSAL supports auto logout
575 * MSUP supports update
576 * MSPI supports persistent ids
577 * MSEX supports extensions
578 * MSBR supports browse
579 * MSQY supports query
580 * MSIX supports index
581 * MSRS supports resolve
582 * MSDC databases count
583 */
584 GNode *msrv;
585
586 msrv = rb_daap_structure_add (NULL, RB_DAAP_CC_MSRV);
587 rb_daap_structure_add (msrv, RB_DAAP_CC_MSTT, (gint32) DMAP_STATUS_OK);
588 rb_daap_structure_add (msrv, RB_DAAP_CC_MPRO, (gdouble) DMAP_VERSION);
589 rb_daap_structure_add (msrv, RB_DAAP_CC_APRO, (gdouble) DAAP_VERSION);
590 /* 2/3 is for itunes 4.8 (at least). its determined by the
591 * Client-DAAP-Version header sent, but if we decide not to support
592 * older versions..? anyway
593 *
594 * 1.0 is 1/1
595 * 2.0 is 1/2
596 * 3.0 is 2/3
597 */
598 rb_daap_structure_add (msrv, RB_DAAP_CC_MINM, share->priv->name);
599 rb_daap_structure_add (msrv, RB_DAAP_CC_MSAU, share->priv->auth_method);
600 /* authentication method
601 * 0 is nothing
602 * 1 is name & password
603 * 2 is password only
604 */
605 rb_daap_structure_add (msrv, RB_DAAP_CC_MSLR, 0);
606 rb_daap_structure_add (msrv, RB_DAAP_CC_MSTM, (gint32) DMAP_TIMEOUT);
607 rb_daap_structure_add (msrv, RB_DAAP_CC_MSAL, (gchar) 0);
608 rb_daap_structure_add (msrv, RB_DAAP_CC_MSUP, (gchar) 0);
609 rb_daap_structure_add (msrv, RB_DAAP_CC_MSPI, (gchar) 0);
610 rb_daap_structure_add (msrv, RB_DAAP_CC_MSEX, (gchar) 0);
611 rb_daap_structure_add (msrv, RB_DAAP_CC_MSBR, (gchar) 0);
612 rb_daap_structure_add (msrv, RB_DAAP_CC_MSQY, (gchar) 0);
613 rb_daap_structure_add (msrv, RB_DAAP_CC_MSIX, (gchar) 0);
614 rb_daap_structure_add (msrv, RB_DAAP_CC_MSRS, (gchar) 0);
615 rb_daap_structure_add (msrv, RB_DAAP_CC_MSDC, (gint32) 1);
616
617 message_set_from_rb_daap_structure (message, msrv);
618 rb_daap_structure_destroy (msrv);
619 }
620
621 static void
622 content_codes_cb (RBDAAPShare *share,
623 SoupServerContext *context,
624 SoupMessage *message)
625 {
626 /* MCCR content codes response
627 * MSTT status
628 * MDCL dictionary
629 * MCNM content codes number
630 * MCNA content codes name
631 * MCTY content codes type
632 * MDCL dictionary
633 * ...
634 */
635 const RBDAAPContentCodeDefinition *defs;
636 guint num_defs = 0;
637 guint i;
638 GNode *mccr;
639
640 defs = rb_daap_content_codes (&num_defs);
641
642 mccr = rb_daap_structure_add (NULL, RB_DAAP_CC_MCCR);
643 rb_daap_structure_add (mccr, RB_DAAP_CC_MSTT, (gint32) DMAP_STATUS_OK);
644
645 for (i = 0; i < num_defs; i++) {
646 GNode *mdcl;
647
648 mdcl = rb_daap_structure_add (mccr, RB_DAAP_CC_MDCL);
649 rb_daap_structure_add (mdcl, RB_DAAP_CC_MCNM, rb_daap_content_code_string_as_int32(defs[i].string));
650 rb_daap_structure_add (mdcl, RB_DAAP_CC_MCNA, defs[i].name);
651 rb_daap_structure_add (mdcl, RB_DAAP_CC_MCTY, (gint32) defs[i].type);
652 }
653
654 message_set_from_rb_daap_structure (message, mccr);
655 rb_daap_structure_destroy (mccr);
656 }
657
658 static gboolean
659 message_get_session_id (SoupMessage *message,
660 guint32 *id)
661 {
662 const SoupUri *uri;
663 char *position;
664 guint32 session_id;
665
666 if (id) {
667 *id = 0;
668 }
669
670 uri = soup_message_get_uri (message);
671 if (uri == NULL) {
672 return FALSE;
673 }
674
675 position = strstr (uri->query, "session-id=");
676
677 if (position == NULL) {
678 rb_debug ("session id not found");
679 return FALSE;
680 }
681
682 position += 11;
683 session_id = (guint32) strtoul (position, NULL, 10);
684
685 if (id) {
686 *id = session_id;
687 }
688
689 return TRUE;
690 }
691
692 static gboolean
693 message_get_revision_number (SoupMessage *message,
694 guint *number)
695 {
696 const SoupUri *uri;
697 char *position;
698 guint revision_number;
699
700 if (number) {
701 *number = 0;
702 }
703
704 uri = soup_message_get_uri (message);
705 if (uri == NULL) {
706 return FALSE;
707 }
708
709 position = strstr (uri->query, "revision-number=");
710
711 if (position == NULL) {
712 rb_debug ("client asked for an update without a revision number?!?\n");
713 return FALSE;
714 }
715
716 position += 16;
717 revision_number = atoi (position);
718
719 if (number) {
720 *number = revision_number;
721 }
722
723 return TRUE;
724 }
725
726 static gboolean
727 session_id_validate (RBDAAPShare *share,
728 SoupServerContext *context,
729 SoupMessage *message,
730 guint32 *id)
731 {
732 guint32 session_id;
733 gboolean res;
734 const char *addr;
735 const char *remote_address;
736
737 if (id) {
738 *id = 0;
739 }
740
741 res = message_get_session_id (message, &session_id);
742 if (! res) {
743 rb_debug ("Validation failed: Unable to parse session id from message");
744 return FALSE;
745 }
746
747 /* check hash for remote address */
748 addr = g_hash_table_lookup (share->priv->session_ids, GUINT_TO_POINTER (session_id));
749 if (addr == NULL) {
750 rb_debug ("Validation failed: Unable to lookup session id %u", session_id);
751 return FALSE;
752 }
753
754 remote_address = soup_server_context_get_client_host (context);
755 rb_debug ("Validating session id %u from %s matches %s",
756 session_id, remote_address, addr);
757 if (remote_address == NULL || strcmp (addr, remote_address) != 0) {
758 rb_debug ("Validation failed: Remote address does not match stored address");
759 return FALSE;
760 }
761
762 if (id) {
763 *id = session_id;
764 }
765
766 return TRUE;
767 }
768
769 static guint32
770 session_id_generate (RBDAAPShare *share,
771 SoupServerContext *context)
772 {
773 guint32 id;
774
775 id = g_random_int ();
776
777 return id;
778 }
779
780 static guint32
781 session_id_create (RBDAAPShare *share,
782 SoupServerContext *context)
783 {
784 guint32 id;
785 const char *addr;
786 char *remote_address;
787
788 do {
789 /* create a unique session id */
790 id = session_id_generate (share, context);
791 rb_debug ("Generated session id %u", id);
792
793 /* if already used, try again */
794 addr = g_hash_table_lookup (share->priv->session_ids, GUINT_TO_POINTER (id));
795 } while (addr != NULL);
796
797 /* store session id and remote address */
798 remote_address = g_strdup (soup_server_context_get_client_host (context));
799 g_hash_table_insert (share->priv->session_ids, GUINT_TO_POINTER (id), remote_address);
800
801 return id;
802 }
803
804 static void
805 session_id_remove (RBDAAPShare *share,
806 SoupServerContext *context,
807 guint32 id)
808 {
809 g_hash_table_remove (share->priv->session_ids, GUINT_TO_POINTER (id));
810 }
811
812 static void
813 login_cb (RBDAAPShare *share,
814 SoupServerContext *context,
815 SoupMessage *message)
816 {
817 /* MLOG login response
818 * MSTT status
819 * MLID session id
820 */
821 GNode *mlog;
822 guint32 session_id;
823
824 session_id = session_id_create (share, context);
825
826 rb_debug ("Handling login session id %u", session_id);
827
828 mlog = rb_daap_structure_add (NULL, RB_DAAP_CC_MLOG);
829 rb_daap_structure_add (mlog, RB_DAAP_CC_MSTT, (gint32) DMAP_STATUS_OK);
830 rb_daap_structure_add (mlog, RB_DAAP_CC_MLID, session_id);
831
832 message_set_from_rb_daap_structure (message, mlog);
833 rb_daap_structure_destroy (mlog);
834 }
835
836 static void
837 logout_cb (RBDAAPShare *share,
838 SoupServerContext *context,
839 SoupMessage *message)
840 {
841 int status;
842 guint32 id;
843
844 if (session_id_validate (share, context, message, &id)) {
845 rb_debug ("Handling logout session id %u", id);
846 session_id_remove (share, context, id);
847
848 status = SOUP_STATUS_NO_CONTENT;
849 } else {
850 status = SOUP_STATUS_FORBIDDEN;
851 }
852
853 soup_message_set_status (message, status);
854 soup_server_message_set_encoding (SOUP_SERVER_MESSAGE (message), SOUP_TRANSFER_CONTENT_LENGTH);
855 }
856
857 static void
858 update_cb (RBDAAPShare *share,
859 SoupServerContext *context,
860 SoupMessage *message)
861 {
862 guint revision_number;
863 gboolean res;
864
865 res = message_get_revision_number (message, &revision_number);
866
867 if (res && revision_number != share->priv->revision_number) {
868 /* MUPD update response
869 * MSTT status
870 * MUSR server revision
871 */
872 GNode *mupd;
873
874 mupd = rb_daap_structure_add (NULL, RB_DAAP_CC_MUPD);
875 rb_daap_structure_add (mupd, RB_DAAP_CC_MSTT, (gint32) DMAP_STATUS_OK);
876 rb_daap_structure_add (mupd, RB_DAAP_CC_MUSR, (gint32) share->priv->revision_number);
877
878 message_set_from_rb_daap_structure (message, mupd);
879 rb_daap_structure_destroy (mupd);
880 } else {
881 g_object_ref (message);
882 soup_message_io_pause (message);
883 }
884 }
885
886 typedef enum {
887 ITEM_ID = 0,
888 ITEM_NAME,
889 ITEM_KIND,
890 PERSISTENT_ID,
891 CONTAINER_ITEM_ID,
892 SONG_ALBUM,
893 SONG_GROUPING,
894 SONG_ARTIST,
895 SONG_BITRATE,
896 SONG_BPM,
897 SONG_COMMENT,
898 SONG_COMPILATION,
899 SONG_COMPOSER,
900 SONG_DATA_KIND,
901 SONG_DATA_URL,
902 SONG_DATE_ADDED,
903 SONG_DATE_MODIFIED,
904 SONG_DISC_COUNT,
905 SONG_DISC_NUMBER,
906 SONG_DISABLED,
907 SONG_EQ_PRESET,
908 SONG_FORMAT,
909 SONG_GENRE,
910 SONG_DESCRIPTION,
911 SONG_RELATIVE_VOLUME,
912 SONG_SAMPLE_RATE,
913 SONG_SIZE,
914 SONG_START_TIME,
915 SONG_STOP_TIME,
916 SONG_TIME,
917 SONG_TRACK_COUNT,
918 SONG_TRACK_NUMBER,
919 SONG_USER_RATING,
920 SONG_YEAR
921 } DAAPMetaData;
922
923 struct DAAPMetaDataMap {
924 gchar *tag;
925 DAAPMetaData md;
926 };
927
928 struct DAAPMetaDataMap meta_data_map[] = {
929 {"dmap.itemid", ITEM_ID},
930 {"dmap.itemname", ITEM_NAME},
931 {"dmap.itemkind", ITEM_KIND},
932 {"dmap.persistentid", PERSISTENT_ID},
933 {"dmap.containeritemid", CONTAINER_ITEM_ID},
934 {"daap.songalbum", SONG_ALBUM},
935 {"daap.songartist", SONG_ARTIST},
936 {"daap.songbitrate", SONG_BITRATE},
937 {"daap.songbeatsperminute", SONG_BPM},
938 {"daap.songcomment", SONG_COMMENT},
939 {"daap.songcompilation", SONG_COMPILATION},
940 {"daap.songcomposer", SONG_COMPOSER},
941 {"daap.songdatakind", SONG_DATA_KIND},
942 {"daap.songdataurl", SONG_DATA_URL},
943 {"daap.songdateadded", SONG_DATE_ADDED},
944 {"daap.songdatemodified", SONG_DATE_MODIFIED},
945 {"daap.songdescription", SONG_DESCRIPTION},
946 {"daap.songdisabled", SONG_DISABLED},
947 {"daap.songdisccount", SONG_DISC_COUNT},
948 {"daap.songdiscnumber", SONG_DISC_NUMBER},
949 {"daap.songeqpreset", SONG_EQ_PRESET},
950 {"daap.songformat", SONG_FORMAT},
951 {"daap.songgenre", SONG_GENRE},
952 {"daap.songgrouping", SONG_GROUPING},
953 {"daap.songrelativevolume", SONG_RELATIVE_VOLUME},
954 {"daap.songsamplerate", SONG_SAMPLE_RATE},
955 {"daap.songsize", SONG_SIZE},
956 {"daap.songstarttime", SONG_START_TIME},
957 {"daap.songstoptime", SONG_STOP_TIME},
958 {"daap.songtime", SONG_TIME},
959 {"daap.songtrackcount", SONG_TRACK_COUNT},
960 {"daap.songtracknumber", SONG_TRACK_NUMBER},
961 {"daap.songuserrating", SONG_USER_RATING},
962 {"daap.songyear", SONG_YEAR}};
963
964 typedef unsigned long long bitwise;
965
966 struct MLCL_Bits {
967 GNode *mlcl;
968 bitwise bits;
969 gpointer pointer;
970 };
971
972 static gboolean
973 client_requested (bitwise bits,
974 gint field)
975 {
976 return 0 != (bits & (((bitwise) 1) << field));
977 }
978
979 #define DMAP_ITEM_KIND_AUDIO 2
980 #define DAAP_SONG_DATA_KIND_NONE 0
981
982 static void
983 add_entry_to_mlcl (RhythmDB *db,
984 RhythmDBEntry *entry,
985 struct MLCL_Bits *mb)
986 {
987 GNode *mlit;
988 gint id;
989
990 id = rhythmdb_entry_get_ulong (entry, RHYTHMDB_PROP_ENTRY_ID);
991 mlit = rb_daap_structure_add (mb->mlcl, RB_DAAP_CC_MLIT);
992
993 if (client_requested (mb->bits, ITEM_KIND))
994 rb_daap_structure_add (mlit, RB_DAAP_CC_MIKD, (gchar) DMAP_ITEM_KIND_AUDIO);
995 if (client_requested (mb->bits, ITEM_ID))
996 rb_daap_structure_add (mlit, RB_DAAP_CC_MIID, (gint32) id);
997 if (client_requested (mb->bits, ITEM_NAME))
998 rb_daap_structure_add (mlit, RB_DAAP_CC_MINM, rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_TITLE));
999 if (client_requested (mb->bits, PERSISTENT_ID))
1000 rb_daap_structure_add (mlit, RB_DAAP_CC_MPER, (gint64) id);
1001 if (client_requested (mb->bits, CONTAINER_ITEM_ID))
1002 rb_daap_structure_add (mlit, RB_DAAP_CC_MCTI, (gint32) id);
1003 if (client_requested (mb->bits, SONG_DATA_KIND))
1004 rb_daap_structure_add (mlit, RB_DAAP_CC_ASDK, (gchar) DAAP_SONG_DATA_KIND_NONE);
1005 if (client_requested (mb->bits, SONG_DATA_URL))
1006 rb_daap_structure_add (mlit, RB_DAAP_CC_ASUL, "");
1007 if (client_requested (mb->bits, SONG_ALBUM))
1008 rb_daap_structure_add (mlit, RB_DAAP_CC_ASAL, rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_ALBUM));
1009 if (client_requested (mb->bits, SONG_GROUPING))
1010 rb_daap_structure_add (mlit, RB_DAAP_CC_AGRP, "");
1011 if (client_requested (mb->bits, SONG_ARTIST))
1012 rb_daap_structure_add (mlit, RB_DAAP_CC_ASAR, rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_ARTIST));
1013 if (client_requested (mb->bits, SONG_BITRATE)) {
1014 gulong bitrate = rhythmdb_entry_get_ulong (entry, RHYTHMDB_PROP_BITRATE);
1015 if (bitrate != 0)
1016 rb_daap_structure_add (mlit, RB_DAAP_CC_ASBR, (gint32) bitrate);
1017 }
1018 if (client_requested (mb->bits, SONG_BPM))
1019 rb_daap_structure_add (mlit, RB_DAAP_CC_ASBT, (gint32) 0);
1020 if (client_requested (mb->bits, SONG_COMMENT))
1021 rb_daap_structure_add (mlit, RB_DAAP_CC_ASCM, "");
1022 if (client_requested (mb->bits, SONG_COMPILATION))
1023 rb_daap_structure_add (mlit, RB_DAAP_CC_ASCO, (gchar) FALSE);
1024 if (client_requested (mb->bits, SONG_COMPOSER))
1025 rb_daap_structure_add (mlit, RB_DAAP_CC_ASCP, "");
1026 if (client_requested (mb->bits, SONG_DATE_ADDED))
1027 rb_daap_structure_add (mlit, RB_DAAP_CC_ASDA, (gint32) rhythmdb_entry_get_ulong (entry, RHYTHMDB_PROP_FIRST_SEEN));
1028 if (client_requested (mb->bits, SONG_DATE_MODIFIED))
1029 rb_daap_structure_add (mlit, RB_DAAP_CC_ASDM, (gint32) rhythmdb_entry_get_ulong (entry, RHYTHMDB_PROP_MTIME));
1030 if (client_requested (mb->bits, SONG_DISC_COUNT))
1031 rb_daap_structure_add (mlit, RB_DAAP_CC_ASDC, (gint32) 0);
1032 if (client_requested (mb->bits, SONG_DISC_NUMBER))
1033 rb_daap_structure_add (mlit, RB_DAAP_CC_ASDN, (gint32) rhythmdb_entry_get_ulong (entry, RHYTHMDB_PROP_DISC_NUMBER));
1034 if (client_requested (mb->bits, SONG_DISABLED))
1035 rb_daap_structure_add (mlit, RB_DAAP_CC_ASDB, (gchar) FALSE);
1036 if (client_requested (mb->bits, SONG_EQ_PRESET))
1037 rb_daap_structure_add (mlit, RB_DAAP_CC_ASEQ, "");
1038 if (client_requested (mb->bits, SONG_FORMAT)) {
1039 const gchar *filename;
1040 gchar *ext;
1041
1042 filename = rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_LOCATION);
1043 ext = strrchr (filename, '.');
1044 if (ext == NULL) {
1045 /* FIXME we should use RHYTHMDB_PROP_MIMETYPE instead */
1046 ext = "mp3";
1047 rb_daap_structure_add (mlit, RB_DAAP_CC_ASFM, ext);
1048 } else {
1049 ext++;
1050 rb_daap_structure_add (mlit, RB_DAAP_CC_ASFM, ext);
1051 }
1052 }
1053 if (client_requested (mb->bits, SONG_GENRE))
1054 rb_daap_structure_add (mlit, RB_DAAP_CC_ASGN, rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_GENRE));
1055 if (client_requested (mb->bits, SONG_DESCRIPTION))
1056 rb_daap_structure_add (mlit, RB_DAAP_CC_ASDT, "");
1057 if (client_requested (mb->bits, SONG_RELATIVE_VOLUME))
1058 rb_daap_structure_add (mlit, RB_DAAP_CC_ASRV, 0);
1059 if (client_requested (mb->bits, SONG_SAMPLE_RATE))
1060 rb_daap_structure_add (mlit, RB_DAAP_CC_ASSR, 0);
1061 if (client_requested (mb->bits, SONG_SIZE))
1062 rb_daap_structure_add (mlit, RB_DAAP_CC_ASSZ, (gint32) rhythmdb_entry_get_uint64 (entry, RHYTHMDB_PROP_FILE_SIZE));
1063 if (client_requested (mb->bits, SONG_START_TIME))
1064 rb_daap_structure_add (mlit, RB_DAAP_CC_ASST, 0);
1065 if (client_requested (mb->bits, SONG_STOP_TIME))
1066 rb_daap_structure_add (mlit, RB_DAAP_CC_ASSP, 0);
1067 if (client_requested (mb->bits, SONG_TIME))
1068 rb_daap_structure_add (mlit, RB_DAAP_CC_ASTM, (gint32) (1000 * rhythmdb_entry_get_ulong (entry, RHYTHMDB_PROP_DURATION)));
1069 if (client_requested (mb->bits, SONG_TRACK_COUNT))
1070 rb_daap_structure_add (mlit, RB_DAAP_CC_ASTC, 0);
1071 if (client_requested (mb->bits, SONG_TRACK_NUMBER))
1072 rb_daap_structure_add (mlit, RB_DAAP_CC_ASTN, (gint32) rhythmdb_entry_get_ulong (entry, RHYTHMDB_PROP_TRACK_NUMBER));
1073 if (client_requested (mb->bits, SONG_USER_RATING))
1074 rb_daap_structure_add (mlit, RB_DAAP_CC_ASUR, 0); /* FIXME */
1075 if (client_requested (mb->bits, SONG_YEAR))
1076 rb_daap_structure_add (mlit, RB_DAAP_CC_ASYR, (gint32) rhythmdb_entry_get_ulong (entry, RHYTHMDB_PROP_YEAR));
1077
1078 return;
1079 }
1080
1081 static void
1082 add_playlist_to_mlcl (RBPlaylistID *playlist_id,
1083 GNode *mlcl)
1084 {
1085 /* MLIT listing item
1086 * MIID item id
1087 * MPER persistent item id
1088 * MINM item name
1089 * MIMC item count
1090 */
1091 GNode *mlit;
1092 gchar *name;
1093 guint num_songs;
1094 RhythmDBQueryModel *model;
1095
1096 g_object_get (playlist_id->source,
1097 "name", &name,
1098 "query-model", &model,
1099 NULL);
1100
1101 num_songs = gtk_tree_model_iter_n_children (GTK_TREE_MODEL (model), NULL);
1102 g_object_unref (model);
1103
1104 mlit = rb_daap_structure_add (mlcl, RB_DAAP_CC_MLIT);
1105 rb_daap_structure_add (mlit, RB_DAAP_CC_MIID, playlist_id->id);
1106 /* we don't have a persistant ID for playlists, unfortunately */
1107 rb_daap_structure_add (mlit, RB_DAAP_CC_MPER, (gint64) playlist_id->id);
1108 rb_daap_structure_add (mlit, RB_DAAP_CC_MINM, name);
1109 rb_daap_structure_add (mlit, RB_DAAP_CC_MIMC, (gint32) num_songs);
1110
1111 g_free (name);
1112
1113 return;
1114 }
1115
1116 static gboolean
1117 add_playlist_entry_to_mlcl (GtkTreeModel *model,
1118 GtkTreePath *path,
1119 GtkTreeIter *iter,
1120 struct MLCL_Bits *mb)
1121 {
1122 GNode *mlit;
1123 RhythmDBEntry *entry;
1124 gint id;
1125
1126 mlit = rb_daap_structure_add (mb->mlcl, RB_DAAP_CC_MLIT);
1127
1128 gtk_tree_model_get (model, iter, 0, &entry, -1);
1129
1130 id = rhythmdb_entry_get_ulong (entry, RHYTHMDB_PROP_ENTRY_ID);
1131
1132 if (client_requested (mb->bits, ITEM_KIND))
1133 rb_daap_structure_add (mlit, RB_DAAP_CC_MIKD, (gchar) DMAP_ITEM_KIND_AUDIO);
1134 if (client_requested (mb->bits, ITEM_ID))
1135 rb_daap_structure_add (mlit, RB_DAAP_CC_MIID, (gint32) id);
1136 if (client_requested (mb->bits, CONTAINER_ITEM_ID))
1137 rb_daap_structure_add (mlit, RB_DAAP_CC_MCTI, (gint32) id);
1138
1139 rhythmdb_entry_unref (entry);
1140
1141 return FALSE;
1142 }
1143
1144 static bitwise
1145 parse_meta (const gchar *s)
1146 {
1147 gchar *start_of_attrs;
1148 gchar *end_of_attrs;
1149 gchar *attrs;
1150 gchar **attrsv;
1151 guint i;
1152 bitwise bits = 0;
1153
1154 start_of_attrs = strstr (s, "meta=");
1155 if (start_of_attrs == NULL) {
1156 return 0;
1157 }
1158 start_of_attrs += 5;
1159
1160 end_of_attrs = strchr (start_of_attrs, '&');
1161 if (end_of_attrs) {
1162 attrs = g_strndup (start_of_attrs, end_of_attrs - start_of_attrs);
1163 } else {
1164 attrs = g_strdup (start_of_attrs);
1165 }
1166
1167 attrsv = g_strsplit (attrs,",",-1);
1168
1169 for (i = 0; attrsv[i]; i++) {
1170 guint j;
1171
1172 for (j = 0; j < G_N_ELEMENTS (meta_data_map); j++) {
1173 if (strcmp (meta_data_map[j].tag, attrsv[i]) == 0) {
1174 bits |= (((bitwise) 1) << meta_data_map[j].md);
1175 }
1176 }
1177 }
1178
1179 g_free (attrs);
1180 g_strfreev (attrsv);
1181
1182 return bits;
1183 }
1184
1185 static void
1186 write_next_chunk (SoupMessage *message, GnomeVFSHandle *handle)
1187 {
1188 GnomeVFSFileSize read_size;
1189 GnomeVFSResult result;
1190 gchar *chunk = g_malloc (DAAP_SHARE_CHUNK_SIZE);
1191
1192 result = gnome_vfs_read (handle, chunk, DAAP_SHARE_CHUNK_SIZE, &read_size);
1193 if (result == GNOME_VFS_OK && read_size > 0) {
1194 soup_message_add_chunk (message, SOUP_BUFFER_SYSTEM_OWNED, chunk, read_size);
1195 } else {
1196 g_free (chunk);
1197 soup_message_add_final_chunk (message);
1198 }
1199 }
1200
1201 static void
1202 chunked_message_finished (SoupMessage *message, GnomeVFSHandle *handle)
1203 {
1204 rb_debug ("finished sending chunked file");
1205 gnome_vfs_close (handle);
1206 }
1207
1208 static void
1209 send_chunked_file (SoupMessage *message, RhythmDBEntry *entry, guint64 file_size, guint64 offset)
1210 {
1211 GnomeVFSResult result;
1212 GnomeVFSHandle *handle;
1213 const char *location;
1214
1215 location = rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_LOCATION);
1216
1217 rb_debug ("sending %s chunked from offset %" G_GUINT64_FORMAT, location, offset);
1218 result = gnome_vfs_open (&handle, location, GNOME_VFS_OPEN_READ);
1219 if (result != GNOME_VFS_OK) {
1220 soup_message_set_status (message, SOUP_STATUS_INTERNAL_SERVER_ERROR);
1221 return;
1222 }
1223
1224 if (offset != 0) {
1225 result = gnome_vfs_seek (handle, GNOME_VFS_SEEK_START, offset);
1226 if (result != GNOME_VFS_OK) {
1227 g_warning ("Error seeking: %s", gnome_vfs_result_to_string (result));
1228 gnome_vfs_close (handle);
1229 soup_message_set_status (message, SOUP_STATUS_INTERNAL_SERVER_ERROR);
1230 return;
1231 }
1232 file_size -= offset;
1233 }
1234
1235 soup_server_message_set_encoding (SOUP_SERVER_MESSAGE (message), SOUP_TRANSFER_CHUNKED);
1236
1237 g_signal_connect (message, "wrote_chunk", G_CALLBACK (write_next_chunk), handle);
1238 g_signal_connect (message, "finished", G_CALLBACK (chunked_message_finished), handle);
1239 write_next_chunk (message, handle);
1240 }
1241
1242 #ifdef HAVE_G_MAPPED_FILE
1243 static void
1244 mapped_file_message_finished (SoupMessage *message, GMappedFile *file)
1245 {
1246 rb_debug ("finished sending mmapped file");
1247 g_mapped_file_free (file);
1248 }
1249
1250 static void
1251 send_mapped_file (SoupMessage *message, RhythmDBEntry *entry, guint64 file_size, guint64 offset)
1252 {
1253 GMappedFile *mapped_file;
1254 char *path;
1255 GError *error = NULL;
1256
1257 path = gnome_vfs_get_local_path_from_uri (rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_LOCATION));
1258 rb_debug ("sending file %s mmapped, from offset %" G_GUINT64_FORMAT, path, offset);
1259
1260 mapped_file = g_mapped_file_new (path, FALSE, &error);
1261 if (mapped_file == NULL) {
1262 g_warning ("Unable to map file %s: %s", path, error->message);
1263 soup_message_set_status (message, SOUP_STATUS_INTERNAL_SERVER_ERROR);
1264 } else {
1265 message->response.owner = SOUP_BUFFER_USER_OWNED;
1266 message->response.length = file_size;
1267 message->response.body = g_mapped_file_get_contents (mapped_file) + offset;
1268 soup_server_message_set_encoding (SOUP_SERVER_MESSAGE (message),
1269 SOUP_TRANSFER_CONTENT_LENGTH);
1270
1271 g_signal_connect (message,
1272 "finished",
1273 G_CALLBACK (mapped_file_message_finished),
1274 mapped_file);
1275 }
1276 g_free (path);
1277 }
1278 #endif
1279
1280 static void
1281 databases_cb (RBDAAPShare *share,
1282 SoupServerContext *context,
1283 SoupMessage *message)
1284 {
1285 gchar *path;
1286 gchar *rest_of_path;
1287 /*guint revision_number;*/
1288
1289 if (! session_id_validate (share, context, message, NULL)) {
1290 soup_message_set_status (message, SOUP_STATUS_FORBIDDEN);
1291 soup_server_message_set_encoding (SOUP_SERVER_MESSAGE (message), SOUP_TRANSFER_CONTENT_LENGTH);
1292 return;
1293 }
1294
1295 path = soup_uri_to_string (soup_message_get_uri (message), TRUE);
1296
1297 rest_of_path = strchr (path + 1, '/');
1298
1299 if (rest_of_path == NULL) {
1300 /* AVDB server databases
1301 * MSTT status
1302 * MUTY update type
1303 * MTCO specified total count
1304 * MRCO returned count
1305 * MLCL listing
1306 * MLIT listing item
1307 * MIID item id
1308 * MPER persistent id
1309 * MINM item name
1310 * MIMC item count
1311 * MCTC container count
1312 */
1313 GNode *avdb;
1314 GNode *mlcl;
1315 GNode *mlit;
1316
1317 avdb = rb_daap_structure_add (NULL, RB_DAAP_CC_AVDB);
1318 rb_daap_structure_add (avdb, RB_DAAP_CC_MSTT, (gint32) DMAP_STATUS_OK);
1319 rb_daap_structure_add (avdb, RB_DAAP_CC_MUTY, 0);
1320 rb_daap_structure_add (avdb, RB_DAAP_CC_MTCO, (gint32) 1);
1321 rb_daap_structure_add (avdb, RB_DAAP_CC_MRCO, (gint32) 1);
1322 mlcl = rb_daap_structure_add (avdb, RB_DAAP_CC_MLCL);
1323 mlit = rb_daap_structure_add (mlcl, RB_DAAP_CC_MLIT);
1324 rb_daap_structure_add (mlit, RB_DAAP_CC_MIID, (gint32) 1);
1325 rb_daap_structure_add (mlit, RB_DAAP_CC_MPER, (gint64) 1);
1326 rb_daap_structure_add (mlit, RB_DAAP_CC_MINM, share->priv->name);
1327 rb_daap_structure_add (mlit, RB_DAAP_CC_MIMC, (gint32) rhythmdb_entry_count_by_type (share->priv->db, share->priv->entry_type));
1328 rb_daap_structure_add (mlit, RB_DAAP_CC_MCTC, (gint32) 1);
1329
1330 message_set_from_rb_daap_structure (message, avdb);
1331 rb_daap_structure_destroy (avdb);
1332 } else if (g_ascii_strncasecmp ("/1/items?", rest_of_path, 9) == 0) {
1333 /* ADBS database songs
1334 * MSTT status
1335 * MUTY update type
1336 * MTCO specified total count
1337 * MRCO returned count
1338 * MLCL listing
1339 * MLIT
1340 * attrs
1341 * MLIT
1342 * ...
1343 */
1344 GNode *adbs;
1345 gint32 num_songs = rhythmdb_entry_count_by_type (share->priv->db, share->priv->entry_type);
1346 struct MLCL_Bits mb = {NULL,0};
1347
1348 mb.bits = parse_meta (rest_of_path);
1349
1350 adbs = rb_daap_structure_add (NULL, RB_DAAP_CC_ADBS);
1351 rb_daap_structure_add (adbs, RB_DAAP_CC_MSTT, (gint32) DMAP_STATUS_OK);
1352 rb_daap_structure_add (adbs, RB_DAAP_CC_MUTY, 0);
1353 rb_daap_structure_add (adbs, RB_DAAP_CC_MTCO, (gint32) num_songs);
1354 rb_daap_structure_add (adbs, RB_DAAP_CC_MRCO, (gint32) num_songs);
1355 mb.mlcl = rb_daap_structure_add (adbs, RB_DAAP_CC_MLCL);
1356
1357 rhythmdb_entry_foreach_by_type (share->priv->db, share->priv->entry_type, (GFunc) add_entry_to_mlcl, &mb);
1358
1359 message_set_from_rb_daap_structure (message, adbs);
1360 rb_daap_structure_destroy (adbs);
1361 adbs = NULL;
1362 } else if (g_ascii_strncasecmp ("/1/containers?", rest_of_path, 14) == 0) {
1363 /* APLY database playlists
1364 * MSTT status
1365 * MUTY update type
1366 * MTCO specified total count
1367 * MRCO returned count
1368 * MLCL listing
1369 * MLIT listing item
1370 * MIID item id
1371 * MPER persistent item id
1372 * MINM item name
1373 * MIMC item count
1374 * ABPL baseplaylist (only for base)
1375 * MLIT
1376 * ...
1377 */
1378 GNode *aply;
1379 GNode *mlcl;
1380 GNode *mlit;
1381
1382 aply = rb_daap_structure_add (NULL, RB_DAAP_CC_APLY);
1383 rb_daap_structure_add (aply, RB_DAAP_CC_MSTT, (gint32) DMAP_STATUS_OK);
1384 rb_daap_structure_add (aply, RB_DAAP_CC_MUTY, 0);
1385 rb_daap_structure_add (aply, RB_DAAP_CC_MTCO, (gint32) 1);
1386 rb_daap_structure_add (aply, RB_DAAP_CC_MRCO, (gint32) 1);
1387 mlcl = rb_daap_structure_add (aply, RB_DAAP_CC_MLCL);
1388 mlit = rb_daap_structure_add (mlcl, RB_DAAP_CC_MLIT);
1389 rb_daap_structure_add (mlit, RB_DAAP_CC_MIID, (gint32) 1);
1390 rb_daap_structure_add (mlit, RB_DAAP_CC_MPER, (gint64) 1);
1391 rb_daap_structure_add (mlit, RB_DAAP_CC_MINM, share->priv->name);
1392 rb_daap_structure_add (mlit, RB_DAAP_CC_MIMC, (gint32) rhythmdb_entry_count_by_type (share->priv->db, share->priv->entry_type));
1393 rb_daap_structure_add (mlit, RB_DAAP_CC_ABPL, (gchar) 1); /* base playlist */
1394
1395 g_list_foreach (share->priv->playlist_ids, (GFunc) add_playlist_to_mlcl, mlcl);
1396
1397 message_set_from_rb_daap_structure (message, aply);
1398 rb_daap_structure_destroy (aply);
1399 } else if (g_ascii_strncasecmp ("/1/containers/", rest_of_path, 14) == 0) {
1400 /* APSO playlist songs
1401 * MSTT status
1402 * MUTY update type
1403 * MTCO specified total count
1404 * MRCO returned count
1405 * MLCL listing
1406 * MLIT listing item
1407 * MIKD item kind
1408 * MIID item id
1409 * MCTI container item id
1410 * MLIT
1411 * ...
1412 */
1413 GNode *apso;
1414 struct MLCL_Bits mb = {NULL,0};
1415 gint pl_id = atoi (rest_of_path + 14);
1416
1417 mb.bits = parse_meta (rest_of_path);
1418
1419 apso = rb_daap_structure_add (NULL, RB_DAAP_CC_APSO);
1420 rb_daap_structure_add (apso, RB_DAAP_CC_MSTT, (gint32) DMAP_STATUS_OK);
1421 rb_daap_structure_add (apso, RB_DAAP_CC_MUTY, 0);
1422
1423 if (pl_id == 1) {
1424 gint32 num_songs = (gint32) rhythmdb_entry_count_by_type (share->priv->db, share->priv->entry_type);
1425 rb_daap_structure_add (apso, RB_DAAP_CC_MTCO, (gint32) num_songs);
1426 rb_daap_structure_add (apso, RB_DAAP_CC_MRCO, (gint32) num_songs);
1427 mb.mlcl = rb_daap_structure_add (apso, RB_DAAP_CC_MLCL);
1428
1429 rhythmdb_entry_foreach_by_type (share->priv->db,
1430 share->priv->entry_type,
1431 (GFunc) add_entry_to_mlcl,
1432 &mb);
1433 } else {
1434 RBPlaylistID *id;
1435 GList *idl;
1436 guint num_songs;
1437 RhythmDBQueryModel *model;
1438
1439 idl = g_list_find_custom (share->priv->playlist_ids,
1440 GINT_TO_POINTER (pl_id),
1441 _find_by_id);
1442 if (idl == NULL) {
1443 soup_message_set_status (message, SOUP_STATUS_NOT_FOUND);
1444 soup_server_message_set_encoding (SOUP_SERVER_MESSAGE (message),
1445 SOUP_TRANSFER_CONTENT_LENGTH);
1446 soup_message_set_response (message, "text/plain", SOUP_BUFFER_USER_OWNED, "", 0);
1447 goto out;
1448 }
1449 id = (RBPlaylistID *)idl->data;
1450
1451 mb.mlcl = rb_daap_structure_add (apso, RB_DAAP_CC_MLCL);
1452
1453 g_object_get (id->source, "query-model", &model, NULL);
1454 num_songs = gtk_tree_model_iter_n_children (GTK_TREE_MODEL (model), NULL);
1455
1456 rb_daap_structure_add (apso, RB_DAAP_CC_MTCO, (gint32) num_songs);
1457 rb_daap_structure_add (apso, RB_DAAP_CC_MRCO, (gint32) num_songs);
1458
1459 gtk_tree_model_foreach (GTK_TREE_MODEL (model), (GtkTreeModelForeachFunc) add_playlist_entry_to_mlcl, &mb);
1460 g_object_unref (model);
1461 }
1462
1463 message_set_from_rb_daap_structure (message, apso);
1464 rb_daap_structure_destroy (apso);
1465 } else if (g_ascii_strncasecmp ("/1/items/", rest_of_path, 9) == 0) {
1466 /* just the file :) */
1467 gchar *id_str;
1468 gint id;
1469 RhythmDBEntry *entry;
1470 const gchar *location;
1471 const gchar *range_header;
1472 guint64 file_size;
1473 guint64 offset = 0;
1474
1475 id_str = rest_of_path + 9;
1476 id = atoi (id_str);
1477
1478 entry = rhythmdb_entry_lookup_by_id (share->priv->db, id);
1479 location = rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_LOCATION);
1480 file_size = rhythmdb_entry_get_uint64 (entry, RHYTHMDB_PROP_FILE_SIZE);
1481
1482 message_add_standard_headers (message);
1483 soup_message_add_header (message->response_headers, "Accept-Ranges", "bytes");
1484
1485 range_header = soup_message_get_header (message->request_headers, "Range");
1486 if (range_header) {
1487 const gchar *s;
1488 gchar *content_range;
1489
1490 s = range_header + 6; /* bytes= */
1491 offset = atoll (s);
1492
1493 content_range = g_strdup_printf ("bytes %" G_GUINT64_FORMAT "-%" G_GUINT64_FORMAT "/%" G_GUINT64_FORMAT, offset, file_size, file_size);
1494 soup_message_add_header (message->response_headers, "Content-Range", content_range);
1495 g_free (content_range);
1496
1497 soup_message_set_status (message, SOUP_STATUS_PARTIAL_CONTENT);
1498 file_size -= offset;
1499 } else {
1500 soup_message_set_status (message, SOUP_STATUS_OK);
1501 }
1502
1503 #ifdef HAVE_G_MAPPED_FILE
1504 /* don't use chunked transfers if we can send the file mmapped,
1505 * as itunes clients can't seek properly when we do.
1506 */
1507 if (rb_uri_is_local (location)) {
1508 send_mapped_file (message, entry, file_size, offset);
1509 } else
1510 #endif
1511 {
1512 send_chunked_file (message, entry, file_size, offset);
1513 }
1514 } else {
1515 rb_debug ("unhandled: %s\n", path);
1516 }
1517
1518 out:
1519 g_free (path);
1520 }
1521
1522 typedef void (* DAAPPathFunction) (RBDAAPShare *share,
1523 SoupServerContext *context,
1524 SoupMessage *message);
1525
1526 struct DAAPPath {
1527 const gchar *path;
1528 guint path_length;
1529 DAAPPathFunction function;
1530 };
1531
1532 static const struct DAAPPath paths_to_functions[] = {
1533 {"/server-info", 12, server_info_cb},
1534 {"/content-codes", 14, content_codes_cb},
1535 {"/login", 6, login_cb},
1536 {"/logout", 7, logout_cb},
1537 {"/update", 7, update_cb},
1538 {"/databases", 10, databases_cb}
1539 };
1540
1541 static void
1542 server_cb (SoupServerContext *context,
1543 SoupMessage *message,
1544 RBDAAPShare *share)
1545 {
1546 gchar *path;
1547 guint i;
1548
1549 path = soup_uri_to_string (soup_message_get_uri (message), TRUE);
1550 rb_debug ("request for %s", path);
1551
1552 for (i = 0; i < G_N_ELEMENTS (paths_to_functions); i++) {
1553 if (g_ascii_strncasecmp (paths_to_functions[i].path, path, paths_to_functions[i].path_length) == 0) {
1554 paths_to_functions[i].function (share, context, message);
1555 return;
1556 }
1557 }
1558
1559 g_warning ("unhandled path %s\n", path);
1560
1561 g_free (path);
1562 }
1563
1564 static void
1565 db_entry_added_cb (RhythmDB *db,
1566 RhythmDBEntry *entry,
1567 RBDAAPShare *share)
1568 {
1569 /* TODO: update our db version number? */
1570 }
1571
1572 static void
1573 add_db_entry (RhythmDBEntry *entry,
1574 RBDAAPShare *share)
1575 {
1576 db_entry_added_cb (share->priv->db, entry, share);
1577 }
1578
1579 static void
1580 db_entry_deleted_cb (RhythmDB *db,
1581 RhythmDBEntry *entry,
1582 RBDAAPShare *share)
1583 {
1584 /* TODO: update our db version number? */
1585 }
1586
1587 static void
1588 db_entry_changed_cb (RhythmDB *db,
1589 RhythmDBEntry *entry,
1590 GSList *changes,
1591 RBDAAPShare *share)
1592 {
1593 if (rhythmdb_entry_get_boolean (entry, RHYTHMDB_PROP_HIDDEN)) {
1594 db_entry_deleted_cb (db, entry, share);
1595 } else {
1596 db_entry_added_cb (db, entry, share);
1597 }
1598 }
1599
1600 static gboolean
1601 soup_auth_callback (SoupServerAuthContext *auth_ctx,
1602 SoupServerAuth *auth,
1603 SoupMessage *message,
1604 RBDAAPShare *share)
1605 {
1606 const char *username;
1607 gboolean allowed;
1608 char *path;
1609
1610 path = soup_uri_to_string (soup_message_get_uri (message), TRUE);
1611 rb_debug ("Auth request for %s", path);
1612
1613 if (auth == NULL) {
1614
1615 /* This is to workaround libsoup looking up handlers by directory.
1616 We require auth for "/databases?" but not "/databases/" */
1617 if (g_str_has_prefix (path, "/databases/")) {
1618 allowed = TRUE;
1619 goto done;
1620 }
1621
1622 rb_debug ("Auth DENIED: information not provided");
1623 allowed = FALSE;
1624 goto done;
1625 }
1626
1627 username = soup_server_auth_get_user (auth);
1628 rb_debug ("Auth request for user: %s", username);
1629
1630 allowed = soup_server_auth_check_passwd (auth, share->priv->password);
1631 rb_debug ("Auth request: %s", allowed ? "ALLOWED" : "DENIED");
1632
1633 done:
1634 g_free (path);
1635
1636 return allowed;
1637 }
1638
1639 static gboolean
1640 rb_daap_share_server_start (RBDAAPShare *share)
1641 {
1642 int port = STANDARD_DAAP_PORT;
1643 gboolean password_required;
1644 SoupServerAuthContext auth_ctx = { 0 };
1645
1646 share->priv->server = soup_server_new (SOUP_SERVER_PORT, port, NULL);
1647 if (share->priv->server == NULL) {
1648 rb_debug ("Unable to start music sharing server on port %d, trying any open port", port);
1649 share->priv->server = soup_server_new (SOUP_SERVER_PORT, SOUP_ADDRESS_ANY_PORT, NULL);
1650
1651 if (share->priv->server == NULL) {
1652 g_warning ("Unable to start music sharing server");
1653 return FALSE;
1654 }
1655 }
1656
1657 share->priv->port = (guint)soup_server_get_port (share->priv->server);
1658 rb_debug ("Started DAAP server on port %u", share->priv->port);
1659
1660 password_required = (share->priv->auth_method != RB_DAAP_SHARE_AUTH_METHOD_NONE);
1661
1662 if (password_required) {
1663 auth_ctx.types = SOUP_AUTH_TYPE_BASIC;
1664 auth_ctx.callback = (SoupServerAuthCallbackFn)soup_auth_callback;
1665 auth_ctx.user_data = share;
1666 auth_ctx.basic_info.realm = "Music Sharing";
1667
1668 soup_server_add_handler (share->priv->server,
1669 "/login",
1670 &auth_ctx,
1671 (SoupServerCallbackFn)server_cb,
1672 NULL,
1673 share);
1674 soup_server_add_handler (share->priv->server,
1675 "/update",
1676 &auth_ctx,
1677 (SoupServerCallbackFn)server_cb,
1678 NULL,
1679 share);
1680 soup_server_add_handler (share->priv->server,
1681 "/databases",
1682 &auth_ctx,
1683 (SoupServerCallbackFn)server_cb,
1684 NULL,
1685 share);
1686 }
1687
1688 soup_server_add_handler (share->priv->server,
1689 NULL,
1690 NULL,
1691 (SoupServerCallbackFn)server_cb,
1692 NULL,
1693 share);
1694 soup_server_run_async (share->priv->server);
1695
1696 /* using direct since there is no g_uint_hash or g_uint_equal */
1697 share->priv->session_ids = g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL, g_free);
1698
1699 share->priv->next_playlist_id = 2; /* 1 already used */
1700
1701 rhythmdb_entry_foreach (share->priv->db, (GFunc)add_db_entry, share);
1702
1703 share->priv->entry_added_id = g_signal_connect (G_OBJECT (share->priv->db),
1704 "entry-added",
1705 G_CALLBACK (db_entry_added_cb),
1706 share);
1707 share->priv->entry_deleted_id = g_signal_connect (G_OBJECT (share->priv->db),
1708 "entry-deleted",
1709 G_CALLBACK (db_entry_deleted_cb),
1710 share);
1711 share->priv->entry_changed_id = g_signal_connect (G_OBJECT (share->priv->db),
1712 "entry-changed",
1713 G_CALLBACK (db_entry_changed_cb),
1714 share);
1715
1716 share->priv->server_active = TRUE;
1717
1718 return TRUE;
1719 }
1720
1721 static gboolean
1722 rb_daap_share_server_stop (RBDAAPShare *share)
1723 {
1724 rb_debug ("Stopping music sharing server on port %d", share->priv->port);
1725
1726 if (share->priv->server) {
1727 soup_server_quit (share->priv->server);
1728 g_object_unref (share->priv->server);
1729 share->priv->server = NULL;
1730 }
1731
1732 if (share->priv->session_ids) {
1733 g_hash_table_destroy (share->priv->session_ids);
1734 share->priv->session_ids = NULL;
1735 }
1736
1737 if (share->priv->entry_added_id != 0) {
1738 g_signal_handler_disconnect (share->priv->db, share->priv->entry_added_id);
1739 share->priv->entry_added_id = 0;
1740 }
1741
1742 if (share->priv->entry_deleted_id != 0) {
1743 g_signal_handler_disconnect (share->priv->db, share->priv->entry_deleted_id);
1744 share->priv->entry_deleted_id = 0;
1745 }
1746
1747 if (share->priv->entry_changed_id != 0) {
1748 g_signal_handler_disconnect (share->priv->db, share->priv->entry_changed_id);
1749 share->priv->entry_changed_id = 0;
1750 }
1751
1752 share->priv->server_active = FALSE;
1753
1754 return TRUE;
1755 }
1756
1757 static gboolean
1758 rb_daap_share_publish_start (RBDAAPShare *share)
1759 {
1760 GError *error;
1761 gboolean res;
1762 gboolean password_required;
1763
1764 password_required = (share->priv->auth_method != RB_DAAP_SHARE_AUTH_METHOD_NONE);
1765
1766 error = NULL;
1767 res = rb_daap_mdns_publisher_publish (share->priv->publisher,
1768 share->priv->name,
1769 share->priv->port,
1770 password_required,
1771 &error);
1772
1773 if (res == FALSE) {
1774 if (error != NULL) {
1775 g_warning ("Unable to notify network of music sharing: %s", error->message);
1776 g_error_free (error);
1777 } else {
1778 g_warning ("Unable to notify network of music sharing");
1779 }
1780 return FALSE;
1781 } else {
1782 rb_debug ("Published DAAP server information to mdns");
1783 }
1784
1785 return TRUE;
1786 }
1787
1788 static gboolean
1789 rb_daap_share_publish_stop (RBDAAPShare *share)
1790 {
1791 if (share->priv->publisher) {
1792 gboolean res;
1793 GError *error;
1794 error = NULL;
1795 res = rb_daap_mdns_publisher_withdraw (share->priv->publisher, &error);
1796 if (error != NULL) {
1797 g_warning ("Unable to withdraw music sharing service: %s", error->message);
1798 g_error_free (error);
1799 }
1800 return res;
1801 }
1802
1803 share->priv->published = FALSE;
1804 return TRUE;
1805 }
1806
1807 static void
1808 rb_daap_share_restart (RBDAAPShare *share)
1809 {
1810 gboolean res;
1811
1812 rb_daap_share_server_stop (share);
1813 res = rb_daap_share_server_start (share);
1814 if (res) {
1815 /* To update information just publish again */
1816 rb_daap_share_publish_start (share);
1817 } else {
1818 rb_daap_share_publish_stop (share);
1819 }
1820 }
1821
1822 static void
1823 rb_daap_share_maybe_restart (RBDAAPShare *share)
1824 {
1825 if (share->priv->published) {
1826 rb_daap_share_restart (share);
1827 }
1828 }
GNOME music player