summaryrefslogtreecommitdiff
path: root/apps/plugins/pdbox/PDa/extra/sendOSC.c
diff options
context:
space:
mode:
Diffstat (limited to 'apps/plugins/pdbox/PDa/extra/sendOSC.c')
-rw-r--r--apps/plugins/pdbox/PDa/extra/sendOSC.c1461
1 files changed, 0 insertions, 1461 deletions
diff --git a/apps/plugins/pdbox/PDa/extra/sendOSC.c b/apps/plugins/pdbox/PDa/extra/sendOSC.c
deleted file mode 100644
index 6bb809d68f..0000000000
--- a/apps/plugins/pdbox/PDa/extra/sendOSC.c
+++ /dev/null
@@ -1,1461 +0,0 @@
1/*
2Written by Matt Wright, The Center for New Music and Audio Technologies,
3University of California, Berkeley. Copyright (c) 1996,97,98,99,2000,01,02,03
4The Regents of the University of California (Regents).
5
6Permission to use, copy, modify, distribute, and distribute modified versions
7of this software and its documentation without fee and without a signed
8licensing agreement, is hereby granted, provided that the above copyright
9notice, this paragraph and the following two paragraphs appear in all copies,
10modifications, and distributions.
11
12IN NO EVENT SHALL REGENTS BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT,
13SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING LOST PROFITS, ARISING
14OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF REGENTS HAS
15BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
16
17REGENTS SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
18THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
19PURPOSE. THE SOFTWARE AND ACCOMPANYING DOCUMENTATION, IF ANY, PROVIDED
20HEREUNDER IS PROVIDED "AS IS". REGENTS HAS NO OBLIGATION TO PROVIDE
21MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
22
23
24The OSC webpage is http://cnmat.cnmat.berkeley.edu/OpenSoundControl
25*/
26
27
28/* sendOSC.c
29
30 Matt Wright, 6/3/97
31 based on sendOSC.c, which was based on a version by Adrian Freed
32
33 Text-based OpenSoundControl client. User can enter messages via command
34 line arguments or standard input.
35
36 Version 0.1: "play" feature
37 Version 0.2: Message type tags.
38
39 pd version branched from http://www.cnmat.berkeley.edu/OpenSoundControl/src/sendOSC/sendOSC.c
40 -------------
41 -- added bundle stuff to send. jdl 20020416
42 -- tweaks for Win32 www.zeggz.com/raf 13-April-2002
43 -- ost_at_test.at + i22_at_test.at, 2000-2002
44 modified to compile as pd externel
45*/
46
47#define MAX_ARGS 2000
48#define SC_BUFFER_SIZE 64000
49
50#include "../src/m_pd.h"
51#include "OSC-client.h"
52
53#include <string.h>
54#include <sys/types.h>
55#include <stdlib.h>
56#include <stdio.h>
57#include <sys/stat.h>
58#include <sys/types.h>
59
60#ifdef WIN32
61#include <winsock2.h>
62#include <io.h>
63#include <errno.h>
64#include <fcntl.h>
65#include <winsock2.h>
66#include <ctype.h>
67#include <signal.h>
68#else
69#include <sys/socket.h>
70#include <netinet/in.h>
71#include <rpc/rpc.h>
72#include <sys/times.h>
73#include <sys/param.h>
74#include <sys/time.h>
75#include <sys/ioctl.h>
76#include <netdb.h>
77#endif
78
79#ifdef __APPLE__
80 #include <string.h>
81#endif
82
83#define UNIXDG_PATH "/tmp/htm"
84#define UNIXDG_TMP "/tmp/htm.XXXXXX"
85
86
87
88OSCTimeTag OSCTT_Immediately(void) {
89 OSCTimeTag result;
90 result.seconds = 0;
91 result.fraction = 1;
92 return result;
93}
94
95
96OSCTimeTag OSCTT_CurrentTime(void) {
97 OSCTimeTag result;
98 result.seconds = 0;
99 result.fraction = 1;
100 return result;
101}
102
103OSCTimeTag OSCTT_PlusSeconds(OSCTimeTag original, float secondsOffset) {
104 OSCTimeTag result;
105 result.seconds = 0;
106 result.fraction = 1;
107 return result;
108}
109
110
111typedef int bool;
112
113typedef struct
114{
115 float srate;
116
117 struct sockaddr_in serv_addr; /* udp socket */
118 #ifndef WIN32
119 struct sockaddr_un userv_addr; /* UNIX socket */
120 #endif
121 int sockfd; /* socket file descriptor */
122 int index, len,uservlen;
123 void *addr;
124 int id;
125} desc;
126
127
128/* open a socket for HTM communication to given host on given portnumber */
129/* if host is 0 then UNIX protocol is used (i.e. local communication */
130void *OpenHTMSocket(char *host, int portnumber)
131{
132 struct sockaddr_in cl_addr;
133 #ifndef WIN32
134 int sockfd;
135 struct sockaddr_un ucl_addr;
136 #else
137 unsigned int sockfd;
138 #endif
139
140 desc *o;
141 int oval = 1;
142 o = malloc(sizeof(*o));
143 if(!o) return 0;
144
145 #ifndef WIN32
146
147 if(!host)
148 {
149 char *mktemp(char *);
150 int clilen;
151 o->len = sizeof(ucl_addr);
152 /*
153 * Fill in the structure "userv_addr" with the address of the
154 * server that we want to send to.
155 */
156
157 bzero((char *) &o->userv_addr, sizeof(o->userv_addr));
158 o->userv_addr.sun_family = AF_UNIX;
159 strcpy(o->userv_addr.sun_path, UNIXDG_PATH);
160 sprintf(o->userv_addr.sun_path+strlen(o->userv_addr.sun_path), "%d", portnumber);
161 o->uservlen = sizeof(o->userv_addr.sun_family) + strlen(o->userv_addr.sun_path);
162 o->addr = &(o->userv_addr);
163 /*
164 * Open a socket (a UNIX domain datagram socket).
165 */
166
167 if ( (sockfd = socket(AF_UNIX, SOCK_DGRAM, 0)) >= 0)
168 {
169 /*
170 * Bind a local address for us.
171 * In the UNIX domain we have to choose our own name (that
172 * should be unique). We'll use mktemp() to create a unique
173 * pathname, based on our process id.
174 */
175
176 bzero((char *) &ucl_addr, sizeof(ucl_addr)); /* zero out */
177 ucl_addr.sun_family = AF_UNIX;
178 strcpy(ucl_addr.sun_path, UNIXDG_TMP);
179
180 mktemp(ucl_addr.sun_path);
181 clilen = sizeof(ucl_addr.sun_family) + strlen(ucl_addr.sun_path);
182
183 if (bind(sockfd, (struct sockaddr *) &ucl_addr, clilen) < 0)
184 {
185 perror("client: can't bind local address");
186 close(sockfd);
187 sockfd = -1;
188 }
189 }
190 else
191 perror("unable to make socket\n");
192
193 }else
194
195 #endif
196
197 {
198 /*
199 * Fill in the structure "serv_addr" with the address of the
200 * server that we want to send to.
201 */
202 o->len = sizeof(cl_addr);
203
204 #ifdef WIN32
205 ZeroMemory((char *)&o->serv_addr, sizeof(o->serv_addr));
206 #else
207 bzero((char *)&o->serv_addr, sizeof(o->serv_addr));
208 #endif
209
210 o->serv_addr.sin_family = AF_INET;
211
212 /* MW 6/6/96: Call gethostbyname() instead of inet_addr(),
213 so that host can be either an Internet host name (e.g.,
214 "les") or an Internet address in standard dot notation
215 (e.g., "128.32.122.13") */
216 {
217 struct hostent *hostsEntry;
218 unsigned long address;
219
220 hostsEntry = gethostbyname(host);
221 if (hostsEntry == NULL) {
222 fprintf(stderr, "Couldn't decipher host name \"%s\"\n", host);
223 #ifndef WIN32
224 herror(NULL);
225 #endif
226 return 0;
227 }
228 address = *((unsigned long *) hostsEntry->h_addr_list[0]);
229 o->serv_addr.sin_addr.s_addr = address;
230 }
231
232 /* was: o->serv_addr.sin_addr.s_addr = inet_addr(host); */
233
234 /* End MW changes */
235
236 /*
237 * Open a socket (a UDP domain datagram socket).
238 */
239
240
241 #ifdef WIN32
242 o->serv_addr.sin_port = htons((USHORT)portnumber);
243 o->addr = &(o->serv_addr);
244 if((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) != INVALID_SOCKET) {
245 ZeroMemory((char *)&cl_addr, sizeof(cl_addr));
246 cl_addr.sin_family = AF_INET;
247 cl_addr.sin_addr.s_addr = htonl(INADDR_ANY);
248 cl_addr.sin_port = htons(0);
249
250 // enable broadcast: jdl ~2003
251 if(setsockopt(sockfd, SOL_SOCKET, SO_BROADCAST, &oval, sizeof(int)) == -1) {
252 perror("setsockopt");
253 }
254
255 if(bind(sockfd, (struct sockaddr *) &cl_addr, sizeof(cl_addr)) < 0) {
256 perror("could not bind\n");
257 closesocket(sockfd);
258 sockfd = -1;
259 }
260 }
261 else { perror("unable to make socket\n");}
262 #else
263 o->serv_addr.sin_port = htons(portnumber);
264 o->addr = &(o->serv_addr);
265 if((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) >= 0) {
266 bzero((char *)&cl_addr, sizeof(cl_addr));
267 cl_addr.sin_family = AF_INET;
268 cl_addr.sin_addr.s_addr = htonl(INADDR_ANY);
269 cl_addr.sin_port = htons(0);
270
271 // enable broadcast: jdl ~2003
272 if(setsockopt(sockfd, SOL_SOCKET, SO_BROADCAST, &oval, sizeof(int)) == -1) {
273 perror("setsockopt");
274 }
275
276 if(bind(sockfd, (struct sockaddr *) &cl_addr, sizeof(cl_addr)) < 0) {
277 perror("could not bind\n");
278 close(sockfd);
279 sockfd = -1;
280 }
281 }
282 else { perror("unable to make socket\n");}
283 #endif
284 }
285 #ifdef WIN32
286 if(sockfd == INVALID_SOCKET) {
287 #else
288 if(sockfd < 0) {
289 #endif
290 free(o);
291 o = 0;
292 }
293 else
294 o->sockfd = sockfd;
295 return o;
296}
297
298static bool sendudp(const struct sockaddr *sp, int sockfd,int length, int count, void *b)
299{
300 int rcount;
301 if((rcount=sendto(sockfd, b, count, 0, sp, length)) != count)
302 {
303 printf("sockfd %d count %d rcount %dlength %d\n", sockfd,count,rcount,length);
304 return FALSE;
305 }
306 return TRUE;
307}
308
309bool SendHTMSocket(void *htmsendhandle, int length_in_bytes, void *buffer)
310{
311 desc *o = (desc *)htmsendhandle;
312 return sendudp(o->addr, o->sockfd, o->len, length_in_bytes, buffer);
313}
314void CloseHTMSocket(void *htmsendhandle)
315{
316 desc *o = (desc *)htmsendhandle;
317 #ifdef WIN32
318 if(SOCKET_ERROR == closesocket(o->sockfd)) {
319 perror("CloseHTMSocket::closesocket failed\n");
320 return;
321 }
322 #else
323 if(close(o->sockfd) == -1)
324 {
325 perror("CloseHTMSocket::closesocket failed");
326 return;
327 }
328 #endif
329
330 free(o);
331}
332
333
334///////////////////////
335// from sendOSC
336
337typedef struct {
338 //enum {INT, FLOAT, STRING} type;
339 enum {INT_osc, FLOAT_osc, STRING_osc} type;
340 union {
341 int i;
342 float f;
343 char *s;
344 } datum;
345} typedArg;
346
347void CommandLineMode(int argc, char *argv[], void *htmsocket);
348OSCTimeTag ParseTimeTag(char *s);
349void ParseInteractiveLine(OSCbuf *buf, char *mesg);
350typedArg ParseToken(char *token);
351int WriteMessage(OSCbuf *buf, char *messageName, int numArgs, typedArg *args);
352void SendBuffer(void *htmsocket, OSCbuf *buf);
353void SendData(void *htmsocket, int size, char *data);
354/* defined in OSC-system-dependent.c now */
355
356//static void *htmsocket;
357static int exitStatus = 0;
358static int useTypeTags = 0;
359
360static char bufferForOSCbuf[SC_BUFFER_SIZE];
361
362
363/////////
364// end from sendOSC
365
366static t_class *sendOSC_class;
367
368typedef struct _sendOSC
369{
370 t_object x_obj;
371 int x_protocol; // UDP/TCP (udp only atm)
372 t_int x_typetags; // typetag flag
373 void *x_htmsocket; // sending socket
374 int x_bundle; // bundle open flag
375 OSCbuf x_oscbuf[1]; // OSCbuffer
376 t_outlet *x_bdpthout;// bundle-depth floatoutlet
377} t_sendOSC;
378
379static void *sendOSC_new(t_floatarg udpflag)
380{
381 t_sendOSC *x = (t_sendOSC *)pd_new(sendOSC_class);
382 outlet_new(&x->x_obj, &s_float);
383 x->x_htmsocket = 0; // {{raf}}
384 // set udp
385 x->x_protocol = SOCK_STREAM;
386 // set typetags to 1 by default
387 x->x_typetags = 1;
388 // bunlde is closed
389 x->x_bundle = 0;
390 OSC_initBuffer(x->x_oscbuf, SC_BUFFER_SIZE, bufferForOSCbuf);
391 x->x_bdpthout = outlet_new(&x->x_obj, 0); // outlet_float();
392 //x->x_oscbuf =
393 return (x);
394}
395
396
397void sendOSC_openbundle(t_sendOSC *x)
398{
399 if (x->x_oscbuf->bundleDepth + 1 >= MAX_BUNDLE_NESTING ||
400 OSC_openBundle(x->x_oscbuf, OSCTT_Immediately()))
401 {
402 post("Problem opening bundle: %s\n", OSC_errorMessage);
403 return;
404 }
405 x->x_bundle = 1;
406 outlet_float(x->x_bdpthout, (float)x->x_oscbuf->bundleDepth);
407}
408
409static void sendOSC_closebundle(t_sendOSC *x)
410{
411 if (OSC_closeBundle(x->x_oscbuf)) {
412 post("Problem closing bundle: %s\n", OSC_errorMessage);
413 return;
414 }
415 outlet_float(x->x_bdpthout, (float)x->x_oscbuf->bundleDepth);
416 // in bundle mode we send when bundle is closed?
417 if(!OSC_isBufferEmpty(x->x_oscbuf) > 0 && OSC_isBufferDone(x->x_oscbuf)) {
418 // post("x_oscbuf: something inside me?");
419 if (x->x_htmsocket) {
420 SendBuffer(x->x_htmsocket, x->x_oscbuf);
421 } else {
422 post("sendOSC: not connected");
423 }
424 OSC_initBuffer(x->x_oscbuf, SC_BUFFER_SIZE, bufferForOSCbuf);
425 x->x_bundle = 0;
426 return;
427 }
428 // post("x_oscbuf: something went wrong");
429}
430
431static void sendOSC_settypetags(t_sendOSC *x, t_float *f)
432 {
433 x->x_typetags = (int)f;
434 post("sendOSC.c: setting typetags %d",x->x_typetags);
435 }
436
437
438static void sendOSC_connect(t_sendOSC *x, t_symbol *hostname,
439 t_floatarg fportno)
440{
441 int portno = fportno;
442 /* create a socket */
443
444 // make sure handle is available
445 if(x->x_htmsocket == 0) {
446 //
447 x->x_htmsocket = OpenHTMSocket(hostname->s_name, portno);
448 if (!x->x_htmsocket)
449 post("Couldn't open socket: ");
450 else {
451 post("connected to port %s:%d (hSock=%d)", hostname->s_name, portno, x->x_htmsocket);
452 outlet_float(x->x_obj.ob_outlet, 1);
453 }
454 }
455 else
456 perror("call to sendOSC_connect() against UNavailable socket handle");
457}
458
459void sendOSC_disconnect(t_sendOSC *x)
460{
461 if (x->x_htmsocket)
462 {
463 post("disconnecting htmsock (hSock=%d)...", x->x_htmsocket);
464 CloseHTMSocket(x->x_htmsocket);
465 x->x_htmsocket = 0; // {{raf}} semi-quasi-semaphorize this
466 outlet_float(x->x_obj.ob_outlet, 0);
467 }
468 else {
469 perror("call to sendOSC_disconnect() against unused socket handle");
470 }
471}
472
473void sendOSC_senduntyped(t_sendOSC *x, t_symbol *s, int argc, t_atom *argv)
474{
475 char* targv[MAXPDARG];
476 char tmparg[MAXPDSTRING];
477 char* tmp = tmparg;
478 //char testarg[MAXPDSTRING];
479 int c;
480
481 post("sendOSC: use typetags 0/1 message and plain send method so send untypetagged...");
482 return;
483
484 //atom_string(argv,testarg, MAXPDSTRING);
485 for (c=0;c<argc;c++) {
486 atom_string(argv+c,tmp, 80);
487 targv[c] = tmp;
488 tmp += strlen(tmp)+1;
489 }
490
491 // this sock needs to be larger than 0, not >= ..
492 if (x->x_htmsocket)
493 {
494 CommandLineMode(argc, targv, x->x_htmsocket);
495 // post("test %d", c);
496 }
497 else {
498 post("sendOSC: not connected");
499 }
500}
501
502//////////////////////////////////////////////////////////////////////
503// this is the real and only sending routine now, for both typed and
504// undtyped mode.
505
506static void sendOSC_sendtyped(t_sendOSC *x, t_symbol *s, int argc, t_atom *argv)
507{
508 char* targv[MAX_ARGS];
509 char tmparg[MAXPDSTRING];
510 char* tmp = tmparg;
511 int c;
512
513 char *messageName;
514 char *token;
515 typedArg args[MAX_ARGS];
516 int i,j;
517 int numArgs = 0;
518
519 messageName = "";
520#ifdef DEBUG
521 post ("sendOSC: messageName: %s", messageName);
522#endif
523
524
525
526 for (c=0;c<argc;c++) {
527 atom_string(argv+c,tmp, 80);
528
529#ifdef DEBUG
530 // post ("sendOSC: %d, %s",c, tmp);
531#endif
532
533 targv[c] = tmp;
534 tmp += strlen(tmp)+1;
535
536#ifdef DEBUG
537 // post ("sendOSC: %d, %s",c, targv[c]);
538#endif
539 }
540
541 // this sock needs to be larger than 0, not >= ..
542 if (x->x_htmsocket > 0)
543 {
544#ifdef DEBUG
545 post ("sendOSC: type tags? %d", useTypeTags);
546#endif
547
548 messageName = strtok(targv[0], ",");
549 j = 1;
550 for (i = j; i < argc; i++) {
551 token = strtok(targv[i],",");
552 args[i-j] = ParseToken(token);
553#ifdef DEBUG
554 printf("cell-cont: %s\n", targv[i]);
555 printf(" type-id: %d\n", args[i-j]);
556#endif
557 numArgs = i;
558 }
559
560
561 if(WriteMessage(x->x_oscbuf, messageName, numArgs, args)) {
562 post("sendOSC: usage error, write-msg failed: %s", OSC_errorMessage);
563 return;
564 }
565
566 if(!x->x_bundle) {
567 SendBuffer(x->x_htmsocket, x->x_oscbuf);
568 OSC_initBuffer(x->x_oscbuf, SC_BUFFER_SIZE, bufferForOSCbuf);
569 }
570
571 //CommandLineMode(argc, targv, x->x_htmsocket);
572 //useTypeTags = 0;
573 }
574 else {
575 post("sendOSC: not connected");
576 }
577}
578
579void sendOSC_send(t_sendOSC *x, t_symbol *s, int argc, t_atom *argv)
580{
581 if(!argc) {
582 post("not sending empty message.");
583 return;
584 }
585 if(x->x_typetags) {
586 useTypeTags = 1;
587 sendOSC_sendtyped(x,s,argc,argv);
588 useTypeTags = 0;
589 } else {
590 sendOSC_sendtyped(x,s,argc,argv);
591 }
592}
593
594static void sendOSC_free(t_sendOSC *x)
595{
596 sendOSC_disconnect(x);
597}
598
599#ifdef WIN32
600 OSC_API void sendOSC_setup(void) {
601#else
602 void sendOSC_setup(void) {
603#endif
604 sendOSC_class = class_new(gensym("sendOSC"), (t_newmethod)sendOSC_new,
605 (t_method)sendOSC_free,
606 sizeof(t_sendOSC), 0, A_DEFFLOAT, 0);
607 class_addmethod(sendOSC_class, (t_method)sendOSC_connect,
608 gensym("connect"), A_SYMBOL, A_FLOAT, 0);
609 class_addmethod(sendOSC_class, (t_method)sendOSC_disconnect,
610 gensym("disconnect"), 0);
611 class_addmethod(sendOSC_class, (t_method)sendOSC_settypetags,
612 gensym("typetags"),
613 A_FLOAT, 0);
614 class_addmethod(sendOSC_class, (t_method)sendOSC_send,
615 gensym("send"),
616 A_GIMME, 0);
617 class_addmethod(sendOSC_class, (t_method)sendOSC_send,
618 gensym("senduntyped"),
619 A_GIMME, 0);
620 class_addmethod(sendOSC_class, (t_method)sendOSC_send,
621 gensym("sendtyped"),
622 A_GIMME, 0);
623 class_addmethod(sendOSC_class, (t_method)sendOSC_openbundle,
624 gensym("["),
625 0, 0);
626 class_addmethod(sendOSC_class, (t_method)sendOSC_closebundle,
627 gensym("]"),
628 0, 0);
629 class_sethelpsymbol(sendOSC_class, gensym("sendOSC-help.pd"));
630}
631
632
633
634
635
636/* Exit status codes:
637 0: successful
638 2: Message(s) dropped because of buffer overflow
639 3: Socket error
640 4: Usage error
641 5: Internal error
642*/
643
644void CommandLineMode(int argc, char *argv[], void *htmsocket) {
645 char *messageName;
646 char *token;
647 typedArg args[MAX_ARGS];
648 int i,j, numArgs;
649 OSCbuf buf[1];
650
651 OSC_initBuffer(buf, SC_BUFFER_SIZE, bufferForOSCbuf);
652
653 if (argc > 1) {
654 post("argc (%d) > 1", argc);
655 }
656
657 // ParseInteractiveLine(buf, argv);
658 messageName = strtok(argv[0], ",");
659
660 j = 1;
661 for (i = j; i < argc; i++) {
662 token = strtok(argv[i],",");
663 args[i-j] = ParseToken(token);
664#ifdef DEBUG
665 printf("cell-cont: %s\n", argv[i]);
666 printf(" type-id: %d\n", args[i-j]);
667#endif
668 numArgs = i;
669 }
670
671 if(WriteMessage(buf, messageName, numArgs, args)) {
672 post("sendOSC: usage error. write-msg failed: %s", OSC_errorMessage);
673 return;
674 }
675
676 SendBuffer(htmsocket, buf);
677}
678
679#define MAXMESG 2048
680
681void InteractiveMode(void *htmsocket) {
682 char mesg[MAXMESG];
683 OSCbuf buf[1];
684 int bundleDepth = 0; /* At first, we haven't seen "[". */
685
686 OSC_initBuffer(buf, SC_BUFFER_SIZE, bufferForOSCbuf);
687
688 while (fgets(mesg, MAXMESG, stdin) != NULL) {
689 if (mesg[0] == '\n') {
690 if (bundleDepth > 0) {
691 /* Ignore blank lines inside a group. */
692 } else {
693 /* blank line => repeat previous send */
694 SendBuffer(htmsocket, buf);
695 }
696 continue;
697 }
698
699 if (bundleDepth == 0) {
700 OSC_resetBuffer(buf);
701 }
702
703 if (mesg[0] == '[') {
704 OSCTimeTag tt = ParseTimeTag(mesg+1);
705 if (OSC_openBundle(buf, tt)) {
706 post("Problem opening bundle: %s\n", OSC_errorMessage);
707 OSC_resetBuffer(buf);
708 bundleDepth = 0;
709 continue;
710 }
711 bundleDepth++;
712 } else if (mesg[0] == ']' && mesg[1] == '\n' && mesg[2] == '\0') {
713 if (bundleDepth == 0) {
714 post("Unexpected ']': not currently in a bundle.\n");
715 } else {
716 if (OSC_closeBundle(buf)) {
717 post("Problem closing bundle: %s\n", OSC_errorMessage);
718 OSC_resetBuffer(buf);
719 bundleDepth = 0;
720 continue;
721 }
722
723 bundleDepth--;
724 if (bundleDepth == 0) {
725 SendBuffer(htmsocket, buf);
726 }
727 }
728 } else {
729 ParseInteractiveLine(buf, mesg);
730 if (bundleDepth != 0) {
731 /* Don't send anything until we close all bundles */
732 } else {
733 SendBuffer(htmsocket, buf);
734 }
735 }
736 }
737}
738
739OSCTimeTag ParseTimeTag(char *s) {
740 char *p, *newline;
741 typedArg arg;
742
743 p = s;
744 while (isspace(*p)) p++;
745 if (*p == '\0') return OSCTT_Immediately();
746
747 if (*p == '+') {
748 /* Time tag is for some time in the future. It should be a
749 number of seconds as an int or float */
750
751 newline = strchr(s, '\n');
752 if (newline != NULL) *newline = '\0';
753
754 p++; /* Skip '+' */
755 while (isspace(*p)) p++;
756
757 arg = ParseToken(p);
758 if (arg.type == STRING_osc) {
759 post("warning: inscrutable time tag request: %s\n", s);
760 return OSCTT_Immediately();
761 } else if (arg.type == INT_osc) {
762 return OSCTT_PlusSeconds(OSCTT_CurrentTime(),
763 (float) arg.datum.i);
764 } else if (arg.type == FLOAT_osc) {
765 return OSCTT_PlusSeconds(OSCTT_CurrentTime(), arg.datum.f);
766 } else {
767 error("This can't happen!");
768 }
769 }
770
771 if (isdigit(*p) || (*p >= 'a' && *p <='f') || (*p >= 'A' && *p <='F')) {
772 /* They specified the 8-byte tag in hex */
773 OSCTimeTag tt;
774 if (sscanf(p, "%llx", &tt) != 1) {
775 post("warning: couldn't parse time tag %s\n", s);
776 return OSCTT_Immediately();
777 }
778#ifndef HAS8BYTEINT
779 if (ntohl(1) != 1) {
780 /* tt is a struct of seconds and fractional part,
781 and this machine is little-endian, so sscanf
782 wrote each half of the time tag in the wrong half
783 of the struct. */
784 int temp;
785 temp = tt.seconds;
786 tt.seconds = tt.fraction ;
787 tt.fraction = temp;
788 }
789#endif
790 return tt;
791 }
792
793 post("warning: invalid time tag: %s\n", s);
794 return OSCTT_Immediately();
795}
796
797
798void ParseInteractiveLine(OSCbuf *buf, char *mesg) {
799 char *messageName, *token, *p;
800 typedArg args[MAX_ARGS];
801 int thisArg;
802
803 p = mesg;
804 while (isspace(*p)) p++;
805 if (*p == '\0') return;
806
807 messageName = p;
808
809 if (strcmp(messageName, "play\n") == 0) {
810 /* Special kludge feature to save typing */
811 typedArg arg;
812
813 if (OSC_openBundle(buf, OSCTT_Immediately())) {
814 post("Problem opening bundle: %s\n", OSC_errorMessage);
815 return;
816 }
817
818 arg.type = INT_osc;
819 arg.datum.i = 0;
820 WriteMessage(buf, "/voices/0/tp/timbre_index", 1, &arg);
821
822 arg.type = FLOAT_osc;
823 arg.datum.i = 0.0f;
824 WriteMessage(buf, "/voices/0/tm/goto", 1, &arg);
825
826 if (OSC_closeBundle(buf)) {
827 post("Problem closing bundle: %s\n", OSC_errorMessage);
828 }
829
830 return;
831 }
832
833 while (!isspace(*p) && *p != '\0') p++;
834 if (isspace(*p)) {
835 *p = '\0';
836 p++;
837 }
838
839 thisArg = 0;
840 while (*p != '\0') {
841 /* flush leading whitespace */
842 while (isspace(*p)) p++;
843 if (*p == '\0') break;
844
845 if (*p == '"') {
846 /* A string argument: scan for close quotes */
847 p++;
848 args[thisArg].type = STRING_osc;
849 args[thisArg].datum.s = p;
850
851 while (*p != '"') {
852 if (*p == '\0') {
853 post("Unterminated quote mark: ignoring line\n");
854 return;
855 }
856 p++;
857 }
858 *p = '\0';
859 p++;
860 } else {
861 token = p;
862 while (!isspace(*p) && (*p != '\0')) p++;
863 if (isspace(*p)) {
864 *p = '\0';
865 p++;
866 }
867 args[thisArg] = ParseToken(token);
868 }
869 thisArg++;
870 if (thisArg >= MAX_ARGS) {
871 post("Sorry, your message has more than MAX_ARGS (%d) arguments; ignoring the rest.\n",
872 MAX_ARGS);
873 break;
874 }
875 }
876
877 if (WriteMessage(buf, messageName, thisArg, args) != 0) {
878 post("Problem sending message: %s\n", OSC_errorMessage);
879 }
880}
881
882typedArg ParseToken(char *token) {
883 char *p = token;
884 typedArg returnVal;
885
886 /* It might be an int, a float, or a string */
887
888 if (*p == '-') p++;
889
890 if (isdigit(*p) || *p == '.') {
891 while (isdigit(*p)) p++;
892 if (*p == '\0') {
893 returnVal.type = INT_osc;
894 returnVal.datum.i = atoi(token);
895 return returnVal;
896 }
897 if (*p == '.') {
898 p++;
899 while (isdigit(*p)) p++;
900 if (*p == '\0') {
901 returnVal.type = FLOAT_osc;
902 returnVal.datum.f = atof(token);
903 return returnVal;
904 }
905 }
906 }
907
908 returnVal.type = STRING_osc;
909 returnVal.datum.s = token;
910 return returnVal;
911}
912
913int WriteMessage(OSCbuf *buf, char *messageName, int numArgs, typedArg *args) {
914 int j, returnVal;
915 const int wmERROR = -1;
916
917 returnVal = 0;
918
919#ifdef DEBUG
920 printf("WriteMessage: %s ", messageName);
921
922 for (j = 0; j < numArgs; j++) {
923 switch (args[j].type) {
924 case INT_osc:
925 printf("%d ", args[j].datum.i);
926 break;
927
928 case FLOAT_osc:
929 printf("%f ", args[j].datum.f);
930 break;
931
932 case STRING_osc:
933 printf("%s ", args[j].datum.s);
934 break;
935
936 default:
937 error("Unrecognized arg type, (not exiting)");
938 return(wmERROR);
939 }
940 }
941 printf("\n");
942#endif
943
944 if (!useTypeTags) {
945 returnVal = OSC_writeAddress(buf, messageName);
946 if (returnVal) {
947 post("Problem writing address: %s\n", OSC_errorMessage);
948 }
949 } else {
950 /* First figure out the type tags */
951 char typeTags[MAX_ARGS+2];
952 int i;
953
954 typeTags[0] = ',';
955
956 for (i = 0; i < numArgs; ++i) {
957 switch (args[i].type) {
958 case INT_osc:
959 typeTags[i+1] = 'i';
960 break;
961
962 case FLOAT_osc:
963 typeTags[i+1] = 'f';
964 break;
965
966 case STRING_osc:
967 typeTags[i+1] = 's';
968 break;
969
970 default:
971 error("Unrecognized arg type (not exiting)");
972 return(wmERROR);
973 }
974 }
975 typeTags[i+1] = '\0';
976
977 returnVal = OSC_writeAddressAndTypes(buf, messageName, typeTags);
978 if (returnVal) {
979 post("Problem writing address: %s\n", OSC_errorMessage);
980 }
981 }
982
983 for (j = 0; j < numArgs; j++) {
984 switch (args[j].type) {
985 case INT_osc:
986 if ((returnVal = OSC_writeIntArg(buf, args[j].datum.i)) != 0) {
987 return returnVal;
988 }
989 break;
990
991 case FLOAT_osc:
992 if ((returnVal = OSC_writeFloatArg(buf, args[j].datum.f)) != 0) {
993 return returnVal;
994 }
995 break;
996
997 case STRING_osc:
998 if ((returnVal = OSC_writeStringArg(buf, args[j].datum.s)) != 0) {
999 return returnVal;
1000 }
1001 break;
1002
1003 default:
1004 error("Unrecognized arg type (not exiting)");
1005 returnVal = wmERROR;
1006 }
1007 }
1008 return returnVal;
1009}
1010
1011void SendBuffer(void *htmsocket, OSCbuf *buf) {
1012#ifdef DEBUG
1013 printf("Sending buffer...\n");
1014#endif
1015 if (OSC_isBufferEmpty(buf)) {
1016 post("SendBuffer() called but buffer empty");
1017 return;
1018 }
1019 if (!OSC_isBufferDone(buf)) {
1020 error("SendBuffer() called but buffer not ready!, not exiting");
1021 return; //{{raf}}
1022 }
1023 SendData(htmsocket, OSC_packetSize(buf), OSC_getPacket(buf));
1024}
1025
1026void SendData(void *htmsocket, int size, char *data) {
1027 if (!SendHTMSocket(htmsocket, size, data)) {
1028 post("SendData::SendHTMSocket()failure -- not connected");
1029 CloseHTMSocket(htmsocket);
1030 }
1031}
1032
1033
1034
1035/* ----------------------
1036 OSC-client code
1037
1038 */
1039
1040/* Here are the possible values of the state field: */
1041
1042#define EMPTY 0 /* Nothing written to packet yet */
1043#define ONE_MSG_ARGS 1 /* Packet has a single message; gathering arguments */
1044#define NEED_COUNT 2 /* Just opened a bundle; must write message name or
1045 open another bundle */
1046#define GET_ARGS 3 /* Getting arguments to a message. If we see a message
1047 name or a bundle open/close then the current message
1048 will end. */
1049#define DONE 4 /* All open bundles have been closed, so can't write
1050 anything else */
1051
1052#ifdef WIN32
1053 #include <winsock2.h>
1054 #include <io.h>
1055 #include <stdio.h>
1056 #include <errno.h>
1057 #include <fcntl.h>
1058 #include <sys/types.h>
1059 #include <sys/stat.h>
1060#endif
1061
1062#ifdef __APPLE__
1063 #include <sys/types.h>
1064#endif
1065
1066#ifdef unix
1067 #include <netinet/in.h>
1068 #include <stdio.h>
1069#endif
1070
1071
1072char *OSC_errorMessage;
1073
1074static int OSC_padString(char *dest, char *str);
1075static int OSC_padStringWithAnExtraStupidComma(char *dest, char *str);
1076static int OSC_WritePadding(char *dest, int i);
1077static int CheckTypeTag(OSCbuf *buf, char expectedType);
1078
1079void OSC_initBuffer(OSCbuf *buf, int size, char *byteArray) {
1080 buf->buffer = byteArray;
1081 buf->size = size;
1082 OSC_resetBuffer(buf);
1083}
1084
1085void OSC_resetBuffer(OSCbuf *buf) {
1086 buf->bufptr = buf->buffer;
1087 buf->state = EMPTY;
1088 buf->bundleDepth = 0;
1089 buf->prevCounts[0] = 0;
1090 buf->gettingFirstUntypedArg = 0;
1091 buf->typeStringPtr = 0;
1092}
1093
1094int OSC_isBufferEmpty(OSCbuf *buf) {
1095 return buf->bufptr == buf->buffer;
1096}
1097
1098int OSC_freeSpaceInBuffer(OSCbuf *buf) {
1099 return buf->size - (buf->bufptr - buf->buffer);
1100}
1101
1102int OSC_isBufferDone(OSCbuf *buf) {
1103 return (buf->state == DONE || buf->state == ONE_MSG_ARGS);
1104}
1105
1106char *OSC_getPacket(OSCbuf *buf) {
1107#ifdef ERROR_CHECK_GETPACKET
1108 if (buf->state == DONE || buf->state == ONE_MSG_ARGS) {
1109 return buf->buffer;
1110 } else {
1111 OSC_errorMessage = "Packet has unterminated bundles";
1112 return 0;
1113 }
1114#else
1115 return buf->buffer;
1116#endif
1117}
1118
1119int OSC_packetSize(OSCbuf *buf) {
1120#ifdef ERROR_CHECK_PACKETSIZE
1121 if (buf->state == DONE || buf->state == ONE_MSG_ARGS) {
1122 return (buf->bufptr - buf->buffer);
1123 } else {
1124 OSC_errorMessage = "Packet has unterminated bundles";
1125 return 0;
1126 }
1127#else
1128 return (buf->bufptr - buf->buffer);
1129#endif
1130}
1131
1132#define CheckOverflow(buf, bytesNeeded) { if ((bytesNeeded) > OSC_freeSpaceInBuffer(buf)) {OSC_errorMessage = "buffer overflow"; return 1;}}
1133
1134static void PatchMessageSize(OSCbuf *buf) {
1135 int4byte size;
1136 size = buf->bufptr - ((char *) buf->thisMsgSize) - 4;
1137 *(buf->thisMsgSize) = htonl(size);
1138}
1139
1140int OSC_openBundle(OSCbuf *buf, OSCTimeTag tt) {
1141 if (buf->state == ONE_MSG_ARGS) {
1142 OSC_errorMessage = "Can't open a bundle in a one-message packet";
1143 return 3;
1144 }
1145
1146 if (buf->state == DONE) {
1147 OSC_errorMessage = "This packet is finished; can't open a new bundle";
1148 return 4;
1149 }
1150
1151 if (++(buf->bundleDepth) >= MAX_BUNDLE_NESTING) {
1152 OSC_errorMessage = "Bundles nested too deeply; change MAX_BUNDLE_NESTING in OpenSoundControl.h";
1153 return 2;
1154 }
1155
1156 if (CheckTypeTag(buf, '\0')) return 9;
1157
1158 if (buf->state == GET_ARGS) {
1159 PatchMessageSize(buf);
1160 }
1161
1162 if (buf->state == EMPTY) {
1163 /* Need 16 bytes for "#bundle" and time tag */
1164 CheckOverflow(buf, 16);
1165 } else {
1166 /* This bundle is inside another bundle, so we need to leave
1167 a blank size count for the size of this current bundle. */
1168 CheckOverflow(buf, 20);
1169 *((int4byte *)buf->bufptr) = 0xaaaaaaaa;
1170 buf->prevCounts[buf->bundleDepth] = (int4byte *)buf->bufptr;
1171
1172 buf->bufptr += 4;
1173 }
1174
1175 buf->bufptr += OSC_padString(buf->bufptr, "#bundle");
1176
1177
1178 *((OSCTimeTag *) buf->bufptr) = tt;
1179
1180 if (htonl(1) != 1) {
1181 /* Byte swap the 8-byte integer time tag */
1182 int4byte *intp = (int4byte *)buf->bufptr;
1183 intp[0] = htonl(intp[0]);
1184 intp[1] = htonl(intp[1]);
1185
1186#ifdef HAS8BYTEINT
1187 { /* tt is a 64-bit int so we have to swap the two 32-bit words.
1188 (Otherwise tt is a struct of two 32-bit words, and even though
1189 each word was wrong-endian, they were in the right order
1190 in the struct.) */
1191 int4byte temp = intp[0];
1192 intp[0] = intp[1];
1193 intp[1] = temp;
1194 }
1195#endif
1196 }
1197
1198 buf->bufptr += sizeof(OSCTimeTag);
1199
1200 buf->state = NEED_COUNT;
1201
1202 buf->gettingFirstUntypedArg = 0;
1203 buf->typeStringPtr = 0;
1204 return 0;
1205}
1206
1207
1208int OSC_closeBundle(OSCbuf *buf) {
1209 if (buf->bundleDepth == 0) {
1210 /* This handles EMPTY, ONE_MSG, ARGS, and DONE */
1211 OSC_errorMessage = "Can't close bundle; no bundle is open!";
1212 return 5;
1213 }
1214
1215 if (CheckTypeTag(buf, '\0')) return 9;
1216
1217 if (buf->state == GET_ARGS) {
1218 PatchMessageSize(buf);
1219 }
1220
1221 if (buf->bundleDepth == 1) {
1222 /* Closing the last bundle: No bundle size to patch */
1223 buf->state = DONE;
1224 } else {
1225 /* Closing a sub-bundle: patch bundle size */
1226 int size = buf->bufptr - ((char *) buf->prevCounts[buf->bundleDepth]) - 4;
1227 *(buf->prevCounts[buf->bundleDepth]) = htonl(size);
1228 buf->state = NEED_COUNT;
1229 }
1230
1231 --buf->bundleDepth;
1232 buf->gettingFirstUntypedArg = 0;
1233 buf->typeStringPtr = 0;
1234 return 0;
1235}
1236
1237
1238int OSC_closeAllBundles(OSCbuf *buf) {
1239 if (buf->bundleDepth == 0) {
1240 /* This handles EMPTY, ONE_MSG, ARGS, and DONE */
1241 OSC_errorMessage = "Can't close all bundles; no bundle is open!";
1242 return 6;
1243 }
1244
1245 if (CheckTypeTag(buf, '\0')) return 9;
1246
1247 while (buf->bundleDepth > 0) {
1248 OSC_closeBundle(buf);
1249 }
1250 buf->typeStringPtr = 0;
1251 return 0;
1252}
1253
1254int OSC_writeAddress(OSCbuf *buf, char *name) {
1255 int4byte paddedLength;
1256
1257 if (buf->state == ONE_MSG_ARGS) {
1258 OSC_errorMessage = "This packet is not a bundle, so you can't write another address";
1259 return 7;
1260 }
1261
1262 if (buf->state == DONE) {
1263 OSC_errorMessage = "This packet is finished; can't write another address";
1264 return 8;
1265 }
1266
1267 if (CheckTypeTag(buf, '\0')) return 9;
1268
1269 paddedLength = OSC_effectiveStringLength(name);
1270
1271 if (buf->state == EMPTY) {
1272 /* This will be a one-message packet, so no sizes to worry about */
1273 CheckOverflow(buf, paddedLength);
1274 buf->state = ONE_MSG_ARGS;
1275 } else {
1276 /* GET_ARGS or NEED_COUNT */
1277 CheckOverflow(buf, 4+paddedLength);
1278 if (buf->state == GET_ARGS) {
1279 /* Close the old message */
1280 PatchMessageSize(buf);
1281 }
1282 buf->thisMsgSize = (int4byte *)buf->bufptr;
1283 *(buf->thisMsgSize) = 0xbbbbbbbb;
1284 buf->bufptr += 4;
1285 buf->state = GET_ARGS;
1286 }
1287
1288 /* Now write the name */
1289 buf->bufptr += OSC_padString(buf->bufptr, name);
1290 buf->typeStringPtr = 0;
1291 buf->gettingFirstUntypedArg = 1;
1292
1293 return 0;
1294}
1295
1296int OSC_writeAddressAndTypes(OSCbuf *buf, char *name, char *types) {
1297 int result;
1298 int4byte paddedLength;
1299
1300 if (CheckTypeTag(buf, '\0')) return 9;
1301
1302 result = OSC_writeAddress(buf, name);
1303
1304 if (result) return result;
1305
1306 paddedLength = OSC_effectiveStringLength(types);
1307
1308 CheckOverflow(buf, paddedLength);
1309
1310 buf->typeStringPtr = buf->bufptr + 1; /* skip comma */
1311 buf->bufptr += OSC_padString(buf->bufptr, types);
1312
1313 buf->gettingFirstUntypedArg = 0;
1314 return 0;
1315}
1316
1317static int CheckTypeTag(OSCbuf *buf, char expectedType) {
1318 if (buf->typeStringPtr) {
1319 if (*(buf->typeStringPtr) != expectedType) {
1320 if (expectedType == '\0') {
1321 OSC_errorMessage =
1322 "According to the type tag I expected more arguments.";
1323 } else if (*(buf->typeStringPtr) == '\0') {
1324 OSC_errorMessage =
1325 "According to the type tag I didn't expect any more arguments.";
1326 } else {
1327 OSC_errorMessage =
1328 "According to the type tag I expected an argument of a different type.";
1329 printf("* Expected %c, string now %s\n", expectedType, buf->typeStringPtr);
1330 }
1331 return 9;
1332 }
1333 ++(buf->typeStringPtr);
1334 }
1335 return 0;
1336}
1337
1338
1339int OSC_writeFloatArg(OSCbuf *buf, float arg) {
1340 int4byte *intp;
1341 //int result;
1342
1343 CheckOverflow(buf, 4);
1344
1345 if (CheckTypeTag(buf, 'f')) return 9;
1346
1347 /* Pretend arg is a long int so we can use htonl() */
1348 intp = ((int4byte *) &arg);
1349 *((int4byte *) buf->bufptr) = htonl(*intp);
1350
1351 buf->bufptr += 4;
1352
1353 buf->gettingFirstUntypedArg = 0;
1354 return 0;
1355}
1356
1357
1358
1359int OSC_writeFloatArgs(OSCbuf *buf, int numFloats, float *args) {
1360 int i;
1361 int4byte *intp;
1362
1363 CheckOverflow(buf, 4 * numFloats);
1364
1365 /* Pretend args are long ints so we can use htonl() */
1366 intp = ((int4byte *) args);
1367
1368 for (i = 0; i < numFloats; i++) {
1369 if (CheckTypeTag(buf, 'f')) return 9;
1370 *((int4byte *) buf->bufptr) = htonl(intp[i]);
1371 buf->bufptr += 4;
1372 }
1373
1374 buf->gettingFirstUntypedArg = 0;
1375 return 0;
1376}
1377
1378int OSC_writeIntArg(OSCbuf *buf, int4byte arg) {
1379 CheckOverflow(buf, 4);
1380 if (CheckTypeTag(buf, 'i')) return 9;
1381
1382 *((int4byte *) buf->bufptr) = htonl(arg);
1383 buf->bufptr += 4;
1384
1385 buf->gettingFirstUntypedArg = 0;
1386 return 0;
1387}
1388
1389int OSC_writeStringArg(OSCbuf *buf, char *arg) {
1390 int len;
1391
1392 if (CheckTypeTag(buf, 's')) return 9;
1393
1394 len = OSC_effectiveStringLength(arg);
1395
1396 if (buf->gettingFirstUntypedArg && arg[0] == ',') {
1397 /* This un-type-tagged message starts with a string
1398 that starts with a comma, so we have to escape it
1399 (with a double comma) so it won't look like a type
1400 tag string. */
1401
1402 CheckOverflow(buf, len+4); /* Too conservative */
1403 buf->bufptr +=
1404 OSC_padStringWithAnExtraStupidComma(buf->bufptr, arg);
1405
1406 } else {
1407 CheckOverflow(buf, len);
1408 buf->bufptr += OSC_padString(buf->bufptr, arg);
1409 }
1410
1411 buf->gettingFirstUntypedArg = 0;
1412 return 0;
1413
1414}
1415
1416/* String utilities */
1417
1418#define STRING_ALIGN_PAD 4
1419int OSC_effectiveStringLength(char *string) {
1420 int len = strlen(string) + 1; /* We need space for the null char. */
1421
1422 /* Round up len to next multiple of STRING_ALIGN_PAD to account for alignment padding */
1423 if ((len % STRING_ALIGN_PAD) != 0) {
1424 len += STRING_ALIGN_PAD - (len % STRING_ALIGN_PAD);
1425 }
1426 return len;
1427}
1428
1429static int OSC_padString(char *dest, char *str) {
1430 int i;
1431
1432 for (i = 0; str[i] != '\0'; i++) {
1433 dest[i] = str[i];
1434 }
1435
1436 return OSC_WritePadding(dest, i);
1437}
1438
1439static int OSC_padStringWithAnExtraStupidComma(char *dest, char *str) {
1440 int i;
1441
1442 dest[0] = ',';
1443 for (i = 0; str[i] != '\0'; i++) {
1444 dest[i+1] = str[i];
1445 }
1446
1447 return OSC_WritePadding(dest, i+1);
1448}
1449
1450static int OSC_WritePadding(char *dest, int i) {
1451 dest[i] = '\0';
1452 i++;
1453
1454 for (; (i % STRING_ALIGN_PAD) != 0; i++) {
1455 dest[i] = '\0';
1456 }
1457
1458 return i;
1459}
1460
1461
generated by cgit v1.2.3 (git 2.39.1) at 2024-09-22 23:20:44 +0000