int rcsRecv (int sockfd, void * buf, int len) {
    cout << "*****receiving on " << sockets[sockfd].sockfd << endl;
	sendbase = recvbase = 0;
	vector<RCSPacket> packets;
	unsigned short numpackets = 1;
	int result = 0;
    ucpSetSockRecvTimeout(sockets[sockfd].sockfd, NULL);
    RCSPacket rcvpacket, sendpacket;
    for (int i = 0; i < numpackets; ++i) {
        while(true){
            memset(&rcvpacket, 0, sizeof(rcvpacket));
            result = ucpRecvFrom(sockets[sockfd].sockfd, &rcvpacket, sizeof(rcvpacket), sockets[sockfd].addr);
            cout << "rcvd [" << rcvpacket.seq << "]: " << rcvpacket.data << " - corrupt: " << isCorrupt(rcvpacket) << endl;

            memset(&sendpacket, 0, sizeof(rcvpacket));
            sendpacket.ack = true;
            if (isCorrupt(rcvpacket) || rcvpacket.seq != i) {
                sendpacket.seq = i-1;
                sendpacket.checksum = computeChecksum((unsigned char*)&sendpacket, sizeof(sendpacket));
                result = ucpSendTo(sockets.at(sockfd).sockfd, &sendpacket, sizeof(sendpacket), sockets.at(sockfd).addr);
            } else {
                sendpacket.seq = i;
                sendpacket.checksum = computeChecksum((unsigned char*)&sendpacket, sizeof(sendpacket));
                result = ucpSendTo(sockets.at(sockfd).sockfd, &sendpacket, sizeof(sendpacket), sockets.at(sockfd).addr);
                break;
            }
        }

		numpackets = rcvpacket.numpackets;
        packets.push_back(rcvpacket);
		//insertPacket(&packets, &packet);
	}

	int length = len;
    int ret = 0;
	for (int i=0; i < (int)packets.size(); i++) {
        ret += sizeof(packets.at(i));
        memcpy((char*)buf + (len - length), packets.at(i).data, min(PACKET_SIZE, length));
        length -= PACKET_SIZE;
	}
	cout << "*****RECEIVED " << ret << " bytes: " << (char*)buf << endl;
	return ret;
}

int rcsSend (int sockfd, const void * buf, int len) {

    cout << "*****sending " << (char*) buf << " to " << sockets[sockfd].sockfd << endl;

	char * buffer = (char *) buf;
	vector<RCSPacket> packets;
	int length = len;
    int ret = 0;

	//cout<<"Buffer size is "<<len
	int numpackets = ceil(((double)len) / (double)PACKET_SIZE);
	for (int i = 0; i < numpackets; ++i) {
	    // Take care of case when last packet isn't PACKET_SIZE
	    int size = min(PACKET_SIZE, length);
	    length -= size;

	    // Create the packet
	    RCSPacket p;
	    memset(&p, 0, sizeof(p));
	    p.sockfd = sockfd;
	    p.seq = i;
        p.numpackets = numpackets;
	    memcpy(p.data, &buffer[i*PACKET_SIZE], size);
        //cout << p.data << " : " << size << endl;
        ret += sizeof(p);
	    packets.push_back(p);
	}

    ucpSetSockRecvTimeout(sockets[sockfd].sockfd, 100);

    cout << "packet size: " << packets.size() << endl;
    int result = 0;
    for (int i = 0; i < (int)packets.size(); ++i) {

        RCSPacket sendpacket, rcvpacket;
        sendpacket = packets.at(i);

        sendpacket.checksum = computeChecksum((unsigned char *)&sendpacket, sizeof(sendpacket));
        cout << "fork sending [" << sendpacket.seq << "]: " << sendpacket.data << endl;

        do {
            // Send the message
            result = ucpSendTo(sockets[sockfd].sockfd, &sendpacket, sizeof(sendpacket), sockets.at(sockfd).addr);
            // rcsRecv needs timeout then....
            result = ucpRecvFrom(sockets.at(sockfd).sockfd, &rcvpacket, sizeof(rcvpacket), NULL);
        } while (result == -1 || isCorrupt(rcvpacket) || !rcvpacket.ack || rcvpacket.seq != sendpacket.seq);
	}
	cout << "*****SENT " << ret << " bytes: " << (char*)buf << endl;
    return ret;
}