source: roaraudio/roard/req.c @ 1044:9d5c342e6a14

Last change on this file since 1044:9d5c342e6a14 was 1044:9d5c342e6a14, checked in by phi, 15 years ago

ROAR_WARN() -> ROAR_DBG()

File size: 15.5 KB
Line 
1//req.c:
2
3/*
4 *      Copyright (C) Philipp 'ph3-der-loewe' Schafft - 2008
5 *
6 *  This file is part of roard a part of RoarAudio,
7 *  a cross-platform sound system for both, home and professional use.
8 *  See README for details.
9 *
10 *  This file is free software; you can redistribute it and/or modify
11 *  it under the terms of the GNU General Public License version 3
12 *  as published by the Free Software Foundation.
13 *
14 *  RoarAudio is distributed in the hope that it will be useful,
15 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
16 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17 *  GNU General Public License for more details.
18 *
19 *  You should have received a copy of the GNU General Public License
20 *  along with this software; see the file COPYING.  If not, write to
21 *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
22 *
23 */
24
25#include "roard.h"
26
27int req_on_noop        (int client, struct roar_message * mes, char * data) {
28 mes->cmd     = ROAR_CMD_OK;
29 mes->datalen = 0;
30 return 0;
31}
32
33int req_on_identify    (int client, struct roar_message * mes, char * data) {
34 struct roar_client * c;
35 int max_len;
36
37 if ( mes->datalen < 1 )
38  return -1;
39
40 clients_get(client, &c);
41
42 if ( mes->data[0] == 1 ) {
43  if ( c->pid == -1 ) {
44   c->pid       = ROAR_NET2HOST32(*(uint32_t*)((mes->data)+1));
45   ROAR_DBG("req_on_identify(): new PID: c->pid = %i", c->pid);
46  }
47
48  ROAR_DBG("req_on_identify(): final PID: c->pid = %i", c->pid);
49
50  max_len = (mes->datalen - 5) < (ROAR_BUFFER_NAME-1) ? (mes->datalen - 5) : (ROAR_BUFFER_NAME-1);
51
52  strncpy(c->name, mes->data + 5, max_len);
53  c->name[max_len] = 0;
54
55  mes->cmd     = ROAR_CMD_OK;
56  mes->datalen = 0;
57
58  ROAR_DBG("req_on_identify(*): client=%i, pid=%i", client, c->pid);
59  ROAR_DBG("req_on_identify(*) = 0");
60  return 0;
61 }
62
63 return -1;
64}
65
66int req_on_auth        (int client, struct roar_message * mes, char * data) {
67 // TODO: add code to support some auth.
68 mes->cmd     = ROAR_CMD_OK;
69 mes->datalen = 0;
70 return 0;
71}
72
73
74int req_on_new_stream  (int client, struct roar_message * mes, char * data) {
75 int stream;
76 struct roar_stream * s;
77
78 if ((stream = streams_new()) == -1 )
79  return -1;
80
81 if ( streams_get(stream, (struct roar_stream_server **)&s) == -1 ) {
82  streams_delete(stream);
83  return -1;
84 }
85
86 if ( client_stream_add(client, stream) == -1 ) {
87  streams_delete(stream);
88  return -1;
89 }
90
91 if ( roar_stream_m2s(s, mes) == -1 ) {
92  streams_delete(stream);
93  return -1;
94 }
95
96 ROAR_STREAM(s)->id = stream; // roar_stream_m2s() resets this
97 ROAR_STREAM_SERVER(s)->codec_orgi = ROAR_STREAM(s)->info.codec;
98
99 mes->cmd     = ROAR_CMD_OK;
100 mes->stream  = stream;
101 mes->datalen = 0;
102
103 return 0;
104}
105
106int req_on_exec_stream (int client, struct roar_message * mes, char * data) {
107 int r;
108
109 if ( (r = client_stream_exec(client, mes->stream)) == -1 )
110  return -1;
111
112 mes->cmd     = ROAR_CMD_OK;
113 mes->datalen = 0;
114
115 return 0;
116}
117
118int req_on_con_stream  (int client, struct roar_message * mes, char * data) {
119 char   host[80] = {0};
120 int    port = 0;
121 int    type;
122 int    fh;
123 int    len;
124
125 if ( mes->datalen < 4 )
126  return -1;
127
128 if ( *(mes->data) != 0 )
129  return -1;
130
131 if ( mes->datalen > 80 ) // we do not support long messages here
132  return -1;
133
134 type = (unsigned)mes->data[1];
135 port = ROAR_NET2HOST16(((uint16_t*)mes->data)[1]);
136
137 len = mes->datalen - 4;
138
139 strncpy(host, &(mes->data[4]), len);
140 host[len] = 0;
141
142 if ( type > ROAR_SOCKET_TYPE_MAX )
143  return -1;
144
145 if ( type == ROAR_SOCKET_TYPE_FILE ) // disabled because of security resons
146  return -1;
147
148 if ( type == ROAR_SOCKET_TYPE_FORK ) // why should we connect to ourself?
149  return -1;
150
151 ROAR_DBG("req_on_con_stream(*): CONNECT(type=%i, host='%s', port=%i)", type, host, port);
152
153 if ( (fh = roar_socket_open(ROAR_SOCKET_MODE_CONNECT, type, host, port)) == -1 )
154  return -1;
155
156 if ( client_stream_set_fh(client, mes->stream, fh) == -1 ) {
157  close(fh);
158  return 1;
159 }
160
161 mes->datalen = 0;
162 mes->cmd     = ROAR_CMD_OK;
163
164 return 0;
165}
166
167int req_on_passfh      (int client, struct roar_message * mes, char * data) {
168 int fh;
169 int sock = clients_get_fh(client);
170
171 if ( (fh = roar_socket_recv_fh(sock, NULL, NULL)) == -1 )
172  return -1;
173
174 if ( client_stream_set_fh(client, mes->stream, fh) == -1 ) {
175  close(fh);
176  return 1;
177 }
178
179
180 mes->datalen = 0;
181 mes->cmd     = ROAR_CMD_OK;
182
183 return 0;
184}
185
186int req_on_set_meta    (int client, struct roar_message * mes, char * data) {
187 int type;
188 int mode;
189 int namelen, vallen;
190 char   val[255+1];
191 char   name[ROAR_META_MAX_NAMELEN+1];
192
193 if ( mes->datalen < 3 )
194  return -1;
195
196 if ( mes->data[0] != 0 ) // version
197  return -1;
198
199 mode = (unsigned) mes->data[1];
200 type = (unsigned) mes->data[2];
201
202 ROAR_DBG("req_on_set_meta(*): mode=%i, type=%i", mode, type);
203
204 if ( mode == ROAR_META_MODE_CLEAR ) {
205  stream_meta_clear(mes->stream);
206  mes->datalen = 0;
207  mes->cmd     = ROAR_CMD_OK;
208  return 0;
209 } else if ( mode == ROAR_META_MODE_DELETE ) { // unsuppoerted at the moment
210  return -1;
211 } else if ( mode == ROAR_META_MODE_FINALIZE ) {
212  stream_meta_finalize(mes->stream);
213  mes->datalen = 0;
214  mes->cmd     = ROAR_CMD_OK;
215  return 0;
216 } else if ( mode == ROAR_META_MODE_SET || mode == ROAR_META_MODE_ADD ) {
217  if ( mes->datalen < 5 )
218   return -1;
219
220  namelen = (unsigned) mes->data[3];
221  vallen  = (unsigned) mes->data[4];
222
223  ROAR_DBG("req_on_set_meta(*): namelen=%i, vallen=%i", namelen, vallen);
224
225  if ( mes->datalen < (5 + namelen + vallen) )
226   return -1;
227
228  if ( namelen > ROAR_META_MAX_NAMELEN )
229   return -1;
230
231  strncpy(name, &(mes->data[5]), namelen);
232  name[namelen] = 0;
233
234  if ( vallen > 255 )
235   return -1;
236
237  strncpy(val, &(mes->data[5+namelen]), vallen);
238  val[vallen] = 0;
239
240  if ( mode == ROAR_META_MODE_SET ) {
241   if ( stream_meta_set(mes->stream, type, name, val) == -1 )
242    return -1;
243  } else {
244   if ( stream_meta_add(mes->stream, type, name, val) == -1 )
245    return -1;
246  }
247
248  mes->datalen = 0;
249  mes->cmd     = ROAR_CMD_OK;
250  return 0;
251 } else { // unknown mode!
252  return -1;
253 }
254
255 return -1;
256}
257
258int req_on_get_meta    (int client, struct roar_message * mes, char * data) {
259 int vallen;
260 int type;
261 char val[LIBROAR_BUFFER_MSGDATA-1];
262
263 if ( mes->datalen != 2 )
264  return -1;
265
266 if ( mes->data[0] != 0 ) // version
267  return -1;
268
269 type = (unsigned) mes->data[1];
270
271 if ( stream_meta_get(mes->stream, type, NULL, val, LIBROAR_BUFFER_MSGDATA-2) == -1 )
272  return -1;
273
274 vallen = strlen(val);
275
276 mes->cmd     = ROAR_CMD_OK;
277 mes->datalen = 2 + vallen;
278
279 mes->data[0] = 0;
280 mes->data[1] = (unsigned char) vallen;
281
282 val[vallen] = 0;
283
284 strncpy(&(mes->data[2]), val, vallen+1);
285
286 return 0;
287}
288
289int req_on_list_meta   (int client, struct roar_message * mes, char * data) {
290 int i;
291 int len = 0;
292 int types[ROAR_META_MAX_PER_STREAM];
293
294 if ( mes->datalen != 1 )
295  return -1;
296
297 if ( mes->data[0] != 0 ) // version
298  return -1;
299
300 if ( (len = stream_meta_list(mes->stream, types, ROAR_META_MAX_PER_STREAM)) == -1 )
301  return -1;
302
303 mes->cmd     = ROAR_CMD_OK;
304 mes->datalen = 1 + len;
305 mes->data[0] = 0;
306
307 for (i = 0; i < len; i++)
308  mes->data[i+1] = types[i];
309
310 return 0;
311}
312
313int req_on_server_oinfo    (int client, struct roar_message * mes, char * data) {
314 struct roar_stream s;
315//ROAR_DIR_OUTPUT
316
317 memset(&s, 0, sizeof(struct roar_stream));
318
319 s.dir           = ROAR_DIR_MIXING;
320 s.pos_rel_id    = -1;
321 s.info.rate     = g_sa->rate;
322 s.info.bits     = g_sa->bits;
323 s.info.channels = g_sa->channels;
324 s.info.codec    = g_sa->codec;
325 s.pos           = g_pos;
326
327 if ( roar_stream_s2m(&s, mes) == -1 )
328  return -1;
329
330 mes->cmd = ROAR_CMD_OK;
331
332 return 0;
333}
334
335
336int req_on_get_standby (int client, struct roar_message * mes, char * data) {
337 mes->cmd = ROAR_CMD_OK;
338 mes->datalen = 2;
339
340 *((uint16_t*)mes->data) = ROAR_HOST2NET16((unsigned) g_standby);
341
342 return 0;
343}
344
345int req_on_set_standby (int client, struct roar_message * mes, char * data) {
346 if ( mes->datalen != 2 )
347  return -1;
348
349 g_standby = ROAR_NET2HOST16(*((uint16_t*)mes->data));
350
351 mes->cmd     = ROAR_CMD_OK;
352 mes->datalen = 0;
353
354 return 0;
355}
356
357int req_on_exit      (int client, struct roar_message * mes, char * data) {
358 int term = 0;
359
360 if ( mes->datalen == 1 )
361  term = mes->data[0];
362
363 mes->cmd     = ROAR_CMD_OK;
364 mes->datalen = 0;
365
366 ROAR_DBG("req_on_exit(*): term=%i", term);
367
368 if ( term ) {
369  cleanup_listen_socket(1);
370 } else {
371  alive = 0;
372 }
373
374 return 0;
375}
376
377int req_on_list_clients(int client, struct roar_message * mes, char * data) {
378 unsigned char filter, cmp;
379 uint32_t id;
380 int clients[ROAR_CLIENTS_MAX];
381 int i, c = 0;
382
383 if ( roar_ctl_m2f(mes, &filter, &cmp, &id) == -1 )
384  return -1;
385
386 // TODO: add code to support filter
387 if ( filter != ROAR_CTL_FILTER_ANY )
388  return -1;
389
390 for (i = 0; i < ROAR_CLIENTS_MAX; i++) {
391  if ( g_clients[i] != NULL ) {
392   clients[c++] = i;
393  }
394 }
395
396 roar_ctl_ia2m(mes, clients, c);
397
398 mes->cmd = ROAR_CMD_OK;
399
400 return 0;
401}
402int req_on_list_streams(int client, struct roar_message * mes, char * data) {
403 unsigned char filter, cmp;
404 uint32_t id;
405 int streams[ROAR_STREAMS_MAX];
406 int i, c = 0;
407
408 if ( roar_ctl_m2f(mes, &filter, &cmp, &id) == -1 )
409  return -1;
410
411 // TODO: add code to support filter
412 if ( filter != ROAR_CTL_FILTER_ANY )
413  return -1;
414
415 for (i = 0; i < ROAR_STREAMS_MAX; i++) {
416  if ( g_streams[i] != NULL ) {
417   streams[c++] = i;
418  }
419 }
420
421 roar_ctl_ia2m(mes, streams, c);
422
423 mes->cmd = ROAR_CMD_OK;
424
425 return 0;
426}
427
428int req_on_get_client  (int client, struct roar_message * mes, char * data) {
429 struct roar_client * c;
430
431 if ( mes->datalen != 1 )
432  return -1;
433
434 if ( clients_get(mes->data[0], &c) == -1 )
435  return -1;
436
437 mes->cmd = ROAR_CMD_OK;
438
439 return roar_ctl_c2m(mes, c);
440}
441
442int req_on_get_stream  (int client, struct roar_message * mes, char * data) {
443 struct roar_stream_server * s;
444
445 if ( mes->datalen != 1 )
446  return -1;
447
448 if ( streams_get(mes->data[0], &s) == -1 )
449  return -1;
450
451 mes->cmd = ROAR_CMD_OK;
452 mes->stream = mes->data[0];
453
454 return roar_stream_s2m(ROAR_STREAM(s), mes);
455}
456
457int req_on_get_stream_para (int client, struct roar_message * mes, char * data) {
458 struct roar_stream * s;
459 struct roar_stream_server * ss;
460 struct roar_audio_info * audio_info;
461 uint16_t * d = (uint16_t *) mes->data;
462 int i;
463
464 if ( mes->datalen != 4 )
465  return -1;
466
467 for (i = 0; i < mes->datalen/2; i++) {
468  d[i] = ROAR_NET2HOST16(d[i]);
469 }
470
471 if ( streams_get(mes->stream, &ss) == -1 ) {
472  ROAR_WARN("req_on_get_stream_para(*): request on non existing (or other error?) stream %i", mes->stream);
473  return -1;
474 }
475
476 s = ROAR_STREAM(ss);
477
478 audio_info = &(s->info);
479
480 if ( d[0] != 0 || d[1] != 1 ) {
481  ROAR_WARN("req_on_get_stream_para(*): unsupported command version: %i, %i", d[0], d[1]);
482  return -1;
483 }
484
485 mes->datalen = 2*7;
486
487 d[2] = ROAR_OUTPUT_CALC_OUTBUFSIZE(audio_info);
488 d[3] = ss->pre_underruns;
489 d[4] = ss->post_underruns;
490 d[5] = ss->codec_orgi;
491 d[6] = ss->flags | (ss->primary ? ROAR_FLAG_PRIMARY : 0) | (ss->driver_id != -1 ? ROAR_FLAG_OUTPUT : 0);
492
493 for (i = 0; i < mes->datalen/2; i++) {
494  d[i] = ROAR_HOST2NET16(d[i]);
495 }
496
497 mes->pos = s->pos;
498
499 mes->cmd = ROAR_CMD_OK;
500 return 0;
501}
502
503int req_on_set_stream_para (int client, struct roar_message * mes, char * data) {
504 uint16_t * d = (uint16_t *) mes->data;
505 int i;
506
507 if ( mes->datalen != 8 )
508  return -1;
509
510 for (i = 0; i < mes->datalen/2; i++) {
511  d[i] = ROAR_NET2HOST16(d[i]);
512 }
513
514 if ( d[0] != 0 || d[1] != 2 ) {
515  ROAR_WARN("req_on_set_stream_para(*): unsupported command version: %i, %i", d[0], d[1]);
516  return -1;
517 }
518
519 mes->cmd     = ROAR_CMD_OK;
520 mes->datalen = 0;
521
522 ROAR_DBG("req_on_set_stream_para(*): request seems to be valid");
523
524 if ( d[2] == ROAR_RESET_FLAG ) {
525  return streams_reset_flag(mes->stream, d[3]);
526 } else {
527  return streams_set_flag(mes->stream, d[3]);
528 }
529
530 return -1;
531}
532
533int req_on_kick (int client, struct roar_message * mes, char * data) {
534 uint16_t * info = (uint16_t *) mes->data;
535
536 if ( mes->datalen != 4 )
537  return -1;
538
539 info[0] = ROAR_NET2HOST16(info[0]);
540 info[1] = ROAR_NET2HOST16(info[1]);
541
542 if ( info[0] == ROAR_OT_CLIENT ) {
543  clients_delete(info[1]);
544 } else if ( info[0] == ROAR_OT_STREAM ) {
545  streams_delete(info[1]);
546 } else {
547  return -1;
548 }
549
550 mes->cmd     = ROAR_CMD_OK;
551 mes->datalen = 0;
552
553 return 0;
554}
555
556int req_on_attach      (int client, struct roar_message * mes, char * data) {
557 uint16_t * info = (uint16_t *) mes->data;
558
559 if ( mes->datalen < 6 )
560  return -1;
561
562 info[0] = ROAR_NET2HOST16(info[0]);
563 info[1] = ROAR_NET2HOST16(info[1]);
564 info[2] = ROAR_NET2HOST16(info[2]);
565
566 if ( info[0] != 0 )
567  return -1;
568
569 if ( info[1] == ROAR_ATTACH_SIMPLE ) {
570  if ( client_stream_move(info[2], mes->stream) == -1 )
571   return -1;
572 } else {
573  return -1;
574 }
575
576 mes->cmd     = ROAR_CMD_OK;
577 mes->datalen = 0;
578
579 return 0;
580}
581
582int req_on_set_vol (int client, struct roar_message * mes, char * data) {
583 uint16_t * info = (uint16_t *) mes->data;
584 int stream;
585 struct roar_stream_server * s;
586 int i;
587 int chans;
588
589 ROAR_DBG("req_on_set_vol(*) = ?");
590 ROAR_DBG("req_on_set_vol(*): mes->datalen=%i", mes->datalen);
591
592 if ( mes->datalen < (4*2) )
593  return -1;
594
595 if ( info[0] != 0 ) // version
596  return -1;
597
598 stream = ROAR_NET2HOST16(info[1]);
599 ROAR_DBG("req_on_set_vol(*): stream=%i", stream);
600
601 // TODO: change this code.
602 //       we should not directly change the stream object but use some stream_*()-func
603 //       for that job.
604
605 if ( stream < 0 || stream >= ROAR_STREAMS_MAX )
606  return -1;
607
608 s = g_streams[stream];
609
610 if ( s == NULL )
611  return -1;
612
613 ROAR_DBG("req_on_set_vol(*): s=%p", s);
614
615 info[2] = ROAR_NET2HOST16(info[2]);
616
617 if ( info[2] == ROAR_SET_VOL_ALL ) {
618  chans = (mes->datalen/2) - 3;
619  ROAR_DBG("req_on_set_vol(*): mode is ROAR_SET_VOL_ALL, channes=%i", chans);
620
621  if ( chans >= ROAR_MAX_CHANNELS )
622   return -1;
623
624  ROAR_DBG("req_on_set_vol(*): mixer at %p", s->mixer.mixer);
625
626  for (i = 0; i < chans; i++) {
627   s->mixer.mixer[i] = ROAR_NET2HOST16(info[i+3]);
628   ROAR_DBG("req_on_set_vol(*): channel %i: %i", i, ROAR_NET2HOST16(info[i+3]));
629  }
630
631  ROAR_DBG("req_on_set_vol(*): mixer changed!");
632
633 } else if ( info[2] == ROAR_SET_VOL_ONE ) {
634  ROAR_DBG("req_on_set_vol(*): mode is ROAR_SET_VOL_ONE");
635  if ( ROAR_NET2HOST16(info[3]) >= ROAR_MAX_CHANNELS )
636   return -1;
637
638  s->mixer.mixer[ROAR_NET2HOST16(info[3])] = ROAR_NET2HOST16(info[4]);
639 } else {
640  return -1;
641 }
642
643 mes->cmd     = ROAR_CMD_OK;
644 mes->datalen = 0;
645
646 return 0;
647}
648
649int req_on_get_vol (int client, struct roar_message * mes, char * data) {
650 uint16_t * info = (uint16_t *) mes->data;
651 int stream;
652 struct roar_stream_server * s;
653 int i;
654 int chans;
655
656 ROAR_DBG("req_on_get_vol(*) = ?");
657 ROAR_DBG("req_on_get_vol(*): mes->datalen=%i", mes->datalen);
658
659 if ( mes->datalen < (2*2) )
660  return -1;
661
662 if ( info[0] != 0 ) // version
663  return -1;
664
665 stream = ROAR_NET2HOST16(info[1]);
666 ROAR_DBG("req_on_get_vol(*): stream=%i", stream);
667
668 // TODO: change this code.
669 //       we should not directly change the stream object but use some stream_*()-func
670 //       for that job.
671
672 if ( stream < 0 || stream >= ROAR_STREAMS_MAX )
673  return -1;
674
675 s = g_streams[stream];
676
677 if ( s == NULL )
678  return -1;
679
680 ROAR_DBG("req_on_get_vol(*): s=%p", s);
681
682 // ok, we have everything
683
684 info[0] = 0;
685 info[1] = ROAR_HOST2NET16(chans = ROAR_STREAM(s)->info.channels);
686
687 for (i = 0; i < chans; i++)
688  info[2+i] = ROAR_HOST2NET16(s->mixer.mixer[i]);
689
690 mes->datalen = (2 + chans)*2;
691 mes->cmd = ROAR_CMD_OK;
692
693 return 0;
694}
695
696int req_on_add_data (int client, struct roar_message * mes, char * data) {
697 struct roar_buffer * b;
698 char               * buf;
699
700 if ( roar_buffer_new(&b, mes->datalen) == -1 ) {
701  ROAR_ERR("req_on_add_data(*): Can not alloc buffer space!");
702  ROAR_DBG("req_on_add_data(*) = -1");
703  return -1;
704 }
705
706 roar_buffer_get_data(b, (void **)&buf);
707
708 if ( data == NULL ) {
709  memcpy(buf, mes->data, mes->datalen);
710 } else {
711  memcpy(buf, data, mes->datalen);
712 }
713
714 if ( stream_add_buffer(mes->stream, b) == -1 ) {
715  roar_buffer_free(b);
716  return -1;
717 }
718
719 mes->cmd     = ROAR_CMD_OK_STOP;
720 mes->datalen = 0;
721
722 return 0;
723}
724
725//ll
Note: See TracBrowser for help on using the repository browser.