apps/plugins/pdbox/PDa/extra/sendOSC.c

   1 /*
   2 Written by Matt Wright, The Center for New Music and Audio Technologies,
   3 University of California, Berkeley.  Copyright (c) 1996,97,98,99,2000,01,02,03
   4 The Regents of the University of California (Regents).
   5
   6 Permission to use, copy, modify, distribute, and distribute modified versions
   7 of this software and its documentation without fee and without a signed
   8 licensing agreement, is hereby granted, provided that the above copyright
   9 notice, this paragraph and the following two paragraphs appear in all copies,
  10 modifications, and distributions.
  11
  12 IN NO EVENT SHALL REGENTS BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT,
  13 SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING LOST PROFITS, ARISING
  14 OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF REGENTS HAS
  15 BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  16
  17 REGENTS SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  18 THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  19 PURPOSE. THE SOFTWARE AND ACCOMPANYING DOCUMENTATION, IF ANY, PROVIDED
  20 HEREUNDER IS PROVIDED "AS IS". REGENTS HAS NO OBLIGATION TO PROVIDE
  21 MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
  22
  23
  24 The 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
  88 OSCTimeTag OSCTT_Immediately(void) {
  89     OSCTimeTag result;
  90     result.seconds = 0;
  91     result.fraction = 1;
  92     return result;
  93 }
  94
  95
  96 OSCTimeTag OSCTT_CurrentTime(void) {
  97     OSCTimeTag result;
  98     result.seconds = 0;
  99     result.fraction = 1;
 100     return result;
 101 }
 102
 103 OSCTimeTag OSCTT_PlusSeconds(OSCTimeTag original, float secondsOffset) {
 104     OSCTimeTag result;
 105     result.seconds = 0;
 106     result.fraction = 1;
 107     return result;
 108 }
 109
 110
 111 typedef int bool;
 112
 113 typedef 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 */
 130 void *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
 298 static  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
 309 bool 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 }
 314 void 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
 337 typedef 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
 347 void CommandLineMode(int argc, char *argv[], void *htmsocket);
 348 OSCTimeTag ParseTimeTag(char *s);
 349 void ParseInteractiveLine(OSCbuf *buf, char *mesg);
 350 typedArg ParseToken(char *token);
 351 int WriteMessage(OSCbuf *buf, char *messageName, int numArgs, typedArg *args);
 352 void SendBuffer(void *htmsocket, OSCbuf *buf);
 353 void SendData(void *htmsocket, int size, char *data);
 354 /* defined in OSC-system-dependent.c now */
 355
 356 //static void *htmsocket;
 357 static int exitStatus = 0;
 358 static int useTypeTags = 0;
 359
 360 static char bufferForOSCbuf[SC_BUFFER_SIZE];
 361
 362
 363 /////////
 364 // end from sendOSC
 365
 366 static t_class *sendOSC_class;
 367
 368 typedef 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
 379 static 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
 397 void 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
 409 static 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
 431 static 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
 438 static 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
 459 void 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
 473 void 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
 506 static 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
 579 void 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
 594 static 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
 644 void 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
 681 void 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
 739 OSCTimeTag 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
 798 void 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
 882 typedArg 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
 913 int 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
1011 void 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
1026 void 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
1072 char *OSC_errorMessage;
1073
1074 static int OSC_padString(char *dest, char *str);
1075 static int OSC_padStringWithAnExtraStupidComma(char *dest, char *str);
1076 static int OSC_WritePadding(char *dest, int i);
1077 static int CheckTypeTag(OSCbuf *buf, char expectedType);
1078
1079 void OSC_initBuffer(OSCbuf *buf, int size, char *byteArray) {
1080     buf->buffer = byteArray;
1081     buf->size = size;
1082     OSC_resetBuffer(buf);
1083 }
1084
1085 void 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
1094 int OSC_isBufferEmpty(OSCbuf *buf) {
1095     return buf->bufptr == buf->buffer;
1096 }
1097
1098 int OSC_freeSpaceInBuffer(OSCbuf *buf) {
1099     return buf->size - (buf->bufptr - buf->buffer);
1100 }
1101
1102 int OSC_isBufferDone(OSCbuf *buf) {
1103     return (buf->state == DONE || buf->state == ONE_MSG_ARGS);
1104 }
1105
1106 char *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
1119 int 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
1134 static void PatchMessageSize(OSCbuf *buf) {
1135     int4byte size;
1136     size = buf->bufptr - ((char *) buf->thisMsgSize) - 4;
1137     *(buf->thisMsgSize) = htonl(size);
1138 }
1139
1140 int 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
1208 int 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
1238 int 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
1254 int 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
1296 int 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
1317 static 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
1339 int 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
1359 int 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
1378 int 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
1389 int 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
1419 int 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
1429 static 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
1439 static 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
1450 static 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