Mercurial > audlegacy
annotate libaudacious/beepctrl.c @ 1532:f74a6ba233c2 trunk
[svn] - allow configdb::pnxmms::preset to set what pn preset to load on start
author | nenolod |
---|---|
date | Tue, 08 Aug 2006 02:19:55 -0700 |
parents | 8f3c0c773c92 |
children | 68aec931b0b6 |
rev | line source |
---|---|
0 | 1 /* XMMS - Cross-platform multimedia player |
2 * Copyright (C) 1998-2003 Peter Alm, Mikael Alm, Olle Hallnas, | |
3 * Thomas Nilsson and 4Front Technologies | |
4 * Copyright (C) 1999-2003 Haavard Kvaalen | |
5 * | |
6 * This program is free software; you can redistribute it and/or modify | |
7 * it under the terms of the GNU General Public License as published by | |
8 * the Free Software Foundation; either version 2 of the License, or | |
9 * (at your option) any later version. | |
10 * | |
11 * This program is distributed in the hope that it will be useful, | |
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
14 * GNU General Public License for more details. | |
15 * | |
16 * You should have received a copy of the GNU General Public License | |
17 * along with this program; if not, write to the Free Software | |
1459 | 18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. |
0 | 19 */ |
20 | |
21 #ifdef HAVE_CONFIG_H | |
22 # include "config.h" | |
23 #endif | |
24 | |
25 #include <glib.h> | |
26 #include <sys/types.h> | |
27 #include <sys/stat.h> | |
28 #include <sys/socket.h> | |
29 #include <sys/un.h> | |
1436
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
30 #include <arpa/inet.h> |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
31 #include <netdb.h> |
0 | 32 #include <errno.h> |
33 #include <stdio.h> | |
34 #include <stdlib.h> | |
35 #include <string.h> | |
36 #include "beepctrl.h" | |
37 #include "audacious/controlsocket.h" | |
1436
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
38 #include "libaudacious/configdb.h" |
0 | 39 |
1436
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
40 /* overrides audacious_get_session_uri(). */ |
1438 | 41 gchar *audacious_session_uri = NULL; |
1456
6fe7ba6e5489
[svn] - Don't poll the config database if not using TCP sockets.
nhjm449
parents:
1450
diff
changeset
|
42 gint *audacious_session_type = NULL; |
0 | 43 |
44 #ifdef HAVE_UNISTD_H | |
45 #include <unistd.h> | |
46 #endif | |
47 | |
48 static gint | |
49 read_all(gint fd, gpointer buf, size_t count) | |
50 { | |
51 size_t left = count; | |
52 GTimer *timer; | |
53 gulong usec; | |
54 gint r; | |
55 | |
56 timer = g_timer_new(); | |
57 | |
58 do { | |
59 if ((r = read(fd, buf, left)) < 0) { | |
60 count = -1; | |
61 break; | |
62 } | |
63 left -= r; | |
64 buf = (gchar *) buf + r; | |
65 g_timer_elapsed(timer, &usec); | |
66 } | |
67 while (left > 0 && usec <= CTRLSOCKET_IO_TIMEOUT_USEC); | |
68 | |
69 g_timer_destroy(timer); | |
70 return count - left; | |
71 } | |
72 | |
73 static gint | |
74 write_all(gint fd, gconstpointer buf, size_t count) | |
75 { | |
76 size_t left = count; | |
77 GTimer *timer; | |
78 gulong usec; | |
79 gint written; | |
80 | |
81 timer = g_timer_new(); | |
82 | |
83 do { | |
84 if ((written = write(fd, buf, left)) < 0) { | |
85 count = -1; | |
86 break; | |
87 } | |
88 left -= written; | |
89 buf = (gchar *) buf + written; | |
90 g_timer_elapsed(timer, &usec); | |
91 } | |
92 while (left > 0 && usec <= CTRLSOCKET_IO_TIMEOUT_USEC); | |
93 | |
94 g_timer_destroy(timer); | |
95 return count - left; | |
96 } | |
97 | |
98 static gpointer | |
99 remote_read_packet(gint fd, ServerPktHeader * pkt_hdr) | |
100 { | |
101 gpointer data = NULL; | |
102 | |
103 if (read_all(fd, pkt_hdr, sizeof(ServerPktHeader)) == | |
104 sizeof(ServerPktHeader)) { | |
105 if (pkt_hdr->data_length) { | |
106 size_t data_length = pkt_hdr->data_length; | |
107 data = g_malloc0(data_length); | |
625
0a73d1faeb4e
[svn] GCC 4.1 warning fixes by Diego 'Flameeyes' Petteno from Gentoo.
chainsaw
parents:
0
diff
changeset
|
108 if ((size_t)read_all(fd, data, data_length) < data_length) { |
0 | 109 g_free(data); |
110 data = NULL; | |
111 } | |
112 } | |
113 } | |
114 return data; | |
115 } | |
116 | |
117 static void | |
118 remote_read_ack(gint fd) | |
119 { | |
120 gpointer data; | |
121 ServerPktHeader pkt_hdr; | |
122 | |
123 data = remote_read_packet(fd, &pkt_hdr); | |
124 if (data) | |
125 g_free(data); | |
126 | |
127 } | |
128 | |
129 static void | |
130 remote_send_packet(gint fd, guint32 command, gpointer data, | |
131 guint32 data_length) | |
132 { | |
133 ClientPktHeader pkt_hdr; | |
134 | |
135 pkt_hdr.version = XMMS_PROTOCOL_VERSION; | |
136 pkt_hdr.command = command; | |
137 pkt_hdr.data_length = data_length; | |
625
0a73d1faeb4e
[svn] GCC 4.1 warning fixes by Diego 'Flameeyes' Petteno from Gentoo.
chainsaw
parents:
0
diff
changeset
|
138 if ((size_t)write_all(fd, &pkt_hdr, sizeof(ClientPktHeader)) < sizeof(pkt_hdr)) |
0 | 139 return; |
140 if (data_length && data) | |
141 write_all(fd, data, data_length); | |
142 } | |
143 | |
144 static void | |
145 remote_send_guint32(gint session, guint32 cmd, guint32 val) | |
146 { | |
147 gint fd; | |
148 | |
149 if ((fd = xmms_connect_to_session(session)) == -1) | |
150 return; | |
151 remote_send_packet(fd, cmd, &val, sizeof(guint32)); | |
152 remote_read_ack(fd); | |
153 close(fd); | |
154 } | |
155 | |
156 static void | |
157 remote_send_boolean(gint session, guint32 cmd, gboolean val) | |
158 { | |
159 gint fd; | |
160 | |
161 if ((fd = xmms_connect_to_session(session)) == -1) | |
162 return; | |
163 remote_send_packet(fd, cmd, &val, sizeof(gboolean)); | |
164 remote_read_ack(fd); | |
165 close(fd); | |
166 } | |
167 | |
168 static void | |
169 remote_send_gfloat(gint session, guint32 cmd, gfloat value) | |
170 { | |
171 gint fd; | |
172 | |
173 if ((fd = xmms_connect_to_session(session)) == -1) | |
174 return; | |
175 remote_send_packet(fd, cmd, &value, sizeof(gfloat)); | |
176 remote_read_ack(fd); | |
177 close(fd); | |
178 } | |
179 | |
180 static void | |
181 remote_send_string(gint session, guint32 cmd, gchar * string) | |
182 { | |
183 gint fd; | |
184 | |
185 if ((fd = xmms_connect_to_session(session)) == -1) | |
186 return; | |
187 remote_send_packet(fd, cmd, string, string ? strlen(string) + 1 : 0); | |
188 remote_read_ack(fd); | |
189 close(fd); | |
190 } | |
191 | |
192 static gboolean | |
193 remote_cmd(gint session, guint32 cmd) | |
194 { | |
195 gint fd; | |
196 | |
197 if ((fd = xmms_connect_to_session(session)) == -1) | |
198 return FALSE; | |
199 remote_send_packet(fd, cmd, NULL, 0); | |
200 remote_read_ack(fd); | |
201 close(fd); | |
202 | |
203 return TRUE; | |
204 } | |
205 | |
206 static gboolean | |
207 remote_get_gboolean(gint session, gint cmd) | |
208 { | |
209 ServerPktHeader pkt_hdr; | |
210 gboolean ret = FALSE; | |
211 gpointer data; | |
212 gint fd; | |
213 | |
214 if ((fd = xmms_connect_to_session(session)) == -1) | |
215 return ret; | |
216 remote_send_packet(fd, cmd, NULL, 0); | |
217 data = remote_read_packet(fd, &pkt_hdr); | |
218 if (data) { | |
219 ret = *((gboolean *) data); | |
220 g_free(data); | |
221 } | |
222 remote_read_ack(fd); | |
223 close(fd); | |
224 | |
225 return ret; | |
226 } | |
227 | |
228 static guint32 | |
229 remote_get_gint(gint session, gint cmd) | |
230 { | |
231 ServerPktHeader pkt_hdr; | |
232 gpointer data; | |
233 gint fd, ret = 0; | |
234 | |
235 if ((fd = xmms_connect_to_session(session)) == -1) | |
236 return ret; | |
237 remote_send_packet(fd, cmd, NULL, 0); | |
238 data = remote_read_packet(fd, &pkt_hdr); | |
239 if (data) { | |
240 ret = *((gint *) data); | |
241 g_free(data); | |
242 } | |
243 remote_read_ack(fd); | |
244 close(fd); | |
245 return ret; | |
246 } | |
247 | |
248 static gfloat | |
249 remote_get_gfloat(gint session, gint cmd) | |
250 { | |
251 ServerPktHeader pkt_hdr; | |
252 gpointer data; | |
253 gint fd; | |
254 gfloat ret = 0.0; | |
255 | |
256 if ((fd = xmms_connect_to_session(session)) == -1) | |
257 return ret; | |
258 remote_send_packet(fd, cmd, NULL, 0); | |
259 data = remote_read_packet(fd, &pkt_hdr); | |
260 if (data) { | |
261 ret = *((gfloat *) data); | |
262 g_free(data); | |
263 } | |
264 remote_read_ack(fd); | |
265 close(fd); | |
266 return ret; | |
267 } | |
268 | |
269 gchar * | |
270 remote_get_string(gint session, gint cmd) | |
271 { | |
272 ServerPktHeader pkt_hdr; | |
273 gpointer data; | |
274 gint fd; | |
275 | |
276 if ((fd = xmms_connect_to_session(session)) == -1) | |
277 return NULL; | |
278 remote_send_packet(fd, cmd, NULL, 0); | |
279 data = remote_read_packet(fd, &pkt_hdr); | |
280 remote_read_ack(fd); | |
281 close(fd); | |
282 return data; | |
283 } | |
284 | |
285 gchar * | |
286 remote_get_string_pos(gint session, gint cmd, guint32 pos) | |
287 { | |
288 ServerPktHeader pkt_hdr; | |
289 gpointer data; | |
290 gint fd; | |
291 | |
292 if ((fd = xmms_connect_to_session(session)) == -1) | |
293 return NULL; | |
294 remote_send_packet(fd, cmd, &pos, sizeof(guint32)); | |
295 data = remote_read_packet(fd, &pkt_hdr); | |
296 remote_read_ack(fd); | |
297 close(fd); | |
298 return data; | |
299 } | |
300 | |
1437 | 301 void |
302 audacious_set_session_uri(gchar *uri) | |
303 { | |
1438 | 304 audacious_session_uri = uri; |
1437 | 305 } |
306 | |
1436
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
307 gchar * |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
308 audacious_get_session_uri(gint session) |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
309 { |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
310 ConfigDb *db; |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
311 gchar *value = NULL; |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
312 |
1438 | 313 if (audacious_session_uri != NULL) |
314 { | |
315 return audacious_session_uri; | |
316 } | |
1436
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
317 |
1456
6fe7ba6e5489
[svn] - Don't poll the config database if not using TCP sockets.
nhjm449
parents:
1450
diff
changeset
|
318 if (audacious_session_type != AUDACIOUS_TYPE_UNIX) |
6fe7ba6e5489
[svn] - Don't poll the config database if not using TCP sockets.
nhjm449
parents:
1450
diff
changeset
|
319 { |
6fe7ba6e5489
[svn] - Don't poll the config database if not using TCP sockets.
nhjm449
parents:
1450
diff
changeset
|
320 db = bmp_cfg_db_open(); |
1444
c04ce16b2b57
[svn] - libaudacious/beepctrl.c: optimise further and be more paranoid about leaks
nenolod
parents:
1442
diff
changeset
|
321 |
1456
6fe7ba6e5489
[svn] - Don't poll the config database if not using TCP sockets.
nhjm449
parents:
1450
diff
changeset
|
322 bmp_cfg_db_get_string(db, NULL, "listen_uri_base", &value); |
1436
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
323 |
1456
6fe7ba6e5489
[svn] - Don't poll the config database if not using TCP sockets.
nhjm449
parents:
1450
diff
changeset
|
324 bmp_cfg_db_close(db); |
6fe7ba6e5489
[svn] - Don't poll the config database if not using TCP sockets.
nhjm449
parents:
1450
diff
changeset
|
325 } |
1442 | 326 |
1436
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
327 if (value == NULL) |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
328 return g_strdup_printf("unix://localhost/%s/%s_%s.%d", g_get_tmp_dir(), |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
329 CTRLSOCKET_NAME, g_get_user_name(), session); |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
330 |
1444
c04ce16b2b57
[svn] - libaudacious/beepctrl.c: optimise further and be more paranoid about leaks
nenolod
parents:
1442
diff
changeset
|
331 audacious_session_uri = value; |
c04ce16b2b57
[svn] - libaudacious/beepctrl.c: optimise further and be more paranoid about leaks
nenolod
parents:
1442
diff
changeset
|
332 |
1436
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
333 return value; |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
334 } |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
335 |
1456
6fe7ba6e5489
[svn] - Don't poll the config database if not using TCP sockets.
nhjm449
parents:
1450
diff
changeset
|
336 void |
6fe7ba6e5489
[svn] - Don't poll the config database if not using TCP sockets.
nhjm449
parents:
1450
diff
changeset
|
337 audacious_set_session_type(gint *type) |
6fe7ba6e5489
[svn] - Don't poll the config database if not using TCP sockets.
nhjm449
parents:
1450
diff
changeset
|
338 { |
6fe7ba6e5489
[svn] - Don't poll the config database if not using TCP sockets.
nhjm449
parents:
1450
diff
changeset
|
339 audacious_session_type = type; |
6fe7ba6e5489
[svn] - Don't poll the config database if not using TCP sockets.
nhjm449
parents:
1450
diff
changeset
|
340 } |
6fe7ba6e5489
[svn] - Don't poll the config database if not using TCP sockets.
nhjm449
parents:
1450
diff
changeset
|
341 |
6fe7ba6e5489
[svn] - Don't poll the config database if not using TCP sockets.
nhjm449
parents:
1450
diff
changeset
|
342 gint * |
1436
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
343 audacious_determine_session_type(gint session) |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
344 { |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
345 gchar *uri; |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
346 |
1456
6fe7ba6e5489
[svn] - Don't poll the config database if not using TCP sockets.
nhjm449
parents:
1450
diff
changeset
|
347 if (audacious_session_type != NULL) |
6fe7ba6e5489
[svn] - Don't poll the config database if not using TCP sockets.
nhjm449
parents:
1450
diff
changeset
|
348 { |
6fe7ba6e5489
[svn] - Don't poll the config database if not using TCP sockets.
nhjm449
parents:
1450
diff
changeset
|
349 return audacious_session_type; |
6fe7ba6e5489
[svn] - Don't poll the config database if not using TCP sockets.
nhjm449
parents:
1450
diff
changeset
|
350 } |
6fe7ba6e5489
[svn] - Don't poll the config database if not using TCP sockets.
nhjm449
parents:
1450
diff
changeset
|
351 |
1436
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
352 uri = audacious_get_session_uri(session); |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
353 |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
354 if (!g_strncasecmp(uri, "tcp://", 6)) |
1456
6fe7ba6e5489
[svn] - Don't poll the config database if not using TCP sockets.
nhjm449
parents:
1450
diff
changeset
|
355 audacious_session_type = (gint *) AUDACIOUS_TYPE_TCP; |
1436
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
356 else |
1456
6fe7ba6e5489
[svn] - Don't poll the config database if not using TCP sockets.
nhjm449
parents:
1450
diff
changeset
|
357 audacious_session_type = (gint *) AUDACIOUS_TYPE_UNIX; |
1436
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
358 |
1456
6fe7ba6e5489
[svn] - Don't poll the config database if not using TCP sockets.
nhjm449
parents:
1450
diff
changeset
|
359 if (audacious_session_type == NULL) |
6fe7ba6e5489
[svn] - Don't poll the config database if not using TCP sockets.
nhjm449
parents:
1450
diff
changeset
|
360 audacious_session_type = (gint *) AUDACIOUS_TYPE_UNIX; |
6fe7ba6e5489
[svn] - Don't poll the config database if not using TCP sockets.
nhjm449
parents:
1450
diff
changeset
|
361 |
1500 | 362 /* memory leak! */ |
363 g_free(uri); | |
364 | |
1456
6fe7ba6e5489
[svn] - Don't poll the config database if not using TCP sockets.
nhjm449
parents:
1450
diff
changeset
|
365 return audacious_session_type; |
1436
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
366 } |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
367 |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
368 /* tcp://192.168.100.1:5900/zyzychynxi389xvmfewqaxznvnw */ |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
369 void |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
370 audacious_decode_tcp_uri(gint session, gchar *in, gchar **host, gint *port, gchar **key) |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
371 { |
1439 | 372 static gchar *workbuf, *keybuf; |
1436
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
373 gint iport; |
1439 | 374 gchar *tmp = g_strdup(in); |
1436
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
375 |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
376 /* split out the host/port and key */ |
1439 | 377 workbuf = tmp; |
1448
3b1c464cbbb0
[svn] Seems safer to me to free this way, assuming I'm not misreading.
nemo
parents:
1447
diff
changeset
|
378 workbuf += 6; |
1439 | 379 |
1448
3b1c464cbbb0
[svn] Seems safer to me to free this way, assuming I'm not misreading.
nemo
parents:
1447
diff
changeset
|
380 keybuf = strchr(workbuf, '/'); |
1439 | 381 *keybuf++ = '\0'; |
1436
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
382 |
1441
ed80e946f30b
[svn] - ok, don't eat up all the system ram (I forgot to g_free())
nenolod
parents:
1439
diff
changeset
|
383 *key = g_strdup(keybuf); |
1436
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
384 |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
385 if (strchr(workbuf, ':') == NULL) |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
386 { |
1441
ed80e946f30b
[svn] - ok, don't eat up all the system ram (I forgot to g_free())
nenolod
parents:
1439
diff
changeset
|
387 *host = g_strdup(workbuf); |
1436
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
388 *port = 37370 + session; |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
389 } |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
390 else |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
391 { |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
392 gchar *hostbuf = NULL; |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
393 sscanf(workbuf, "%s:%d", hostbuf, &iport); |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
394 |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
395 *port = iport + session; |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
396 } |
1441
ed80e946f30b
[svn] - ok, don't eat up all the system ram (I forgot to g_free())
nenolod
parents:
1439
diff
changeset
|
397 |
1447 | 398 g_free(tmp); |
1436
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
399 } |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
400 |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
401 /* unix://localhost/tmp/audacious_nenolod.0 */ |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
402 void |
1439 | 403 audacious_decode_unix_uri(gint session, gchar *in, gchar **key) |
1436
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
404 { |
1439 | 405 static gchar *workbuf, *keybuf; |
406 gchar *tmp = g_strdup(in); | |
1436
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
407 |
1439 | 408 /* split out the host/port and key */ |
409 workbuf = tmp; | |
1448
3b1c464cbbb0
[svn] Seems safer to me to free this way, assuming I'm not misreading.
nemo
parents:
1447
diff
changeset
|
410 workbuf += 7; |
1436
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
411 |
1448
3b1c464cbbb0
[svn] Seems safer to me to free this way, assuming I'm not misreading.
nemo
parents:
1447
diff
changeset
|
412 keybuf = strchr(workbuf, '/'); |
1439 | 413 *keybuf++ = '\0'; |
414 | |
1441
ed80e946f30b
[svn] - ok, don't eat up all the system ram (I forgot to g_free())
nenolod
parents:
1439
diff
changeset
|
415 *key = g_strdup(keybuf); |
ed80e946f30b
[svn] - ok, don't eat up all the system ram (I forgot to g_free())
nenolod
parents:
1439
diff
changeset
|
416 |
1447 | 417 g_free(tmp); |
1436
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
418 } |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
419 |
0 | 420 gint |
421 xmms_connect_to_session(gint session) | |
422 { | |
423 gint fd; | |
1456
6fe7ba6e5489
[svn] - Don't poll the config database if not using TCP sockets.
nhjm449
parents:
1450
diff
changeset
|
424 gint *type = audacious_determine_session_type(session); |
1436
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
425 gchar *uri = audacious_get_session_uri(session); |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
426 |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
427 if (type == AUDACIOUS_TYPE_UNIX) |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
428 { |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
429 if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) != -1) |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
430 { |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
431 uid_t stored_uid, euid; |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
432 struct sockaddr_un saddr; |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
433 gchar *path; |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
434 |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
435 saddr.sun_family = AF_UNIX; |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
436 stored_uid = getuid(); |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
437 euid = geteuid(); |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
438 setuid(euid); |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
439 |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
440 audacious_decode_unix_uri(session, uri, &path); |
0 | 441 |
1436
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
442 g_strlcpy(saddr.sun_path, path, 108); |
1441
ed80e946f30b
[svn] - ok, don't eat up all the system ram (I forgot to g_free())
nenolod
parents:
1439
diff
changeset
|
443 g_free(path); |
1436
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
444 setreuid(stored_uid, euid); |
1501 | 445 |
446 g_free(uri); | |
447 | |
1436
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
448 if (connect(fd, (struct sockaddr *) &saddr, sizeof(saddr)) != -1) |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
449 return fd; |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
450 } |
0 | 451 } |
1436
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
452 else |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
453 { |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
454 if ((fd = socket(AF_INET, SOCK_STREAM, 0)) != -1) |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
455 { |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
456 struct hostent *hp; |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
457 struct sockaddr_in saddr; |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
458 gchar *host, *key; |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
459 gint port; |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
460 |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
461 audacious_decode_tcp_uri(session, uri, &host, &port, &key); |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
462 |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
463 /* resolve it */ |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
464 if ((hp = gethostbyname(host)) == NULL) |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
465 { |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
466 close(fd); |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
467 return -1; |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
468 } |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
469 |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
470 memset(&saddr, '\0', sizeof(saddr)); |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
471 saddr.sin_family = AF_INET; |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
472 saddr.sin_port = htons(port); |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
473 memcpy(&saddr.sin_addr, hp->h_addr, hp->h_length); |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
474 |
1441
ed80e946f30b
[svn] - ok, don't eat up all the system ram (I forgot to g_free())
nenolod
parents:
1439
diff
changeset
|
475 g_free(host); |
ed80e946f30b
[svn] - ok, don't eat up all the system ram (I forgot to g_free())
nenolod
parents:
1439
diff
changeset
|
476 g_free(key); |
ed80e946f30b
[svn] - ok, don't eat up all the system ram (I forgot to g_free())
nenolod
parents:
1439
diff
changeset
|
477 |
1501 | 478 g_free(uri); |
479 | |
1436
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
480 if (connect(fd, (struct sockaddr *) &saddr, sizeof(saddr)) != -1) |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
481 return fd; |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
482 } |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
483 } |
c70b68bcf527
[svn] - add framework for later handling tcp:// connections
nenolod
parents:
984
diff
changeset
|
484 |
0 | 485 close(fd); |
486 return -1; | |
487 } | |
488 | |
489 void | |
490 xmms_remote_playlist(gint session, gchar ** list, gint num, gboolean enqueue) | |
491 { | |
492 gint fd, i; | |
493 gchar *data, *ptr; | |
494 gint data_length; | |
495 guint32 len; | |
496 | |
497 g_return_if_fail(list != NULL); | |
498 g_return_if_fail(num > 0); | |
499 | |
500 if (!enqueue) | |
501 xmms_remote_playlist_clear(session); | |
502 | |
503 if ((fd = xmms_connect_to_session(session)) == -1) | |
504 return; | |
505 | |
506 for (i = 0, data_length = 0; i < num; i++) | |
507 data_length += (((strlen(list[i]) + 1) + 3) / 4) * 4 + 4; | |
508 if (data_length) { | |
509 data_length += 4; | |
510 data = g_malloc(data_length); | |
511 for (i = 0, ptr = data; i < num; i++) { | |
512 len = strlen(list[i]) + 1; | |
513 *((guint32 *) ptr) = len; | |
514 ptr += 4; | |
515 memcpy(ptr, list[i], len); | |
516 ptr += ((len + 3) / 4) * 4; | |
517 } | |
518 *((guint32 *) ptr) = 0; | |
519 remote_send_packet(fd, CMD_PLAYLIST_ADD, data, data_length); | |
520 remote_read_ack(fd); | |
521 close(fd); | |
522 g_free(data); | |
523 } | |
524 | |
525 if (!enqueue) | |
526 xmms_remote_play(session); | |
527 } | |
528 | |
529 gint | |
530 xmms_remote_get_version(gint session) | |
531 { | |
532 return remote_get_gint(session, CMD_GET_VERSION); | |
533 } | |
534 | |
535 void | |
536 xmms_remote_play_files(gint session, GList * list) | |
537 { | |
538 g_return_if_fail(list != NULL); | |
539 | |
540 xmms_remote_playlist_clear(session); | |
541 xmms_remote_add_files(session, list); | |
542 xmms_remote_play(session); | |
543 } | |
544 | |
545 void | |
546 xmms_remote_playlist_add(gint session, GList * list) | |
547 { | |
548 gchar **str_list; | |
549 GList *node; | |
550 gint i, num; | |
551 | |
552 g_return_if_fail(list != NULL); | |
553 | |
554 num = g_list_length(list); | |
555 str_list = g_malloc0(num * sizeof(gchar *)); | |
556 for (i = 0, node = list; i < num && node; i++, node = g_list_next(node)) | |
557 str_list[i] = node->data; | |
558 | |
559 xmms_remote_playlist(session, str_list, num, TRUE); | |
560 g_free(str_list); | |
561 } | |
562 | |
563 void | |
564 xmms_remote_playlist_delete(gint session, gint pos) | |
565 { | |
566 remote_send_guint32(session, CMD_PLAYLIST_DELETE, pos); | |
567 } | |
568 | |
569 void | |
570 xmms_remote_play(gint session) | |
571 { | |
572 remote_cmd(session, CMD_PLAY); | |
573 } | |
574 | |
575 void | |
576 xmms_remote_pause(gint session) | |
577 { | |
578 remote_cmd(session, CMD_PAUSE); | |
579 } | |
580 | |
581 void | |
582 xmms_remote_stop(gint session) | |
583 { | |
584 remote_cmd(session, CMD_STOP); | |
585 } | |
586 | |
587 void | |
588 xmms_remote_play_pause(gint session) | |
589 { | |
590 remote_cmd(session, CMD_PLAY_PAUSE); | |
591 } | |
592 | |
593 gboolean | |
594 xmms_remote_is_playing(gint session) | |
595 { | |
596 return remote_get_gboolean(session, CMD_IS_PLAYING); | |
597 } | |
598 | |
599 gboolean | |
600 xmms_remote_is_paused(gint session) | |
601 { | |
602 return remote_get_gboolean(session, CMD_IS_PAUSED); | |
603 } | |
604 | |
605 gint | |
606 xmms_remote_get_playlist_pos(gint session) | |
607 { | |
608 return remote_get_gint(session, CMD_GET_PLAYLIST_POS); | |
609 } | |
610 | |
611 void | |
612 xmms_remote_set_playlist_pos(gint session, gint pos) | |
613 { | |
614 remote_send_guint32(session, CMD_SET_PLAYLIST_POS, pos); | |
615 } | |
616 | |
617 gint | |
618 xmms_remote_get_playlist_length(gint session) | |
619 { | |
620 return remote_get_gint(session, CMD_GET_PLAYLIST_LENGTH); | |
621 } | |
622 | |
623 void | |
624 xmms_remote_playlist_clear(gint session) | |
625 { | |
626 remote_cmd(session, CMD_PLAYLIST_CLEAR); | |
627 } | |
628 | |
629 gint | |
630 xmms_remote_get_output_time(gint session) | |
631 { | |
632 return remote_get_gint(session, CMD_GET_OUTPUT_TIME); | |
633 } | |
634 | |
635 void | |
636 xmms_remote_jump_to_time(gint session, gint pos) | |
637 { | |
638 remote_send_guint32(session, CMD_JUMP_TO_TIME, pos); | |
639 } | |
640 | |
641 void | |
642 xmms_remote_get_volume(gint session, gint * vl, gint * vr) | |
643 { | |
644 ServerPktHeader pkt_hdr; | |
645 gint fd; | |
646 gpointer data; | |
647 | |
648 if ((fd = xmms_connect_to_session(session)) == -1) | |
649 return; | |
650 | |
651 remote_send_packet(fd, CMD_GET_VOLUME, NULL, 0); | |
652 data = remote_read_packet(fd, &pkt_hdr); | |
653 if (data) { | |
654 *vl = ((guint32 *) data)[0]; | |
655 *vr = ((guint32 *) data)[1]; | |
656 g_free(data); | |
657 } | |
658 remote_read_ack(fd); | |
659 close(fd); | |
660 } | |
661 | |
662 gint | |
663 xmms_remote_get_main_volume(gint session) | |
664 { | |
665 gint vl, vr; | |
666 | |
667 xmms_remote_get_volume(session, &vl, &vr); | |
668 | |
669 return (vl > vr) ? vl : vr; | |
670 } | |
671 | |
672 gint | |
673 xmms_remote_get_balance(gint session) | |
674 { | |
675 return remote_get_gint(session, CMD_GET_BALANCE); | |
676 } | |
677 | |
678 void | |
679 xmms_remote_set_volume(gint session, gint vl, gint vr) | |
680 { | |
681 gint fd; | |
682 guint32 v[2]; | |
683 | |
684 if (vl < 0) | |
685 vl = 0; | |
686 if (vl > 100) | |
687 vl = 100; | |
688 if (vr < 0) | |
689 vr = 0; | |
690 if (vr > 100) | |
691 vr = 100; | |
692 | |
693 if ((fd = xmms_connect_to_session(session)) == -1) | |
694 return; | |
695 v[0] = vl; | |
696 v[1] = vr; | |
697 remote_send_packet(fd, CMD_SET_VOLUME, v, 2 * sizeof(guint32)); | |
698 remote_read_ack(fd); | |
699 close(fd); | |
700 } | |
701 | |
702 void | |
703 xmms_remote_set_main_volume(gint session, gint v) | |
704 { | |
705 gint b, vl, vr; | |
706 | |
707 b = xmms_remote_get_balance(session); | |
708 | |
709 if (b < 0) { | |
710 vl = v; | |
711 vr = (v * (100 - abs(b))) / 100; | |
712 } | |
713 else if (b > 0) { | |
714 vl = (v * (100 - b)) / 100; | |
715 vr = v; | |
716 } | |
717 else | |
718 vl = vr = v; | |
719 xmms_remote_set_volume(session, vl, vr); | |
720 } | |
721 | |
722 void | |
723 xmms_remote_set_balance(gint session, gint b) | |
724 { | |
725 gint v, vl, vr; | |
726 | |
727 if (b < -100) | |
728 b = -100; | |
729 if (b > 100) | |
730 b = 100; | |
731 | |
732 v = xmms_remote_get_main_volume(session); | |
733 | |
734 if (b < 0) { | |
735 vl = v; | |
736 vr = (v * (100 - abs(b))) / 100; | |
737 } | |
738 else if (b > 0) { | |
739 vl = (v * (100 - b)) / 100; | |
740 vr = v; | |
741 } | |
742 else | |
743 vl = vr = v; | |
744 xmms_remote_set_volume(session, vl, vr); | |
745 } | |
746 | |
747 gchar * | |
748 xmms_remote_get_skin(gint session) | |
749 { | |
750 return remote_get_string(session, CMD_GET_SKIN); | |
751 } | |
752 | |
753 void | |
754 xmms_remote_set_skin(gint session, gchar * skinfile) | |
755 { | |
756 remote_send_string(session, CMD_SET_SKIN, skinfile); | |
757 } | |
758 | |
759 gchar * | |
760 xmms_remote_get_playlist_file(gint session, gint pos) | |
761 { | |
762 return remote_get_string_pos(session, CMD_GET_PLAYLIST_FILE, pos); | |
763 } | |
764 | |
765 gchar * | |
766 xmms_remote_get_playlist_title(gint session, gint pos) | |
767 { | |
768 return remote_get_string_pos(session, CMD_GET_PLAYLIST_TITLE, pos); | |
769 } | |
770 | |
771 gint | |
772 xmms_remote_get_playlist_time(gint session, gint pos) | |
773 { | |
774 ServerPktHeader pkt_hdr; | |
775 gpointer data; | |
776 gint fd, ret = 0; | |
777 guint32 p = pos; | |
778 | |
779 if ((fd = xmms_connect_to_session(session)) == -1) | |
780 return ret; | |
781 remote_send_packet(fd, CMD_GET_PLAYLIST_TIME, &p, sizeof(guint32)); | |
782 data = remote_read_packet(fd, &pkt_hdr); | |
783 if (data) { | |
784 ret = *((gint *) data); | |
785 g_free(data); | |
786 } | |
787 remote_read_ack(fd); | |
788 close(fd); | |
789 return ret; | |
790 } | |
791 | |
792 void | |
793 xmms_remote_get_info(gint session, gint * rate, gint * freq, gint * nch) | |
794 { | |
795 ServerPktHeader pkt_hdr; | |
796 gint fd; | |
797 gpointer data; | |
798 | |
799 if ((fd = xmms_connect_to_session(session)) == -1) | |
800 return; | |
801 remote_send_packet(fd, CMD_GET_INFO, NULL, 0); | |
802 data = remote_read_packet(fd, &pkt_hdr); | |
803 if (data) { | |
804 *rate = ((guint32 *) data)[0]; | |
805 *freq = ((guint32 *) data)[1]; | |
806 *nch = ((guint32 *) data)[2]; | |
807 g_free(data); | |
808 } | |
809 remote_read_ack(fd); | |
810 close(fd); | |
811 } | |
812 | |
813 void | |
814 xmms_remote_get_eq_data(gint session) | |
815 { | |
816 /* Obsolete */ | |
817 } | |
818 | |
819 void | |
820 xmms_remote_set_eq_data(gint session) | |
821 { | |
822 /* Obsolete */ | |
823 } | |
824 | |
825 void | |
826 xmms_remote_pl_win_toggle(gint session, gboolean show) | |
827 { | |
828 remote_send_boolean(session, CMD_PL_WIN_TOGGLE, show); | |
829 } | |
830 | |
831 void | |
832 xmms_remote_eq_win_toggle(gint session, gboolean show) | |
833 { | |
834 remote_send_boolean(session, CMD_EQ_WIN_TOGGLE, show); | |
835 } | |
836 | |
837 void | |
838 xmms_remote_main_win_toggle(gint session, gboolean show) | |
839 { | |
840 remote_send_boolean(session, CMD_MAIN_WIN_TOGGLE, show); | |
841 } | |
842 | |
843 gboolean | |
844 xmms_remote_is_main_win(gint session) | |
845 { | |
846 return remote_get_gboolean(session, CMD_IS_MAIN_WIN); | |
847 } | |
848 | |
849 gboolean | |
850 xmms_remote_is_pl_win(gint session) | |
851 { | |
852 return remote_get_gboolean(session, CMD_IS_PL_WIN); | |
853 } | |
854 | |
855 gboolean | |
856 xmms_remote_is_eq_win(gint session) | |
857 { | |
858 return remote_get_gboolean(session, CMD_IS_EQ_WIN); | |
859 } | |
860 | |
861 void | |
862 xmms_remote_show_prefs_box(gint session) | |
863 { | |
864 remote_cmd(session, CMD_SHOW_PREFS_BOX); | |
865 } | |
866 | |
867 void | |
984 | 868 xmms_remote_show_jtf_box(gint session) |
869 { | |
870 remote_cmd(session, CMD_SHOW_JTF_BOX); | |
871 } | |
872 | |
873 void | |
0 | 874 xmms_remote_toggle_aot(gint session, gboolean ontop) |
875 { | |
876 remote_send_boolean(session, CMD_TOGGLE_AOT, ontop); | |
877 } | |
878 | |
879 void | |
880 xmms_remote_show_about_box(gint session) | |
881 { | |
882 remote_cmd(session, CMD_SHOW_ABOUT_BOX); | |
883 } | |
884 | |
885 void | |
886 xmms_remote_eject(gint session) | |
887 { | |
888 remote_cmd(session, CMD_EJECT); | |
889 } | |
890 | |
891 void | |
892 xmms_remote_playlist_prev(gint session) | |
893 { | |
894 remote_cmd(session, CMD_PLAYLIST_PREV); | |
895 } | |
896 | |
897 void | |
898 xmms_remote_playlist_next(gint session) | |
899 { | |
900 remote_cmd(session, CMD_PLAYLIST_NEXT); | |
901 } | |
902 | |
903 void | |
904 xmms_remote_playlist_add_url_string(gint session, gchar * string) | |
905 { | |
906 g_return_if_fail(string != NULL); | |
907 remote_send_string(session, CMD_PLAYLIST_ADD_URL_STRING, string); | |
908 } | |
909 | |
910 void | |
911 xmms_remote_playlist_ins_url_string(gint session, gchar * string, gint pos) | |
912 { | |
913 gint fd, size; | |
914 gchar *packet; | |
915 | |
916 g_return_if_fail(string != NULL); | |
917 | |
918 size = strlen(string) + 1 + sizeof(gint); | |
919 | |
920 if ((fd = xmms_connect_to_session(session)) == -1) | |
921 return; | |
922 | |
923 packet = g_malloc0(size); | |
924 *((gint *) packet) = pos; | |
925 strcpy(packet + sizeof(gint), string); | |
926 remote_send_packet(fd, CMD_PLAYLIST_INS_URL_STRING, packet, size); | |
927 remote_read_ack(fd); | |
928 close(fd); | |
929 g_free(packet); | |
930 } | |
931 | |
932 gboolean | |
933 xmms_remote_is_running(gint session) | |
934 { | |
935 return remote_cmd(session, CMD_PING); | |
936 } | |
937 | |
938 void | |
939 xmms_remote_toggle_repeat(gint session) | |
940 { | |
941 remote_cmd(session, CMD_TOGGLE_REPEAT); | |
942 } | |
943 | |
944 void | |
945 xmms_remote_toggle_shuffle(gint session) | |
946 { | |
947 remote_cmd(session, CMD_TOGGLE_SHUFFLE); | |
948 } | |
949 | |
950 void | |
951 xmms_remote_toggle_advance(int session) | |
952 { | |
953 remote_cmd(session, CMD_TOGGLE_ADVANCE); | |
954 } | |
955 | |
956 gboolean | |
957 xmms_remote_is_repeat(gint session) | |
958 { | |
959 return remote_get_gboolean(session, CMD_IS_REPEAT); | |
960 } | |
961 | |
962 gboolean | |
963 xmms_remote_is_shuffle(gint session) | |
964 { | |
965 return remote_get_gboolean(session, CMD_IS_SHUFFLE); | |
966 } | |
967 | |
968 gboolean | |
969 xmms_remote_is_advance(gint session) | |
970 { | |
971 return remote_get_gboolean(session, CMD_IS_ADVANCE); | |
972 } | |
973 | |
974 void | |
975 xmms_remote_playqueue_add(gint session, gint pos) | |
976 { | |
977 remote_send_guint32(session, CMD_PLAYQUEUE_ADD, pos); | |
978 } | |
979 | |
980 void | |
981 xmms_remote_playqueue_remove(gint session, gint pos) | |
982 { | |
983 remote_send_guint32(session, CMD_PLAYQUEUE_REMOVE, pos); | |
984 } | |
985 | |
984 | 986 void |
987 xmms_remote_playqueue_clear(gint session) | |
988 { | |
989 remote_cmd(session, CMD_PLAYQUEUE_CLEAR); | |
990 } | |
991 | |
0 | 992 gint |
993 xmms_remote_get_playqueue_length(gint session) | |
994 { | |
995 return remote_get_gint(session, CMD_GET_PLAYQUEUE_LENGTH); | |
996 } | |
997 | |
984 | 998 gboolean |
999 xmms_remote_playqueue_is_queued(gint session, gint pos) | |
1000 { | |
1001 ServerPktHeader pkt_hdr; | |
1002 gpointer data; | |
1003 gint fd, ret = 0; | |
1004 guint32 p = pos; | |
1005 | |
1006 if ((fd = xmms_connect_to_session(session)) == -1) | |
1007 return ret; | |
1008 remote_send_packet(fd, CMD_PLAYQUEUE_IS_QUEUED, &p, sizeof(guint32)); | |
1009 data = remote_read_packet(fd, &pkt_hdr); | |
1010 if (data) { | |
1011 ret = *((gint *) data); | |
1012 g_free(data); | |
1013 } | |
1014 remote_read_ack(fd); | |
1015 close(fd); | |
1016 return ret; | |
1017 } | |
1018 | |
1019 gint | |
1020 xmms_remote_get_playqueue_position(gint session, gint pos) | |
1021 { | |
1022 ServerPktHeader pkt_hdr; | |
1023 gpointer data; | |
1024 gint fd, ret = 0; | |
1025 guint32 p = pos; | |
1026 | |
1027 if ((fd = xmms_connect_to_session(session)) == -1) | |
1028 return ret; | |
1029 remote_send_packet(fd, CMD_PLAYQUEUE_GET_POS, &p, sizeof(guint32)); | |
1030 data = remote_read_packet(fd, &pkt_hdr); | |
1031 if (data) { | |
1032 ret = *((gint *) data); | |
1033 g_free(data); | |
1034 } | |
1035 remote_read_ack(fd); | |
1036 close(fd); | |
1037 return ret; | |
1038 } | |
1039 | |
1040 gint | |
1041 xmms_remote_get_playqueue_queue_position(gint session, gint pos) | |
1042 { | |
1043 ServerPktHeader pkt_hdr; | |
1044 gpointer data; | |
1045 gint fd, ret = 0; | |
1046 guint32 p = pos; | |
1047 | |
1048 if ((fd = xmms_connect_to_session(session)) == -1) | |
1049 return ret; | |
1050 remote_send_packet(fd, CMD_PLAYQUEUE_GET_QPOS, &p, sizeof(guint32)); | |
1051 data = remote_read_packet(fd, &pkt_hdr); | |
1052 if (data) { | |
1053 ret = *((gint *) data); | |
1054 g_free(data); | |
1055 } | |
1056 remote_read_ack(fd); | |
1057 close(fd); | |
1058 return ret; | |
1059 } | |
1060 | |
0 | 1061 void |
1062 xmms_remote_get_eq(gint session, gfloat * preamp, gfloat ** bands) | |
1063 { | |
1064 ServerPktHeader pkt_hdr; | |
1065 gint fd; | |
1066 gpointer data; | |
1067 | |
1068 if (preamp) | |
1069 *preamp = 0.0; | |
1070 | |
1071 if (bands) | |
1072 *bands = NULL; | |
1073 | |
1074 if ((fd = xmms_connect_to_session(session)) == -1) | |
1075 return; | |
1076 remote_send_packet(fd, CMD_GET_EQ, NULL, 0); | |
1077 data = remote_read_packet(fd, &pkt_hdr); | |
1078 if (data) { | |
1079 if (pkt_hdr.data_length >= 11 * sizeof(gfloat)) { | |
1080 if (preamp) | |
1081 *preamp = *((gfloat *) data); | |
1082 if (bands) | |
1083 *bands = | |
1084 (gfloat *) g_memdup((gfloat *) data + 1, | |
1085 10 * sizeof(gfloat)); | |
1086 } | |
1087 g_free(data); | |
1088 } | |
1089 remote_read_ack(fd); | |
1090 close(fd); | |
1091 } | |
1092 | |
1093 gfloat | |
1094 xmms_remote_get_eq_preamp(gint session) | |
1095 { | |
1096 return remote_get_gfloat(session, CMD_GET_EQ_PREAMP); | |
1097 } | |
1098 | |
1099 gfloat | |
1100 xmms_remote_get_eq_band(gint session, gint band) | |
1101 { | |
1102 ServerPktHeader pkt_hdr; | |
1103 gint fd; | |
1104 gpointer data; | |
1105 gfloat val = 0.0; | |
1106 | |
1107 if ((fd = xmms_connect_to_session(session)) == -1) | |
1108 return val; | |
1109 remote_send_packet(fd, CMD_GET_EQ_BAND, &band, sizeof(band)); | |
1110 data = remote_read_packet(fd, &pkt_hdr); | |
1111 if (data) { | |
1112 val = *((gfloat *) data); | |
1113 g_free(data); | |
1114 } | |
1115 remote_read_ack(fd); | |
1116 close(fd); | |
1117 return val; | |
1118 } | |
1119 | |
1120 void | |
1121 xmms_remote_set_eq(gint session, gfloat preamp, gfloat * bands) | |
1122 { | |
1123 gint fd, i; | |
1124 gfloat data[11]; | |
1125 | |
1126 g_return_if_fail(bands != NULL); | |
1127 | |
1128 if ((fd = xmms_connect_to_session(session)) == -1) | |
1129 return; | |
1130 data[0] = preamp; | |
1131 for (i = 0; i < 10; i++) | |
1132 data[i + 1] = bands[i]; | |
1133 remote_send_packet(fd, CMD_SET_EQ, data, sizeof(data)); | |
1134 remote_read_ack(fd); | |
1135 close(fd); | |
1136 } | |
1137 | |
1138 void | |
1139 xmms_remote_set_eq_preamp(gint session, gfloat preamp) | |
1140 { | |
1141 remote_send_gfloat(session, CMD_SET_EQ_PREAMP, preamp); | |
1142 } | |
1143 | |
1144 void | |
1145 xmms_remote_set_eq_band(gint session, gint band, gfloat value) | |
1146 { | |
1147 gint fd; | |
1148 gchar data[sizeof(gint) + sizeof(gfloat)]; | |
1149 | |
1150 if ((fd = xmms_connect_to_session(session)) == -1) | |
1151 return; | |
1152 *((gint *) data) = band; | |
1153 *((gfloat *) (data + sizeof(gint))) = value; | |
1154 remote_send_packet(fd, CMD_SET_EQ_BAND, data, sizeof(data)); | |
1155 remote_read_ack(fd); | |
1156 close(fd); | |
1157 } | |
1158 | |
1159 void | |
1160 xmms_remote_quit(gint session) | |
1161 { | |
1162 gint fd; | |
1163 | |
1164 if ((fd = xmms_connect_to_session(session)) == -1) | |
1165 return; | |
1166 remote_send_packet(fd, CMD_QUIT, NULL, 0); | |
1167 remote_read_ack(fd); | |
1168 close(fd); | |
1169 } | |
1170 | |
1171 void | |
1172 xmms_remote_activate(gint session) | |
1173 { | |
1174 gint fd; | |
1175 | |
1176 if ((fd = xmms_connect_to_session(session)) == -1) | |
1177 return; | |
1178 remote_send_packet(fd, CMD_ACTIVATE, NULL, 0); | |
1179 remote_read_ack(fd); | |
1180 close(fd); | |
1181 } |