/[svn]/liblscp/trunk/examples/example_server.c
ViewVC logotype

Annotation of /liblscp/trunk/examples/example_server.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 187 - (hide annotations) (download)
Wed Jul 7 23:41:07 2004 UTC (19 years, 8 months ago) by capela
File MIME type: text/plain
File size: 20215 byte(s)
* lscp_isplit_create() gets wrong zero item if string list is empty: fixed.
* lscp_param_concat() was quitting prematurely when deplist is null: fixed.
* Lil'bit more informative example_client test run; new teststep command.

1 capela 105 // example_server.c
2     //
3     /****************************************************************************
4     Copyright (C) 2004, rncbc aka Rui Nuno Capela. All rights reserved.
5    
6     This program is free software; you can redistribute it and/or
7     modify it under the terms of the GNU General Public License
8     as published by the Free Software Foundation; either version 2
9     of the License, or (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
18     Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
19    
20     *****************************************************************************/
21    
22     #include "server.h"
23     #include "parser.h"
24    
25     #include <time.h>
26    
27     #define SERVER_PORT 8888
28    
29     #if defined(WIN32)
30     static WSADATA _wsaData;
31     #endif
32    
33     ////////////////////////////////////////////////////////////////////////
34    
35     lscp_status_t server_callback ( lscp_connect_t *pConnect, const char *pchBuffer, int cchBuffer, void *pvData )
36     {
37     lscp_status_t ret = LSCP_OK;
38     lscp_parser_t tok;
39     const char *pszResult = NULL;
40     char szTemp[256];
41 capela 125 int i;
42 capela 171 static int iSamplerChannel = 0;
43     static int iAudioDevice = 0;
44     static int iMidiDevice = 0;
45 capela 105
46     if (pchBuffer == NULL) {
47     fprintf(stderr, "server_callback: addr=%s port=%d: ",
48     inet_ntoa(pConnect->client.addr.sin_addr),
49     htons(pConnect->client.addr.sin_port));
50     switch (cchBuffer) {
51     case LSCP_CONNECT_OPEN:
52     fprintf(stderr, "New client connection.\n");
53     break;
54     case LSCP_CONNECT_CLOSE:
55     fprintf(stderr, "Connection closed.\n");
56     break;
57     }
58     return ret;
59     }
60    
61     lscp_socket_trace("server_callback", &(pConnect->client.addr), pchBuffer, cchBuffer);
62    
63     lscp_parser_init(&tok, pchBuffer, cchBuffer);
64    
65     if (lscp_parser_test(&tok, "GET")) {
66     if (lscp_parser_test(&tok, "CHANNEL")) {
67     if (lscp_parser_test(&tok, "INFO")) {
68     // Getting sampler channel informations:
69     // GET CHANNEL INFO <sampler-channel>
70     pszResult = "ENGINE_NAME: DummyEngine\r\n"
71     "INSTRUMENT_FILE: DummyInstrument.gig\r\n"
72     "INSTRUMENT_NR: 0\r\n"
73 capela 144 "INSTRUMENT_STATUS: 100\r\n"
74 capela 105 "AUDIO_OUTPUT_DEVICE: 0\r\n"
75     "AUDIO_OUTPUT_CHANNELS: 2\r\n"
76     "AUDIO_OUTPUT_ROUTING: 0,1\r\n"
77     "MIDI_INPUT_DEVICE: 0\r\n"
78     "MIDI_INPUT_PORT: 0\r\n"
79     "MIDI_INPUT_CHANNEL: ALL\r\n"
80     "VOLUME: 0.5\r\n";
81     }
82     else if (lscp_parser_test(&tok, "VOICE_COUNT")) {
83     // Current number of active voices:
84     // GET CHANNEL VOICE_COUNT <sampler-channel>
85     sprintf(szTemp, "%d", rand() % 100);
86     pszResult = szTemp;
87     }
88     else if (lscp_parser_test(&tok, "STREAM_COUNT")) {
89     // Current number of active disk streams:
90     // GET CHANNEL STREAM_COUNT <sampler-channel>
91     pszResult = "3\r\n";
92     }
93     else if (lscp_parser_test(&tok, "BUFFER_FILL")) {
94     if (lscp_parser_test(&tok, "BYTES")) {
95     // Current fill state of disk stream buffers:
96     // GET CHANNEL BUFFER_FILL BYTES <sampler-channel>
97     sprintf(szTemp, "[1]%d,[2]%d,[3]%d\r\n", rand(), rand(), rand());
98     pszResult = szTemp;
99     }
100     else if (lscp_parser_test(&tok, "PERCENTAGE")) {
101     // Current fill state of disk stream buffers:
102     // GET CHANNEL BUFFER_FILL PERCENTAGE <sampler-channel>
103     sprintf(szTemp, "[1]%d%%,[2]%d%%,[3]%d%%\r\n", rand() % 100, rand() % 100, rand() % 100);
104     pszResult = szTemp;
105     }
106     else ret = LSCP_FAILED;
107     }
108     else ret = LSCP_FAILED;
109     }
110     else if (lscp_parser_test(&tok, "CHANNELS")) {
111     // Current number of sampler channels:
112     // GET CHANNELS
113 capela 171 sprintf(szTemp, "%d", iSamplerChannel);
114 capela 105 pszResult = szTemp;
115     }
116     else if (lscp_parser_test(&tok, "AVAILABLE_AUDIO_OUTPUT_DRIVERS")) {
117     // Getting all available audio output drivers.
118     // GET AVAILABLE_AUDIO_OUTPUT_DRIVERS
119 capela 144 pszResult = "Alsa,Jack,CoreAudio\r\n";
120 capela 105 }
121     else if (lscp_parser_test(&tok, "AVAILABLE_MIDI_INPUT_DRIVERS")) {
122     // Getting all available MIDI input drivers.
123     // GET AVAILABLE_MIDI_INPUT_DRIVERS
124 capela 144 pszResult = "Alsa,MidiShare,CoreMidi\r\n";
125 capela 105 }
126     else if (lscp_parser_test2(&tok, "AUDIO_OUTPUT_DRIVER", "INFO")) {
127     // Getting informations about a specific audio output driver.
128     // GET AUDIO_OUTPUT_DRIVER INFO <audio-output-type>
129 capela 163 if (lscp_parser_test(&tok, "Alsa")) {
130 capela 105 pszResult = "DESCRIPTION: 'ALSA PCM'\r\n"
131     "VERSION: '1.0'\r\n"
132 capela 163 "PARAMETERS: channels,samplerate,active,card\r\n";
133 capela 105 }
134 capela 163 else if (lscp_parser_test(&tok, "Jack")) {
135     pszResult = "DESCRIPTION: JACK Audio Connection Kit\r\n"
136 capela 105 "VERSION: 0.98.1\r\n"
137 capela 163 "PARAMETERS: channels,samplerate,active\r\n";
138 capela 105 }
139     else ret = LSCP_FAILED;
140     }
141     else if (lscp_parser_test2(&tok, "MIDI_INPUT_DRIVER", "INFO")) {
142     // Getting informations about a specific MIDI input driver.
143     // GET MIDI_INPUT_DRIVER INFO <midi-input-type>
144 capela 163 if (lscp_parser_test(&tok, "Alsa")) {
145 capela 105 pszResult = "DESCRIPTION: ALSA Sequencer\r\n"
146     "VERSION: 1.0\r\n"
147 capela 163 "PARAMETERS: ports,active\r\n";
148 capela 105 }
149     else ret = LSCP_FAILED;
150     }
151 capela 163 else if (lscp_parser_test2(&tok, "AUDIO_OUTPUT_DRIVER_PARAMETER", "INFO")) {
152     // Getting informations about a specific audio output driver parameter.
153     // GET AUDIO_OUTPUT_DRIVER_PARAMETER INFO <audio-output-type> <param>
154     if (lscp_parser_test2(&tok, "Alsa", "active")) {
155     pszResult = "DESCRIPTION: 'ALSA PCM device active state'\r\n"
156     "TYPE: BOOL\r\n"
157     "MANDATORY: TRUE\r\n"
158     "FIX: TRUE\r\n"
159     "MULTIPLICITY: FALSE\r\n"
160     "DEPENDS: channels,samplerate,card\r\n"
161     "DEFAULT: TRUE\r\n"
162     "RANGE_MIN: FALSE\r\n"
163 capela 180 "RANGE_MAX: TRUE\r\n"
164 capela 163 "POSSIBILITIES: FALSE,TRUE\r\n";
165     }
166     else if (lscp_parser_test2(&tok, "Jack", "active")) {
167     pszResult = "DESCRIPTION: 'JACK device active state'\r\n"
168     "TYPE: BOOL\r\n"
169     "MANDATORY: TRUE\r\n"
170     "FIX: TRUE\r\n"
171     "MULTIPLICITY: FALSE\r\n"
172     "DEPENDS: channels,samplerate\r\n"
173     "DEFAULT: TRUE\r\n"
174     "RANGE_MIN: FALSE\r\n"
175 capela 180 "RANGE_MAX: TRUE\r\n"
176 capela 163 "POSSIBILITIES: FALSE,TRUE\r\n";
177     }
178     else ret = LSCP_FAILED;
179     }
180     else if (lscp_parser_test2(&tok, "MIDI_INPUT_DRIVER_PARAMETER", "INFO")) {
181     // Getting informations about a specific MIDI input driver parameter.
182     // GET MIDI_INPUT_DRIVER_PARAMETER INFO <midi-input-type> <param>
183     if (lscp_parser_test2(&tok, "Alsa", "active")) {
184     pszResult = "DESCRIPTION: 'ALSA Sequencer device active state'\r\n"
185     "TYPE: BOOL\r\n"
186     "MANDATORY: TRUE\r\n"
187     "FIX: TRUE\r\n"
188     "MULTIPLICITY: FALSE\r\n"
189     "DEPENDS: channels,ports\r\n"
190     "DEFAULT: TRUE\r\n"
191     "RANGE_MIN: FALSE\r\n"
192 capela 180 "RANGE_MAX: TRUE\r\n"
193 capela 163 "POSSIBILITIES: FALSE,TRUE\r\n";
194     }
195     else ret = LSCP_FAILED;
196     }
197 capela 171 else if (lscp_parser_test2(&tok, "AUDIO_OUTPUT_DEVICE", "INFO")) {
198     // Getting informations about a specific audio output device.
199     // GET AUDIO_OUTPUT_DEVICE INFO <audio-device-id>
200     if (lscp_parser_nextint(&tok) < iAudioDevice) {
201     pszResult = "driver: Alsa\r\n"
202     "active: TRUE\r\n"
203     "channels: 2\r\n"
204     "samplerate: 44100\r\n";
205     }
206     else ret = LSCP_FAILED;
207     }
208     else if (lscp_parser_test2(&tok, "MIDI_INPUT_DEVICE", "INFO")) {
209     // Getting informations about a specific MIDI input device.
210     // GET MIDI_INPUT_DEVICE INFO <midi-device-id>
211     if (lscp_parser_nextint(&tok) < iMidiDevice) {
212     pszResult = "driver: Alsa\r\n"
213     "active: TRUE\r\n"
214     "channels: 16\r\n"
215     "ports: 1\r\n";
216     }
217     else ret = LSCP_FAILED;
218     }
219 capela 105 else if (lscp_parser_test(&tok, "AVAILABLE_ENGINES")) {
220     // Getting all available engines:
221     // GET AVAILABLE_ENGINES
222 capela 163 pszResult = "GigEngine,DLSEngine,AkaiEngine\r\n";
223 capela 105 }
224     else if (lscp_parser_test2(&tok, "ENGINE", "INFO")) {
225     // Getting information about an engine.
226     // GET ENGINE INFO <engine-name>
227 capela 163 if (lscp_parser_test(&tok, "GigEngine")) {
228     pszResult = "DESCRIPTION: GigaSampler Engine\r\n"
229     "VERSION: 0.3\r\n";
230     }
231     else if (lscp_parser_test(&tok, "DLSEngine")) {
232     pszResult = "DESCRIPTION: 'DLS Generic Engine'\r\n"
233     "VERSION: 0.2\r\n";
234     }
235     else if (lscp_parser_test(&tok, "AkaiEngine")) {
236     pszResult = "DESCRIPTION: Akai Sampler Engine\r\n"
237     "VERSION: 0.1\r\n";
238     }
239     else ret = LSCP_FAILED;
240 capela 105 }
241     else ret = LSCP_FAILED;
242     }
243 capela 125 else if (lscp_parser_test(&tok, "LIST")) {
244     if (lscp_parser_test(&tok, "CHANNELS")) {
245     // Getting all created sampler channel list.
246     // GET CHANNELS
247 capela 171 if (iSamplerChannel > 0) {
248 capela 125 strcpy(szTemp, "0");
249 capela 177 for (i = 1; i < iSamplerChannel && strlen(szTemp) < sizeof(szTemp) - 8; i++)
250 capela 125 sprintf(szTemp + strlen(szTemp), ",%d", i);
251     strcat(szTemp, "\r\n");
252     pszResult = szTemp;
253     }
254     else ret = LSCP_FAILED;
255     }
256     else if (lscp_parser_test(&tok, "AUDIO_OUTPUT_DEVICES")) {
257     // Getting all created audio output device list.
258     // GET AUDIO_OUTPUT_DEVICES
259 capela 171 if (iAudioDevice > 0) {
260     strcpy(szTemp, "0");
261 capela 177 for (i = 1; i < iAudioDevice && strlen(szTemp) < sizeof(szTemp) - 8; i++)
262 capela 171 sprintf(szTemp + strlen(szTemp), ",%d", i);
263     strcat(szTemp, "\r\n");
264     pszResult = szTemp;
265     }
266     else ret = LSCP_FAILED;
267 capela 125 }
268     else if (lscp_parser_test(&tok, "MIDI_INPUT_DEVICES")) {
269     // Getting all created MID input device list.
270     // GET MIDI_INPUT_DEVICES
271 capela 171 if (iMidiDevice > 0) {
272     strcpy(szTemp, "0");
273 capela 177 for (i = 1; i < iMidiDevice && strlen(szTemp) < sizeof(szTemp) - 8; i++)
274 capela 171 sprintf(szTemp + strlen(szTemp), ",%d", i);
275     strcat(szTemp, "\r\n");
276     pszResult = szTemp;
277     }
278     else ret = LSCP_FAILED;
279 capela 125 }
280     else ret = LSCP_FAILED;
281     }
282 capela 105 else if (lscp_parser_test(&tok, "SET")) {
283     if (lscp_parser_test(&tok, "CHANNEL")) {
284     if (lscp_parser_test(&tok, "VOLUME")) {
285     // Setting channel volume:
286     // SET CHANNEL VOLUME <sampler-channel> <volume>
287     }
288     else if (lscp_parser_test(&tok, "AUDIO_OUTPUT_TYPE")) {
289     // Setting audio output type:
290     // SET CHANNEL AUDIO_OUTPUT_TYPE <sampler-channel> <audio-output-type>
291     }
292 capela 125 else if (lscp_parser_test(&tok, "AUDIO_OUTPUT_DEVICE")) {
293     // Setting audio output device:
294     // SET CHANNEL AUDIO_OUTPUT_DEVICE <sampler-channel> <device-id>
295     }
296 capela 105 else if (lscp_parser_test(&tok, "AUDIO_OUTPUT_CHANNEL")) {
297     // Setting audio output channel:
298 capela 125 // SET CHANNEL AUDIO_OUTPUT_CHANNEL <sampler-channel> <audio-in> <audio-out>
299 capela 105 }
300     else if (lscp_parser_test(&tok, "MIDI_INPUT_TYPE")) {
301     // Setting MIDI input type:
302     // SET CHANNEL MIDI_INPUT_TYPE <sampler-channel> <midi-input-type>
303     }
304 capela 125 else if (lscp_parser_test(&tok, "MIDI_INPUT_DEVICE")) {
305     // Setting MIDI input device:
306     // SET CHANNEL MIDI_INPUT_DEVICE <sampler-channel> <device-id>
307     }
308 capela 105 else if (lscp_parser_test(&tok, "MIDI_INPUT_PORT")) {
309     // Setting MIDI input port:
310     // SET CHANNEL MIDI_INPUT_PORT <sampler-channel> <midi-input-port>
311     }
312     else if (lscp_parser_test(&tok, "MIDI_INPUT_CHANNEL")) {
313     // Setting MIDI input channel:
314     // SET CHANNEL MIDI_INPUT_CHANNEL <sampler-channel> <midi-input-chan>
315     }
316     else ret = LSCP_FAILED;
317     }
318     else ret = LSCP_FAILED;
319     }
320     else if (lscp_parser_test(&tok, "LOAD")) {
321     if (lscp_parser_test(&tok, "ENGINE")) {
322     // Loading a sampler engine:
323     // LOAD ENGINE <engine-name> <sampler-channel>
324     }
325     else if (lscp_parser_test(&tok, "INSTRUMENT")) {
326     // Loading an instrument:
327 capela 144 // LOAD INSTRUMENT [NON_MODAL] <filename> <instr-index> <sampler-channel>
328 capela 105 }
329     else ret = LSCP_FAILED;
330     }
331     else if (lscp_parser_test2(&tok, "ADD", "CHANNEL")) {
332     // Adding a new sampler channel:
333     // ADD CHANNEL
334 capela 187 if (iSamplerChannel < 16) {
335     sprintf(szTemp, "OK[%d]", iSamplerChannel++);
336     pszResult = szTemp;
337     } else {
338     iSamplerChannel = 0;
339     ret = LSCP_FAILED;
340     }
341 capela 105 }
342     else if (lscp_parser_test2(&tok, "REMOVE", "CHANNEL")) {
343     // Removing a sampler channel:
344     // REMOVE CHANNEL <sampler-channel>
345 capela 171 if (lscp_parser_nextint(&tok) > iSamplerChannel)
346     ret = LSCP_FAILED;
347 capela 105 }
348     else if (lscp_parser_test2(&tok, "RESET", "CHANNEL")) {
349     // Resetting a sampler channel:
350     // RESET CHANNEL <sampler-channel>
351 capela 171 if (lscp_parser_nextint(&tok) > iSamplerChannel)
352     ret = LSCP_FAILED;
353 capela 105 }
354 capela 171 else if (lscp_parser_test(&tok, "CREATE")) {
355     if (lscp_parser_test(&tok, "AUDIO_OUTPUT_DEVICE")) {
356     // Creating an audio output device.
357     // CREATE AUDIO_OUTPUT_DEVICE <audio-output-driver> [<params>]
358 capela 187 if (iAudioDevice < 8) {
359     sprintf(szTemp, "OK[%d]", iAudioDevice++);
360     pszResult = szTemp;
361     } else {
362     iAudioDevice = 0;
363     ret = LSCP_FAILED;
364     }
365 capela 171 }
366     else if (lscp_parser_test(&tok, "MIDI_INPUT_DEVICE")) {
367     // Creating an MIDI input device.
368     // CREATE MIDI_INPUT_DEVICE <midi-input-driver> [<params>]
369 capela 187 if (iMidiDevice < 8) {
370     sprintf(szTemp, "OK[%d]", iMidiDevice++);
371     pszResult = szTemp;
372     } else {
373     iMidiDevice = 0;
374     ret = LSCP_FAILED;
375     }
376 capela 171 }
377     else ret = LSCP_FAILED;
378     }
379     else if (lscp_parser_test(&tok, "DESTROY")) {
380     if (lscp_parser_test(&tok, "AUDIO_OUTPUT_DEVICE")) {
381     // Destroying an audio output device.
382     // DESTROY AUDIO_OUTPUT_DEVICE <audio-device-id>
383     if (lscp_parser_nextint(&tok) > iAudioDevice)
384     ret = LSCP_FAILED;
385     }
386     else if (lscp_parser_test(&tok, "MIDI_INPUT_DEVICE")) {
387     // Destroying an MIDI intput device.
388     // DESTROY MIDI_INPUT_DEVICE <midi-device-id>
389     if (lscp_parser_nextint(&tok) > iMidiDevice)
390     ret = LSCP_FAILED;
391     }
392     else ret = LSCP_FAILED;
393     }
394 capela 146 else if (lscp_parser_test(&tok, "SUBSCRIBE")) {
395     // Register frontend for receiving event notification messages:
396     // SUBSCRIBE <event>
397     ret = lscp_server_subscribe(pConnect, lscp_event_from_text(lscp_parser_next(&tok)));
398 capela 105 }
399 capela 146 else if (lscp_parser_test(&tok, "UNSUBSCRIBE")) {
400     // Deregister frontend for not receiving event notification messages anymore:
401     // UNSUBSCRIBE <event>
402     ret = lscp_server_unsubscribe(pConnect, lscp_event_from_text(lscp_parser_next(&tok)));
403 capela 105 }
404     else if (lscp_parser_test(&tok, "QUIT")) {
405     // Close client connection:
406     // QUIT
407     lscp_parser_free(&tok);
408     return LSCP_FAILED; // Disconnect.
409     }
410     else ret = LSCP_FAILED;
411    
412     lscp_parser_free(&tok);
413    
414     if (pszResult == NULL)
415     pszResult = (ret == LSCP_OK ? "OK\r\n" : "ERR:1:Failed\r\n");
416    
417     fprintf(stderr, "> %s", pszResult);
418    
419     return lscp_server_result(pConnect, pszResult, strlen(pszResult));
420     }
421    
422     ////////////////////////////////////////////////////////////////////////
423    
424     void server_usage (void)
425     {
426     printf("\n %s %s (Build: %s)\n", lscp_server_package(), lscp_server_version(), lscp_server_build());
427    
428     fputs("\n Available server commands: help, exit, quit, list", stdout);
429     fputs("\n (all else are broadcast verbatim to subscribers)\n\n", stdout);
430     }
431    
432     void server_prompt (void)
433     {
434     fputs("lscp_server> ", stdout);
435     }
436    
437     int main (int argc, char *argv[] )
438     {
439     lscp_server_t *pServer;
440     char szLine[200];
441     int cchLine;
442     lscp_connect_t *p;
443    
444     #if defined(WIN32)
445     if (WSAStartup(MAKEWORD(1, 1), &_wsaData) != 0) {
446     fprintf(stderr, "lscp_server: WSAStartup failed.\n");
447     return -1;
448     }
449     #endif
450    
451     srand(time(NULL));
452    
453     pServer = lscp_server_create(SERVER_PORT, server_callback, NULL);
454     if (pServer == NULL)
455     return -1;
456    
457     server_usage();
458     server_prompt();
459    
460     while (fgets(szLine, sizeof(szLine), stdin)) {
461    
462     cchLine = strlen(szLine);
463     while (cchLine > 0 && (szLine[cchLine - 1] == '\n' || szLine[cchLine - 1] == '\r'))
464     cchLine--;
465     szLine[cchLine] = '\0';
466    
467     if (strcmp(szLine, "exit") == 0 || strcmp(szLine, "quit") == 0)
468     break;
469     else
470     if (strcmp(szLine, "list") == 0) {
471     for (p = pServer->connects.first; p; p = p->next) {
472 capela 146 printf("client: sock=%d addr=%s port=%d events=0x%04x.\n",
473 capela 105 p->client.sock,
474     inet_ntoa(p->client.addr.sin_addr),
475     ntohs(p->client.addr.sin_port),
476 capela 146 (int) p->events
477 capela 105 );
478     }
479     }
480     else
481     if (cchLine > 0 && strcmp(szLine, "help") != 0)
482 capela 146 lscp_server_broadcast(pServer, LSCP_EVENT_MISCELLANEOUS, szLine, strlen(szLine));
483 capela 105 else
484     server_usage();
485    
486     server_prompt();
487     }
488    
489     lscp_server_destroy(pServer);
490    
491     #if defined(WIN32)
492     WSACleanup();
493     #endif
494    
495     return 0;
496     }
497    
498     // end of example_server.c

  ViewVC Help
Powered by ViewVC