/[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 188 - (hide annotations) (download)
Thu Jul 8 09:13:36 2004 UTC (19 years, 8 months ago) by capela
File MIME type: text/plain
File size: 20879 byte(s)
- lscp_set_channel_audio_channel() is using a wrong command syntax: fixed.
- device configuration functions missing on documention main page: added.

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 188 else if (lscp_parser_test(&tok, "AUDIO_OUTPUT_DEVICES")) {
220     // Getting all created audio output device count.
221     // GET AUDIO_OUTPUT_DEVICES
222     sprintf(szTemp, "%d\r\n", iAudioDevice);
223     pszResult = szTemp;
224     }
225     else if (lscp_parser_test(&tok, "MIDI_INPUT_DEVICES")) {
226     // Getting all created MID input device count.
227     // GET MIDI_INPUT_DEVICES
228     sprintf(szTemp, "%d\r\n", iMidiDevice);
229     pszResult = szTemp;
230     }
231 capela 105 else if (lscp_parser_test(&tok, "AVAILABLE_ENGINES")) {
232     // Getting all available engines:
233     // GET AVAILABLE_ENGINES
234 capela 163 pszResult = "GigEngine,DLSEngine,AkaiEngine\r\n";
235 capela 105 }
236     else if (lscp_parser_test2(&tok, "ENGINE", "INFO")) {
237     // Getting information about an engine.
238     // GET ENGINE INFO <engine-name>
239 capela 163 if (lscp_parser_test(&tok, "GigEngine")) {
240     pszResult = "DESCRIPTION: GigaSampler Engine\r\n"
241     "VERSION: 0.3\r\n";
242     }
243     else if (lscp_parser_test(&tok, "DLSEngine")) {
244     pszResult = "DESCRIPTION: 'DLS Generic Engine'\r\n"
245     "VERSION: 0.2\r\n";
246     }
247     else if (lscp_parser_test(&tok, "AkaiEngine")) {
248     pszResult = "DESCRIPTION: Akai Sampler Engine\r\n"
249     "VERSION: 0.1\r\n";
250     }
251     else ret = LSCP_FAILED;
252 capela 105 }
253     else ret = LSCP_FAILED;
254     }
255 capela 125 else if (lscp_parser_test(&tok, "LIST")) {
256     if (lscp_parser_test(&tok, "CHANNELS")) {
257     // Getting all created sampler channel list.
258 capela 188 // LIST CHANNELS
259 capela 171 if (iSamplerChannel > 0) {
260 capela 125 strcpy(szTemp, "0");
261 capela 177 for (i = 1; i < iSamplerChannel && strlen(szTemp) < sizeof(szTemp) - 8; i++)
262 capela 125 sprintf(szTemp + strlen(szTemp), ",%d", i);
263     strcat(szTemp, "\r\n");
264     pszResult = szTemp;
265     }
266     else ret = LSCP_FAILED;
267     }
268     else if (lscp_parser_test(&tok, "AUDIO_OUTPUT_DEVICES")) {
269     // Getting all created audio output device list.
270 capela 188 // LIST AUDIO_OUTPUT_DEVICES
271 capela 171 if (iAudioDevice > 0) {
272     strcpy(szTemp, "0");
273 capela 177 for (i = 1; i < iAudioDevice && 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 if (lscp_parser_test(&tok, "MIDI_INPUT_DEVICES")) {
281     // Getting all created MID input device list.
282 capela 188 // LIST MIDI_INPUT_DEVICES
283 capela 171 if (iMidiDevice > 0) {
284     strcpy(szTemp, "0");
285 capela 177 for (i = 1; i < iMidiDevice && strlen(szTemp) < sizeof(szTemp) - 8; i++)
286 capela 171 sprintf(szTemp + strlen(szTemp), ",%d", i);
287     strcat(szTemp, "\r\n");
288     pszResult = szTemp;
289     }
290     else ret = LSCP_FAILED;
291 capela 125 }
292     else ret = LSCP_FAILED;
293     }
294 capela 105 else if (lscp_parser_test(&tok, "SET")) {
295     if (lscp_parser_test(&tok, "CHANNEL")) {
296     if (lscp_parser_test(&tok, "VOLUME")) {
297     // Setting channel volume:
298     // SET CHANNEL VOLUME <sampler-channel> <volume>
299     }
300     else if (lscp_parser_test(&tok, "AUDIO_OUTPUT_TYPE")) {
301     // Setting audio output type:
302     // SET CHANNEL AUDIO_OUTPUT_TYPE <sampler-channel> <audio-output-type>
303     }
304 capela 125 else if (lscp_parser_test(&tok, "AUDIO_OUTPUT_DEVICE")) {
305     // Setting audio output device:
306     // SET CHANNEL AUDIO_OUTPUT_DEVICE <sampler-channel> <device-id>
307     }
308 capela 105 else if (lscp_parser_test(&tok, "AUDIO_OUTPUT_CHANNEL")) {
309     // Setting audio output channel:
310 capela 125 // SET CHANNEL AUDIO_OUTPUT_CHANNEL <sampler-channel> <audio-in> <audio-out>
311 capela 105 }
312     else if (lscp_parser_test(&tok, "MIDI_INPUT_TYPE")) {
313     // Setting MIDI input type:
314     // SET CHANNEL MIDI_INPUT_TYPE <sampler-channel> <midi-input-type>
315     }
316 capela 125 else if (lscp_parser_test(&tok, "MIDI_INPUT_DEVICE")) {
317     // Setting MIDI input device:
318     // SET CHANNEL MIDI_INPUT_DEVICE <sampler-channel> <device-id>
319     }
320 capela 105 else if (lscp_parser_test(&tok, "MIDI_INPUT_PORT")) {
321     // Setting MIDI input port:
322     // SET CHANNEL MIDI_INPUT_PORT <sampler-channel> <midi-input-port>
323     }
324     else if (lscp_parser_test(&tok, "MIDI_INPUT_CHANNEL")) {
325     // Setting MIDI input channel:
326     // SET CHANNEL MIDI_INPUT_CHANNEL <sampler-channel> <midi-input-chan>
327     }
328     else ret = LSCP_FAILED;
329     }
330     else ret = LSCP_FAILED;
331     }
332     else if (lscp_parser_test(&tok, "LOAD")) {
333     if (lscp_parser_test(&tok, "ENGINE")) {
334     // Loading a sampler engine:
335     // LOAD ENGINE <engine-name> <sampler-channel>
336     }
337     else if (lscp_parser_test(&tok, "INSTRUMENT")) {
338     // Loading an instrument:
339 capela 144 // LOAD INSTRUMENT [NON_MODAL] <filename> <instr-index> <sampler-channel>
340 capela 105 }
341     else ret = LSCP_FAILED;
342     }
343     else if (lscp_parser_test2(&tok, "ADD", "CHANNEL")) {
344     // Adding a new sampler channel:
345     // ADD CHANNEL
346 capela 187 if (iSamplerChannel < 16) {
347     sprintf(szTemp, "OK[%d]", iSamplerChannel++);
348     pszResult = szTemp;
349     } else {
350     iSamplerChannel = 0;
351     ret = LSCP_FAILED;
352     }
353 capela 105 }
354     else if (lscp_parser_test2(&tok, "REMOVE", "CHANNEL")) {
355     // Removing a sampler channel:
356     // REMOVE CHANNEL <sampler-channel>
357 capela 188 if (lscp_parser_nextint(&tok) < iSamplerChannel)
358     iSamplerChannel--;
359     else
360 capela 171 ret = LSCP_FAILED;
361 capela 105 }
362     else if (lscp_parser_test2(&tok, "RESET", "CHANNEL")) {
363     // Resetting a sampler channel:
364     // RESET CHANNEL <sampler-channel>
365 capela 171 if (lscp_parser_nextint(&tok) > iSamplerChannel)
366     ret = LSCP_FAILED;
367 capela 105 }
368 capela 171 else if (lscp_parser_test(&tok, "CREATE")) {
369     if (lscp_parser_test(&tok, "AUDIO_OUTPUT_DEVICE")) {
370     // Creating an audio output device.
371     // CREATE AUDIO_OUTPUT_DEVICE <audio-output-driver> [<params>]
372 capela 187 if (iAudioDevice < 8) {
373     sprintf(szTemp, "OK[%d]", iAudioDevice++);
374     pszResult = szTemp;
375     } else {
376     iAudioDevice = 0;
377     ret = LSCP_FAILED;
378     }
379 capela 171 }
380     else if (lscp_parser_test(&tok, "MIDI_INPUT_DEVICE")) {
381     // Creating an MIDI input device.
382     // CREATE MIDI_INPUT_DEVICE <midi-input-driver> [<params>]
383 capela 187 if (iMidiDevice < 8) {
384     sprintf(szTemp, "OK[%d]", iMidiDevice++);
385     pszResult = szTemp;
386     } else {
387     iMidiDevice = 0;
388     ret = LSCP_FAILED;
389     }
390 capela 171 }
391     else ret = LSCP_FAILED;
392     }
393     else if (lscp_parser_test(&tok, "DESTROY")) {
394     if (lscp_parser_test(&tok, "AUDIO_OUTPUT_DEVICE")) {
395     // Destroying an audio output device.
396     // DESTROY AUDIO_OUTPUT_DEVICE <audio-device-id>
397 capela 188 if (lscp_parser_nextint(&tok) < iAudioDevice)
398     iAudioDevice--;
399     else
400 capela 171 ret = LSCP_FAILED;
401     }
402     else if (lscp_parser_test(&tok, "MIDI_INPUT_DEVICE")) {
403     // Destroying an MIDI intput device.
404     // DESTROY MIDI_INPUT_DEVICE <midi-device-id>
405 capela 188 if (lscp_parser_nextint(&tok) < iMidiDevice)
406     iMidiDevice--;
407     else
408 capela 171 ret = LSCP_FAILED;
409     }
410     else ret = LSCP_FAILED;
411     }
412 capela 146 else if (lscp_parser_test(&tok, "SUBSCRIBE")) {
413     // Register frontend for receiving event notification messages:
414     // SUBSCRIBE <event>
415     ret = lscp_server_subscribe(pConnect, lscp_event_from_text(lscp_parser_next(&tok)));
416 capela 105 }
417 capela 146 else if (lscp_parser_test(&tok, "UNSUBSCRIBE")) {
418     // Deregister frontend for not receiving event notification messages anymore:
419     // UNSUBSCRIBE <event>
420     ret = lscp_server_unsubscribe(pConnect, lscp_event_from_text(lscp_parser_next(&tok)));
421 capela 105 }
422     else if (lscp_parser_test(&tok, "QUIT")) {
423     // Close client connection:
424     // QUIT
425     lscp_parser_free(&tok);
426     return LSCP_FAILED; // Disconnect.
427     }
428     else ret = LSCP_FAILED;
429    
430     lscp_parser_free(&tok);
431    
432     if (pszResult == NULL)
433     pszResult = (ret == LSCP_OK ? "OK\r\n" : "ERR:1:Failed\r\n");
434    
435     fprintf(stderr, "> %s", pszResult);
436    
437     return lscp_server_result(pConnect, pszResult, strlen(pszResult));
438     }
439    
440     ////////////////////////////////////////////////////////////////////////
441    
442     void server_usage (void)
443     {
444     printf("\n %s %s (Build: %s)\n", lscp_server_package(), lscp_server_version(), lscp_server_build());
445    
446     fputs("\n Available server commands: help, exit, quit, list", stdout);
447     fputs("\n (all else are broadcast verbatim to subscribers)\n\n", stdout);
448     }
449    
450     void server_prompt (void)
451     {
452     fputs("lscp_server> ", stdout);
453     }
454    
455     int main (int argc, char *argv[] )
456     {
457     lscp_server_t *pServer;
458     char szLine[200];
459     int cchLine;
460     lscp_connect_t *p;
461    
462     #if defined(WIN32)
463     if (WSAStartup(MAKEWORD(1, 1), &_wsaData) != 0) {
464     fprintf(stderr, "lscp_server: WSAStartup failed.\n");
465     return -1;
466     }
467     #endif
468    
469     srand(time(NULL));
470    
471     pServer = lscp_server_create(SERVER_PORT, server_callback, NULL);
472     if (pServer == NULL)
473     return -1;
474    
475     server_usage();
476     server_prompt();
477    
478     while (fgets(szLine, sizeof(szLine), stdin)) {
479    
480     cchLine = strlen(szLine);
481     while (cchLine > 0 && (szLine[cchLine - 1] == '\n' || szLine[cchLine - 1] == '\r'))
482     cchLine--;
483     szLine[cchLine] = '\0';
484    
485     if (strcmp(szLine, "exit") == 0 || strcmp(szLine, "quit") == 0)
486     break;
487     else
488     if (strcmp(szLine, "list") == 0) {
489     for (p = pServer->connects.first; p; p = p->next) {
490 capela 146 printf("client: sock=%d addr=%s port=%d events=0x%04x.\n",
491 capela 105 p->client.sock,
492     inet_ntoa(p->client.addr.sin_addr),
493     ntohs(p->client.addr.sin_port),
494 capela 146 (int) p->events
495 capela 105 );
496     }
497     }
498     else
499     if (cchLine > 0 && strcmp(szLine, "help") != 0)
500 capela 146 lscp_server_broadcast(pServer, LSCP_EVENT_MISCELLANEOUS, szLine, strlen(szLine));
501 capela 105 else
502     server_usage();
503    
504     server_prompt();
505     }
506    
507     lscp_server_destroy(pServer);
508    
509     #if defined(WIN32)
510     WSACleanup();
511     #endif
512    
513     return 0;
514     }
515    
516     // end of example_server.c

  ViewVC Help
Powered by ViewVC