Example #1
0
void* SC_TcpConnectionPort::Run()
{
	OSC_Packet *packet = 0;
	// wait for login message
	int32 size;
	int32 msglen;

	while (true) {
		if (!packet) {
			packet = (OSC_Packet*)malloc(sizeof(OSC_Packet));
		}
		size = recvall(mSocket, &msglen, sizeof(int32));
		if (size < 0) goto leave;

		// sk: msglen is in network byte order
		msglen = ntohl(msglen);

		char *data = (char*)malloc(msglen);
		size = recvall(mSocket, data, msglen);
		if (size < msglen) goto leave;

		packet->mReplyAddr.mReplyFunc = tcp_reply_func;
		packet->mSize = msglen;
		packet->mData = data;
		packet->mReplyAddr.mSocket = mSocket;
		ProcessOSCPacket(packet);
		packet = 0;
	}
leave:
    delete this; // ohh this could cause a crash if a reply tries to access it..
    return 0;
}
Example #2
0
void* SC_UdpInPort::Run()
{
	char buf[kTextBufSize];
	OSC_Packet *packet = 0;

	//printf("SC_UdpInPort::Run\n"); fflush(stdout);

	while (true) {
		if (!packet) {
			packet = (OSC_Packet*)malloc(sizeof(OSC_Packet));
		}
		packet->mReplyAddr.mSockAddrLen = sizeof(sockaddr_in);
		int size = recvfrom(mSocket, buf, kTextBufSize , 0,
								(struct sockaddr *) &packet->mReplyAddr.mSockAddr, (socklen_t*)&packet->mReplyAddr.mSockAddrLen);

		if (size > 0) {
			//dumpOSC(3, size, buf);
			//fflush(stdout);

			char *data = (char*)malloc(size);
			packet->mReplyAddr.mReplyFunc = udp_reply_func;
			packet->mSize = size;
			packet->mData = data;
			packet->mReplyAddr.mSocket = mSocket;
			memcpy(data, buf, size);
			ProcessOSCPacket(packet);
			packet = 0;
		}
	}
	return 0;
}
Example #3
0
void* SC_UdpCustomInPort::Run()
{
	OSC_Packet *packet = 0;

	const int fd = mSocket;
	const int max_fd = fd+1;

	mRunning.store(true);
	while (mRunning.load(boost::memory_order_consume)) {
		fd_set rfds;

		FD_ZERO(   &rfds);
		FD_SET(fd, &rfds);

		struct timeval timeout;
		timeout.tv_sec = 0;
		timeout.tv_usec = 500000;

		int n = select(max_fd, &rfds, 0, 0, &timeout);
		if ((n > 0) && FD_ISSET(fd, &rfds)) {
			if (!packet) {
				packet = (OSC_Packet*)malloc(sizeof(OSC_Packet));
			}
			packet->mReplyAddr.mSockAddrLen = sizeof(sockaddr_in);
			int size = recvfrom(mSocket, buf, kTextBufSize , 0,
								(struct sockaddr *) &packet->mReplyAddr.mSockAddr, (socklen_t*)&packet->mReplyAddr.mSockAddrLen);

			if (size > 0 && mRunning.load(boost::memory_order_consume)) {
				//dumpOSC(3, size, buf);
				//fflush(stdout);

				char *data = (char*)malloc(size);
				packet->mReplyAddr.mReplyFunc = udp_reply_func;
				packet->mSize = size;
				packet->mData = data;
				packet->mReplyAddr.mSocket = mSocket;
				memcpy(data, buf, size);
				ProcessOSCPacket(packet, mPortNum);
				packet = 0;
			}
		}
	}
	FreeOSCPacket(packet); // just in case
	return 0;
}
Example #4
0
SC_DLLEXPORT_C bool World_SendPacketWithContext(World *inWorld, int inSize, char *inData, ReplyFunc inFunc, void *inContext)
{
	bool result = false;
	if (inSize > 0) {
		if (inWorld->mDumpOSC) dumpOSC(inWorld->mDumpOSC, inSize, inData);

		OSC_Packet* packet = (OSC_Packet*)malloc(sizeof(OSC_Packet));
		char *data = (char*)malloc(inSize);
		packet->mReplyAddr.mSockAddr.sin_addr.s_addr = 0;
		packet->mReplyAddr.mSockAddr.sin_port = 0;
		packet->mReplyAddr.mReplyFunc = inFunc;
		packet->mReplyAddr.mReplyData = inContext;
		packet->mSize = inSize;
		packet->mData = data;
		packet->mReplyAddr.mSocket = 0;
		memcpy(data, inData, inSize);

		result = ProcessOSCPacket(inWorld, packet);
	}
	return result;
}
void* SC_UdpInPort::Run()
{
	OSC_Packet *packet = 0;
	while (true) {
		if (!packet) {
			// preallocate packet before we need it.
			packet = (OSC_Packet*)malloc(sizeof(OSC_Packet));
		}

		packet->mReplyAddr.mSockAddrLen = sizeof(sockaddr_in);
#ifdef _WIN32
		int size = recvfrom(mSocket, (char *)mReadBuf, kMaxUDPSize , 0,
#else
		int size = recvfrom(mSocket, mReadBuf, kMaxUDPSize , 0,
#endif
								(struct sockaddr *) &packet->mReplyAddr.mSockAddr, (socklen_t*)&packet->mReplyAddr.mSockAddrLen);

		if (size > 0) {
			char *data = (char*)malloc(size);
			memcpy(data, mReadBuf, size);
			if (mWorld->mDumpOSC) dumpOSC(mWorld->mDumpOSC, size, data);

			packet->mReplyAddr.mReplyFunc = udp_reply_func;
			packet->mReplyAddr.mReplyData = 0;
			packet->mSize = size;
			packet->mData = data;
			packet->mReplyAddr.mSocket = mSocket;

			if (!ProcessOSCPacket(mWorld, packet))
			{
				scprintf("command FIFO full\n");
				free(data);
				free(packet);
			}
			packet = 0;
			data = 0;
		}
	}
	return 0;
}
CFDataRef SC_MachMessagePort::messagePortCallBack(CFMessagePortRef local, SInt32 msgid, CFDataRef data, void *info)
{
    // CFShow(data);
    SC_MachMessagePort *port = (SC_MachMessagePort *) info;
    OSC_Packet* packet = (OSC_Packet *) malloc(sizeof(OSC_Packet));
    bzero(&packet->mReplyAddr, sizeof(ReplyAddress));
    packet->mReplyAddr.mReplyFunc = port->mReplyPort ? mach_reply_func : null_reply_func;
	packet->mReplyAddr.mReplyData = 0;
    packet->mReplyAddr.mSocket = (int)(int64)port->mReplyPort;
    packet->mSize = CFDataGetLength(data);
    packet->mData = (char*) memcpy(malloc(packet->mSize), CFDataGetBytePtr(data), packet->mSize);

    World *world = port->mWorld;
    if (world->mDumpOSC) dumpOSC(world->mDumpOSC, packet->mSize, packet->mData);

    if (!ProcessOSCPacket(world, packet)) {
        scprintf("command FIFO full\n");
        free(packet->mData);
        free(packet);
    }

    // how can we send a reply? we could block here until the message is processed...
    return NULL;
}
Example #7
0
void* SC_TcpClientPort::Run()
{
	OSC_Packet *packet = 0;
	int32 size;
	int32 msglen;

	int cmdfd = mCmdFifo[0];
	int sockfd = mSocket;
	int nfds = sc_max(cmdfd, sockfd) + 1;

	bool cmdClose = false;

	pthread_detach(mThread);

	while (true) {
		fd_set rfds;
		FD_ZERO(&rfds);
		FD_SET(cmdfd, &rfds);
		FD_SET(sockfd, &rfds);

		if ((select(nfds, &rfds, 0, 0, 0) == -1) || (cmdClose = FD_ISSET(cmdfd, &rfds)))
			goto leave;

		if (!FD_ISSET(sockfd, &rfds))
			continue;

		packet = (OSC_Packet*)malloc(sizeof(OSC_Packet));
		if (!packet) goto leave;

		packet->mData = 0;

		size = recvall(sockfd, &msglen, sizeof(int32));
		if (size < (int32)sizeof(int32)) goto leave;

		// msglen is in network byte order
		msglen = ntohl(msglen);

		packet->mData = (char*)malloc(msglen);
		if (!packet->mData) goto leave;

		size = recvall(sockfd, packet->mData, msglen);
		if (size < msglen) goto leave;

		memcpy(&packet->mReplyAddr.mSockAddr, &mReplySockAddr, sizeof(mReplySockAddr));
		packet->mReplyAddr.mSockAddrLen = sizeof(mReplySockAddr);
		packet->mReplyAddr.mSocket = sockfd;
		packet->mReplyAddr.mReplyFunc = tcp_reply_func;
		packet->mSize = msglen;
		ProcessOSCPacket(packet);

		packet = 0;
	}

leave:
	if (packet) {
		free(packet->mData);
		free(packet);
	}
	// Only call notify function when not closed explicitly
	if (!cmdClose && mClientNotifyFunc) {
		(*mClientNotifyFunc)(mClientData);
	}
	delete this;
    return 0;
}
void* SC_TcpConnectionPort::Run()
{
	const int kMaxPasswordLen = 32;
	char buf[kMaxPasswordLen];
	OSC_Packet *packet = 0;
	// wait for login message
	int32 size;
	int32 msglen;

	// first message must be the password. 4 tries.
	bool validated = mWorld->hw->mPassword[0] == 0;
	for (int i=0; !validated && i<4; ++i) {
		size = recvall(mSocket, &msglen, sizeof(int32) );
		if (size < 0) goto leave;

		msglen = ntohl(msglen);
		if (msglen > kMaxPasswordLen) break;

		size = recvall(mSocket, buf, msglen);
		if (size < 0) goto leave;

		validated = strcmp(buf, mWorld->hw->mPassword) == 0;
#ifdef _WIN32
		if (!validated) Sleep(i+1);	// thwart cracking.
#else
		if (!validated) sleep(i+1);	// thwart cracking.
#endif
	}

	if (validated) {
		while (true) {
			if (!packet) {
				packet = (OSC_Packet*)malloc(sizeof(OSC_Packet));
			}
			size = recvall(mSocket, &msglen, sizeof(int32));
			if (size != sizeof(int32)) goto leave;

			// sk: msglen is in network byte order
			msglen = ntohl(msglen);

			char *data = (char*)malloc(msglen);
			size = recvall(mSocket, data, msglen);
			if (size < msglen) goto leave;

			if (mWorld->mDumpOSC) dumpOSC(mWorld->mDumpOSC, size, data);

			packet->mReplyAddr.mReplyFunc = tcp_reply_func;
			packet->mReplyAddr.mReplyData = 0;
			packet->mSize = msglen;
			packet->mData = data;
			packet->mReplyAddr.mSocket = mSocket;
			if (!ProcessOSCPacket(mWorld, packet)) {
				scprintf("command FIFO full\n");
				free(data);
				free(packet);
			}
			packet = 0;
		}
	}
leave:
    delete this; // ohh this could cause a crash if a reply tries to access it..
    return 0;
}