lang/LangPrimSource/SC_ComPort.cpp

   1 /*
   2         SuperCollider real time audio synthesis system
   3     Copyright (c) 2002 James McCartney. All rights reserved.
   4         http://www.audiosynth.com
   5
   6     This program is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
  19 */
  20
  21 #include "SC_BoundsMacros.h"
  22 #include "SC_ComPort.h"
  23 #include "SC_Endian.h"
  24 //#include "SC_Lock.h"
  25 #include <ctype.h>
  26 #include <stdexcept>
  27 #include <stdarg.h>
  28 #include "SCBase.h"
  29 #include <fcntl.h>
  30
  31 #ifndef SC_WIN32
  32 # include <unistd.h>
  33 #else
  34 #include "SC_Win32Utils.h"
  35 #endif
  36
  37 #ifdef SC_LINUX
  38 # include <errno.h>
  39 #endif
  40
  41 #ifdef __FreeBSD__
  42 # include <errno.h>
  43 #endif
  44
  45 #if defined(SC_DARWIN) || defined(SC_IPHONE)
  46 #include <errno.h>
  47 #endif
  48
  49 // sk: determine means of blocking SIGPIPE for send(2) (implementation
  50 // dependent)
  51
  52 #define HAVE_SO_NOSIGPIPE 0
  53 #define HAVE_MSG_NOSIGNAL 0
  54
  55 #if defined(SO_NOSIGPIPE)
  56 # undef HAVE_SO_NOSIGPIPE
  57 # define HAVE_SO_NOSIGPIPE 1
  58 #elif defined(MSG_NOSIGNAL)
  59 # undef HAVE_MSG_NOSIGNAL
  60 # define HAVE_MSG_NOSIGNAL 1
  61 #endif
  62
  63 int recvall(int socket, void *msg, size_t len);
  64 int recvallfrom(int socket, void *msg, size_t len, struct sockaddr *fromaddr, int addrlen);
  65 int sendallto(int socket, const void *msg, size_t len, struct sockaddr *toaddr, int addrlen);
  66 int sendall(int socket, const void *msg, size_t len);
  67
  68 void ProcessOSCPacket(OSC_Packet *inPacket, int inPortNum);
  69
  70 void dumpOSCmsg(int inSize, char* inData)
  71 {
  72         int size;
  73         const char *data;
  74
  75         if (inData[0]) {
  76                 char *addr = inData;
  77                 data = OSCstrskip(inData);
  78                 size = inSize - (data - inData);
  79                 printf("[ \"%s\",", addr);
  80         }
  81         else
  82         {
  83                 printf("[ %d,", OSCint(inData));
  84                 data = inData + 4;
  85                 size = inSize - 4;
  86         }
  87
  88         sc_msg_iter msg(size, data);
  89
  90         while (msg.remain())
  91         {
  92                 char c = msg.nextTag('i');
  93                 switch(c)
  94                 {
  95                         case 'i' :
  96                                 printf(" %d", msg.geti());
  97                                 break;
  98                         case 'f' :
  99                                 printf(" %g", msg.getf());
 100                                 break;
 101                         case 'd' :
 102                                 printf(" %g", msg.getd());
 103                                 break;
 104                         case 's' :
 105                                 printf(" \"%s\"", msg.gets());
 106                                 break;
 107                         case 'b' :
 108                                 printf(" DATA[%zu]", msg.getbsize());
 109                                 msg.skipb();
 110                                 break;
 111                         default :
 112                                 printf(" !unknown tag '%c' 0x%02x !", isprint(c)?c:'?', (unsigned char)c & 255);
 113                                 goto leave;
 114                 }
 115                 if (msg.remain()) printf(",");
 116         }
 117 leave:
 118         printf(" ]");
 119 }
 120
 121 void hexdump(int size, char* data)
 122 {
 123         char ascii[20];
 124         int padsize = (size + 15) & -16;
 125         printf("size %d\n", size);
 126         for (int i=0; i<padsize; ++i)
 127         {
 128                 if ((i&15)==0)
 129                 {
 130                         printf("%4d   ", i);
 131                 }
 132                 if (i >= size)
 133                 {
 134                         printf("   ");
 135                         ascii[i&15] = 0;
 136                 }
 137                 else
 138                 {
 139                         printf("%02x ", (unsigned char)data[i] & 255);
 140
 141                         if (isprint(data[i])) ascii[i&15] = data[i];
 142                         else ascii[i&15] = '.';
 143                 }
 144                 if ((i&15)==15)
 145                 {
 146                         ascii[16] = 0;
 147                         printf("  |%s|\n", ascii);
 148                 }
 149                 else if ((i&3)==3)
 150                 {
 151                         printf(" ");
 152                 }
 153         }
 154         printf("\n");
 155 }
 156
 157 void dumpOSC(int mode, int size, char* inData)
 158 {
 159         if (mode & 1)
 160         {
 161                 if (strcmp(inData, "#bundle") == 0)
 162                 {
 163                         char* data = inData + 8;
 164                         printf("[ \"#bundle\", %lld, ", OSCtime(data));
 165                         data += 8;
 166                         char* dataEnd = inData + size;
 167                         while (data < dataEnd) {
 168                                 int32 msgSize = OSCint(data);
 169                                 data += sizeof(int32);
 170                                 printf("\n    ");
 171                                 dumpOSCmsg(msgSize, data);
 172                                 data += msgSize;
 173                                 if (data < dataEnd) printf(",");
 174                         }
 175                         printf("\n]\n");
 176                 }
 177                 else
 178                 {
 179                         dumpOSCmsg(size, inData);
 180                         printf("\n");
 181                 }
 182         }
 183
 184         if (mode & 2) hexdump(size, inData);
 185 }
 186
 187 //////////////////////////////////////////////////////////////////////////////////////////////////////////
 188
 189 SC_CmdPort::SC_CmdPort()
 190 {
 191 }
 192
 193 SC_CmdPort::~SC_CmdPort()
 194 {
 195 }
 196
 197 //////////////////////////////////////////////////////////////////////////////////////////////////////////
 198
 199 SC_ComPort::SC_ComPort(int inPortNum)
 200         : mPortNum(inPortNum), mSocket(-1)
 201 {
 202 }
 203
 204 SC_ComPort::~SC_ComPort()
 205 {
 206 #ifdef SC_WIN32
 207     if (mSocket != -1) closesocket(mSocket);
 208 #else
 209     if (mSocket != -1) close(mSocket);
 210 #endif
 211 }
 212
 213 void* com_thread_func(void* arg);
 214 void* com_thread_func(void* arg)
 215 {
 216     SC_CmdPort *thread = (SC_CmdPort*)arg;
 217     void* result = thread->Run();
 218     return result;
 219 }
 220
 221 void SC_CmdPort::Start()
 222 {
 223     pthread_create (&mThread, NULL, com_thread_func, (void*)this);
 224 }
 225
 226 //////////////////////////////////////////////////////////////////////////////////////////////////////////
 227
 228 SC_UdpInPort::SC_UdpInPort(int inPortNum)
 229         : SC_ComPort(inPortNum)
 230 {
 231         if ((mSocket = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
 232                 throw std::runtime_error("failed to create udp socket\n");
 233         }
 234
 235         {
 236                 int bufsize = 65536;
 237 #ifdef SC_WIN32
 238                 setsockopt(mSocket, SOL_SOCKET, SO_SNDBUF, (char*)&bufsize, sizeof(bufsize));
 239 #else
 240                 setsockopt(mSocket, SOL_SOCKET, SO_SNDBUF, &bufsize, sizeof(bufsize));
 241 #endif
 242         }
 243
 244         bzero((char *)&mBindSockAddr, sizeof(mBindSockAddr));
 245         mBindSockAddr.sin_family = AF_INET;
 246         mBindSockAddr.sin_addr.s_addr = htonl(INADDR_ANY);
 247
 248         bool bound = false;
 249         for (int i=0; i<10 && !bound; ++i) {
 250                         mPortNum = mPortNum+i;
 251             mBindSockAddr.sin_port = htons(mPortNum);
 252             if (bind(mSocket, (struct sockaddr *)&mBindSockAddr, sizeof(mBindSockAddr)) >= 0) {
 253                 bound = true;
 254             }
 255         }
 256         if (!bound) throw std::runtime_error("unable to bind udp socket\n");
 257         Start();
 258 }
 259
 260 SC_UdpInPort::~SC_UdpInPort()
 261 {
 262 #ifdef SC_WIN32
 263         if (mSocket != -1) closesocket(mSocket);
 264 #else
 265         if (mSocket != -1) close(mSocket);
 266 #endif
 267 }
 268
 269 //////////////////////////////////////////////////////////////////////////////////////////////////////////
 270
 271 SC_UdpCustomInPort::SC_UdpCustomInPort(int inPortNum)
 272 : SC_ComPort(inPortNum)
 273 {
 274         if ((mSocket = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
 275                 throw std::runtime_error("failed to create udp socket\n");
 276         }
 277
 278         {
 279                 int bufsize = 65536;
 280 #ifdef SC_WIN32
 281                 setsockopt(mSocket, SOL_SOCKET, SO_SNDBUF, (char*)&bufsize, sizeof(bufsize));
 282 #else
 283                 setsockopt(mSocket, SOL_SOCKET, SO_SNDBUF, &bufsize, sizeof(bufsize));
 284 #endif
 285         }
 286
 287         bzero((char *)&mBindSockAddr, sizeof(mBindSockAddr));
 288         mBindSockAddr.sin_family = AF_INET;
 289         mBindSockAddr.sin_addr.s_addr = htonl(INADDR_ANY);
 290
 291         bool bound = false;
 292         mBindSockAddr.sin_port = htons(mPortNum);
 293         if (bind(mSocket, (struct sockaddr *)&mBindSockAddr, sizeof(mBindSockAddr)) >= 0) {
 294                 bound = true;
 295         }
 296         if (!bound) throw std::runtime_error("unable to bind udp socket\n");
 297         Start();
 298 }
 299
 300 SC_UdpCustomInPort::~SC_UdpCustomInPort()
 301 {
 302         mRunning.store(false);
 303         pthread_join(mThread, NULL);
 304 #ifdef SC_WIN32
 305         if (mSocket != -1) closesocket(mSocket);
 306 #else
 307         if (mSocket != -1) close(mSocket);
 308 #endif
 309
 310 }
 311
 312 //////////////////////////////////////////////////////////////////////////////////////////////////////////
 313
 314 void DumpReplyAddress(ReplyAddress *inReplyAddress)
 315 {
 316         printf("mSockAddrLen %d\n", inReplyAddress->mSockAddrLen);
 317         printf("mSocket %d\n", inReplyAddress->mSocket);
 318 #ifdef SC_DARWIN
 319         printf("mSockAddr.sin_len %d\n", inReplyAddress->mSockAddr.sin_len);
 320 #endif
 321         printf("mSockAddr.sin_family %d\n", inReplyAddress->mSockAddr.sin_family);
 322         printf("mSockAddr.sin_port %d\n", inReplyAddress->mSockAddr.sin_port);
 323         printf("mSockAddr.sin_addr.s_addr %d\n", inReplyAddress->mSockAddr.sin_addr.s_addr);
 324         printf("mReplyFunc %p\n", inReplyAddress->mReplyFunc);
 325 }
 326
 327 /*
 328 int32 Hash(ReplyAddress *inReplyAddress)
 329 {
 330         int32 hash;
 331         int32 *word = (int32*)&inReplyAddress->mSockAddr;
 332         hash = Hash(inReplyAddress->mSockAddr.sin_addr.s_addr);
 333
 334         hash += inReplyAddress->mSockAddr.sin_len << 24
 335                 | inReplyAddress->mSockAddr.sin_family << 16
 336                 | inReplyAddress->mSockAddr.sin_port;
 337
 338         hash = Hash(hash);
 339         return hash;
 340 }
 341 */
 342
 343 void udp_reply_func(struct ReplyAddress *addr, char* msg, int size);
 344 void udp_reply_func(struct ReplyAddress *addr, char* msg, int size)
 345 {
 346         printf("->udp_reply_func\n");
 347         int total = sendallto(addr->mSocket, msg, size, (sockaddr*)&addr->mSockAddr, addr->mSockAddrLen);
 348         printf("<-udp_reply_func  %d of %d\n", total, size);
 349         if (total < size) DumpReplyAddress(addr);
 350 }
 351
 352 ReplyFunc SC_UdpInPort::GetReplyFunc()
 353 {
 354         return udp_reply_func;
 355 }
 356
 357 void* SC_UdpInPort::Run()
 358 {
 359         char buf[kTextBufSize];
 360         OSC_Packet *packet = 0;
 361
 362         //printf("SC_UdpInPort::Run\n"); fflush(stdout);
 363
 364         while (true) {
 365                 if (!packet) {
 366                         packet = (OSC_Packet*)malloc(sizeof(OSC_Packet));
 367                 }
 368                 packet->mReplyAddr.mSockAddrLen = sizeof(sockaddr_in);
 369                 int size = recvfrom(mSocket, buf, kTextBufSize , 0,
 370                                                                 (struct sockaddr *) &packet->mReplyAddr.mSockAddr, (socklen_t*)&packet->mReplyAddr.mSockAddrLen);
 371
 372                 if (size > 0) {
 373                         //dumpOSC(3, size, buf);
 374                         //fflush(stdout);
 375
 376                         char *data = (char*)malloc(size);
 377                         packet->mReplyAddr.mReplyFunc = udp_reply_func;
 378                         packet->mSize = size;
 379                         packet->mData = data;
 380                         packet->mReplyAddr.mSocket = mSocket;
 381                         memcpy(data, buf, size);
 382                         ProcessOSCPacket(packet, mPortNum);
 383                         packet = 0;
 384                 }
 385         }
 386         return 0;
 387 }
 388
 389 ReplyFunc SC_UdpCustomInPort::GetReplyFunc()
 390 {
 391         return udp_reply_func;
 392 }
 393
 394 void* SC_UdpCustomInPort::Run()
 395 {
 396         char buf[kTextBufSize];
 397         OSC_Packet *packet = 0;
 398
 399         const int fd = mSocket;
 400         const int max_fd = fd+1;
 401
 402         mRunning.store(true);
 403         while (mRunning.load(boost::memory_order_consume)) {
 404                 fd_set rfds;
 405
 406                 FD_ZERO(   &rfds);
 407                 FD_SET(fd, &rfds);
 408
 409                 struct timeval timeout;
 410                 timeout.tv_sec = 0;
 411                 timeout.tv_usec = 500000;
 412
 413                 int n = select(max_fd, &rfds, 0, 0, &timeout);
 414                 if ((n > 0) && FD_ISSET(fd, &rfds)) {
 415                         if (!packet) {
 416                                 packet = (OSC_Packet*)malloc(sizeof(OSC_Packet));
 417                         }
 418                         packet->mReplyAddr.mSockAddrLen = sizeof(sockaddr_in);
 419                         int size = recvfrom(mSocket, buf, kTextBufSize , 0,
 420                                                                 (struct sockaddr *) &packet->mReplyAddr.mSockAddr, (socklen_t*)&packet->mReplyAddr.mSockAddrLen);
 421
 422                         if (size > 0 && mRunning.load(boost::memory_order_consume)) {
 423                                 //dumpOSC(3, size, buf);
 424                                 //fflush(stdout);
 425
 426                                 char *data = (char*)malloc(size);
 427                                 packet->mReplyAddr.mReplyFunc = udp_reply_func;
 428                                 packet->mSize = size;
 429                                 packet->mData = data;
 430                                 packet->mReplyAddr.mSocket = mSocket;
 431                                 memcpy(data, buf, size);
 432                                 ProcessOSCPacket(packet, mPortNum);
 433                                 packet = 0;
 434                         }
 435                 }
 436         }
 437         FreeOSCPacket(packet); // just in case
 438         return 0;
 439 }
 440
 441 //////////////////////////////////////////////////////////////////////////////////////////////////////////
 442
 443 SC_TcpInPort::SC_TcpInPort(int inPortNum, int inMaxConnections, int inBacklog)
 444         : SC_ComPort(inPortNum), mConnectionAvailable(inMaxConnections),
 445         mBacklog(inBacklog)
 446 {
 447
 448     if((mSocket = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
 449         throw std::runtime_error("failed to create tcp socket\n");
 450     }
 451     //setsockopt(mSocket, SOL_SOCKET, TCP_NODELAY);
 452
 453     bzero((char *)&mBindSockAddr, sizeof(mBindSockAddr));
 454     mBindSockAddr.sin_family = AF_INET;
 455     mBindSockAddr.sin_addr.s_addr = htonl(INADDR_ANY);
 456     mBindSockAddr.sin_port = htons(mPortNum);
 457
 458     if(bind(mSocket, (struct sockaddr *)&mBindSockAddr, sizeof(mBindSockAddr)) < 0)
 459     {
 460         throw std::runtime_error("unable to bind tcp socket\n");
 461     }
 462     if(listen(mSocket, mBacklog) < 0)
 463     {
 464         throw std::runtime_error("unable to listen tcp socket\n");
 465     }
 466
 467     Start();
 468 }
 469
 470 void* SC_TcpInPort::Run()
 471 {
 472     while (true)
 473     {
 474         mConnectionAvailable.Acquire();
 475         struct sockaddr_in address; /* Internet socket address stuct */
 476         int addressSize=sizeof(struct sockaddr_in);
 477         int socket = accept(mSocket,(struct sockaddr*)&address,(socklen_t*)&addressSize);
 478         if (socket < 0) {
 479                 mConnectionAvailable.Release();
 480         } else {
 481                 new SC_TcpConnectionPort(this, socket);
 482         }
 483     }
 484     return 0;
 485 }
 486
 487 void SC_TcpInPort::ConnectionTerminated()
 488 {
 489         mConnectionAvailable.Release();
 490 }
 491
 492 void null_reply_func(struct ReplyAddress *addr, char* msg, int size);
 493 void null_reply_func(struct ReplyAddress *addr, char* msg, int size)
 494 {
 495 }
 496
 497 ReplyFunc SC_TcpInPort::GetReplyFunc()
 498 {
 499         return null_reply_func;
 500 }
 501
 502 //////////////////////////////////////////////////////////////////////////////////////////////////////////
 503
 504 SC_TcpConnectionPort::SC_TcpConnectionPort(SC_TcpInPort *inParent, int inSocket)
 505     : SC_ComPort(0), mParent(inParent)
 506 {
 507     mSocket = inSocket;
 508     Start();
 509 }
 510
 511 SC_TcpConnectionPort::~SC_TcpConnectionPort()
 512 {
 513 #ifdef SC_WIN32
 514         closesocket(mSocket);
 515 #else
 516         close(mSocket);
 517 #endif
 518     mParent->ConnectionTerminated();
 519 }
 520
 521 void tcp_reply_func(struct ReplyAddress *addr, char* msg, int size);
 522 void tcp_reply_func(struct ReplyAddress *addr, char* msg, int size)
 523 {
 524         sendall(addr->mSocket, msg, size);
 525 }
 526
 527 ReplyFunc SC_TcpConnectionPort::GetReplyFunc()
 528 {
 529         return tcp_reply_func;
 530 }
 531
 532 extern const char* gPassword;
 533
 534 void* SC_TcpConnectionPort::Run()
 535 {
 536         OSC_Packet *packet = 0;
 537         // wait for login message
 538         int32 size;
 539         int32 msglen;
 540
 541         while (true) {
 542                 if (!packet) {
 543                         packet = (OSC_Packet*)malloc(sizeof(OSC_Packet));
 544                 }
 545                 size = recvall(mSocket, &msglen, sizeof(int32));
 546                 if (size < 0) goto leave;
 547
 548                 // sk: msglen is in network byte order
 549                 msglen = ntohl(msglen);
 550
 551                 char *data = (char*)malloc(msglen);
 552                 size = recvall(mSocket, data, msglen);
 553                 if (size < msglen) goto leave;
 554
 555                 packet->mReplyAddr.mReplyFunc = tcp_reply_func;
 556                 packet->mSize = msglen;
 557                 packet->mData = data;
 558                 packet->mReplyAddr.mSocket = mSocket;
 559                 ProcessOSCPacket(packet, mPortNum);
 560                 packet = 0;
 561         }
 562 leave:
 563     delete this; // ohh this could cause a crash if a reply tries to access it..
 564     return 0;
 565 }
 566
 567 //////////////////////////////////////////////////////////////////////////////////////////////////////////
 568
 569 #ifndef SC_WIN32
 570 # include <sys/select.h>
 571 #endif
 572 //SC_WIN32
 573
 574 SC_TcpClientPort::SC_TcpClientPort(int inSocket, ClientNotifyFunc notifyFunc, void *clientData)
 575         : SC_ComPort(0),
 576           mClientNotifyFunc(notifyFunc),
 577           mClientData(clientData)
 578 {
 579         mSocket = inSocket;
 580         socklen_t sockAddrLen = sizeof(mReplySockAddr);
 581
 582         if (getpeername(mSocket, (struct sockaddr*)&mReplySockAddr, &sockAddrLen) == -1) {
 583                 memset(&mReplySockAddr, 0, sizeof(mReplySockAddr));
 584                 mReplySockAddr.sin_family = AF_INET;
 585                 mReplySockAddr.sin_addr.s_addr = htonl(INADDR_NONE);
 586                 mReplySockAddr.sin_port = htons(0);
 587         }
 588
 589 #if HAVE_SO_NOSIGPIPE
 590         int sockopt = 1;
 591         setsockopt(mSocket, SOL_SOCKET, SO_NOSIGPIPE, &sockopt, sizeof(sockopt));
 592 #endif // HAVE_SO_NOSIGPIPE
 593
 594         if (pipe(mCmdFifo) == -1) {
 595                 mCmdFifo[0] = mCmdFifo[1] = -1;
 596         }
 597
 598         Start();
 599 }
 600
 601 SC_TcpClientPort::~SC_TcpClientPort()
 602 {
 603 #ifdef SC_WIN32
 604         closesocket(mCmdFifo[0]);
 605         closesocket(mCmdFifo[1]);
 606         closesocket(mSocket);
 607 #else
 608         close(mCmdFifo[0]);
 609         close(mCmdFifo[1]);
 610         close(mSocket);
 611 #endif
 612 }
 613
 614 void* SC_TcpClientPort::Run()
 615 {
 616         OSC_Packet *packet = 0;
 617         int32 size;
 618         int32 msglen;
 619
 620         int cmdfd = mCmdFifo[0];
 621         int sockfd = mSocket;
 622         int nfds = sc_max(cmdfd, sockfd) + 1;
 623
 624         bool cmdClose = false;
 625
 626         pthread_detach(mThread);
 627
 628         while (true) {
 629                 fd_set rfds;
 630                 FD_ZERO(&rfds);
 631                 FD_SET(cmdfd, &rfds);
 632                 FD_SET(sockfd, &rfds);
 633
 634                 if ((select(nfds, &rfds, 0, 0, 0) == -1) || (cmdClose = FD_ISSET(cmdfd, &rfds)))
 635                         goto leave;
 636
 637                 if (!FD_ISSET(sockfd, &rfds))
 638                         continue;
 639
 640                 packet = (OSC_Packet*)malloc(sizeof(OSC_Packet));
 641                 if (!packet) goto leave;
 642
 643                 packet->mData = 0;
 644
 645                 size = recvall(sockfd, &msglen, sizeof(int32));
 646                 if (size < (int32)sizeof(int32)) goto leave;
 647
 648                 // msglen is in network byte order
 649                 msglen = ntohl(msglen);
 650
 651                 packet->mData = (char*)malloc(msglen);
 652                 if (!packet->mData) goto leave;
 653
 654                 size = recvall(sockfd, packet->mData, msglen);
 655                 if (size < msglen) goto leave;
 656
 657                 memcpy(&packet->mReplyAddr.mSockAddr, &mReplySockAddr, sizeof(mReplySockAddr));
 658                 packet->mReplyAddr.mSockAddrLen = sizeof(mReplySockAddr);
 659                 packet->mReplyAddr.mSocket = sockfd;
 660                 packet->mReplyAddr.mReplyFunc = tcp_reply_func;
 661                 packet->mSize = msglen;
 662                 ProcessOSCPacket(packet, mPortNum);
 663
 664                 packet = 0;
 665         }
 666
 667 leave:
 668         if (packet) {
 669                 free(packet->mData);
 670                 free(packet);
 671         }
 672         // Only call notify function when not closed explicitly
 673         if (!cmdClose && mClientNotifyFunc) {
 674                 (*mClientNotifyFunc)(mClientData);
 675         }
 676         delete this;
 677     return 0;
 678 }
 679
 680 void SC_TcpClientPort::Close()
 681 {
 682         char cmd = 0;
 683 #ifdef SC_WIN32
 684         win32_pipewrite(mCmdFifo[1], &cmd, sizeof(cmd));
 685 #else
 686         size_t written = write(mCmdFifo[1], &cmd, sizeof(cmd));
 687         if (written != sizeof(cmd))
 688                 post("warning: invalid write in SC_TcpClientPort::Close");
 689 #endif
 690 }
 691
 692 ReplyFunc SC_TcpClientPort::GetReplyFunc()
 693 {
 694         return tcp_reply_func;
 695 }
 696
 697 //////////////////////////////////////////////////////////////////////////////////////////////////////////
 698
 699 int recvall(int socket, void *msg, size_t len)
 700 {
 701         size_t total = 0;
 702         while (total < len)
 703         {
 704 #ifdef SC_WIN32
 705     int numbytes = recv(socket, reinterpret_cast<char*>(msg), len - total, 0);
 706 #else
 707     int numbytes = recv(socket, msg, len - total, 0);
 708 #endif
 709                 if (numbytes <= 0) return total;
 710                 total += numbytes;
 711                 msg = (void*)((char*)msg + numbytes);
 712         }
 713         return total;
 714 }
 715
 716 int recvallfrom(int socket, void *msg, size_t len, struct sockaddr *fromaddr, int addrlen)
 717 {
 718         size_t total = 0;
 719         while (total < len)
 720         {
 721                 socklen_t addrlen2 = addrlen;
 722 #ifdef SC_WIN32
 723                 int numbytes = recvfrom(socket, reinterpret_cast<char*>(msg), len - total, 0, fromaddr, &addrlen2);
 724 #else
 725                 int numbytes = recvfrom(socket, msg, len - total, 0, fromaddr, &addrlen2);
 726 #endif
 727                 if (numbytes < 0) return total;
 728                 total += numbytes;
 729                 msg = (void*)((char*)msg + numbytes);
 730         }
 731         return total;
 732 }
 733
 734 int sendallto(int socket, const void *msg, size_t len, struct sockaddr *toaddr, int addrlen)
 735 {
 736         size_t total = 0;
 737         while (total < len)
 738         {
 739 #ifdef SC_WIN32
 740                 int numbytes = sendto(socket, reinterpret_cast<const char*>(msg), len - total, 0, toaddr, addrlen);
 741 #else
 742                 int numbytes = sendto(socket, msg, len - total, 0, toaddr, addrlen);
 743 #endif
 744                 //printf("numbytes %d  total %d  len %d\n", numbytes, total, len);
 745                 if (numbytes < 0) {
 746                         printf("******* errno %d %s\n", errno, strerror(errno));
 747                         return total;
 748                 }
 749                 total += numbytes;
 750                 msg = (void*)((char*)msg + numbytes);
 751         }
 752         return total;
 753 }
 754
 755 int sendall(int socket, const void *msg, size_t len)
 756 {
 757         size_t total = 0;
 758         while (total < len)
 759         {
 760 #if HAVE_MSG_NOSIGNAL
 761                 int flags = MSG_NOSIGNAL;
 762 #else
 763                 int flags = 0;
 764 #endif // HAVE_MSG_NOSIGNAL
 765 #ifdef SC_WIN32
 766     int numbytes = send(socket, reinterpret_cast<const char*>(msg), len - total, flags);
 767 #else
 768                 int numbytes = send(socket, msg, len - total, flags);
 769 #endif
 770                 if (numbytes < 0) return total;
 771                 total += numbytes;
 772                 msg = (void*)((char*)msg + numbytes);
 773         }
 774         return total;
 775 }
 776
 777 //////////////////////////////////////////////////////////////////////////////////////////////////////////
 778