void WsEncoder::computeLength()
{
_totalLen = 0;
// System json.
auto sysJsonPtr = _currPkt->getSysJson();
if (sysJsonPtr)
{
_sysJsonStr = sysJsonPtr->toString();
_totalLen += getDataLen(_sysJsonStr.size());
}
else
{
_sysJsonStr.clear();
}
// User's json.
auto jsonPtr = _currPkt->getJson();
if (jsonPtr)
{
_jsonStr = jsonPtr->toString();
_totalLen += getDataLen(_jsonStr.size());
}
else
{
_jsonStr.clear();
}
// Binary.
_totalLen += getDataLen(_currPkt->getBinary().size());
computeComponentLen(_totalLen);
}
virtual size_t size() const {
if (UNLIKELY(getDataLen() != 0))
return getDataLen() + 16;
size_t total = 4 + 4 + 4;
if (server_flag != TAIR_SERVERFLAG_CLIENT)
total += 4 + 8 + 4;
key_code_map_t::iterator it;
if (nsuccess > 0) {
assert(success_key_value_map != NULL);
it = success_key_value_map->begin();
while (it != success_key_value_map->end()) {
total += it->first->encoded_size() + 4;
++it;
}
}
total += 4;
if (nfailed > 0) {
assert(failed_key_code_map != NULL);
it = failed_key_code_map->begin();
while (it != failed_key_code_map->end()) {
total += it->first->encoded_size() + 4;
++it;
}
}
return total + 16; //header 16 bytes
}
virtual size_t size() const {
if (LIKELY(getDataLen() != 0))
return getDataLen() + 16; // header 16 bytes
size_t total = 1 + 2 + 4;
if (key != NULL) {
total += key->encoded_size();
}
return total + 16; // header 16 bytes
}
//AutoreleasePool pool;
bool ImageAlphaLut::initWithImage(std::string file)
{
file = FileUtils::getInstance()->fullPathForFilename(file);
auto na = file.substr(file.find_last_of("/") + 1);
_name = (char *)malloc(na.length() + 1);
strcpy(_name, na.c_str());
auto img = new Image();
CCASSERT(img->initWithImageFile(file), "Init image fail");
auto lengh = img->getDataLen();
CCASSERT(lengh >= 8, "NO image data");
_width = img->getWidth();
_height = img->getHeight();
auto data = img->getData();
// 初始化 BUFF
resetBuffer();
// 提取图片透明信息
for (int i = 0 ; i < _width * _height; ++i)
{
if (data[i*4+3] )
{
setPixelAlpha(i);
}
}
CC_SAFE_RELEASE(img);
return true;
}
int RawDataEncoder::packetNum() {
if (m_packetNum < 0) {
int datasize = getDataLen();
m_packetNum = 1 + datasize/UNIT_DATA_SIZE + ((datasize%UNIT_DATA_SIZE)? 1: 0);
}
return m_packetNum;
}
TestObject* TestObject::copy() {
int data_len = getDataLen();
char* data = (char*)malloc(sizeof(char) * (data_len+1));
memcpy(data, getData(), data_len);
data[data_len] = '\0';
return new TestObject(data, data_len);
}
virtual size_t size() const {
if (LIKELY(getDataLen() != 0))
return getDataLen() + 16;
size_t total = 1 + 2 + 4;
if (key_count != 0) {
total += pkey->encoded_size();
key_counter_map_t::const_iterator it = key_counter_map->begin();
while (it != key_counter_map->end()) {
total += it->first->encoded_size();
total += it->second->encoded_size();
++it;
}
}
if (server_flag != TAIR_SERVERFLAG_CLIENT)
total += 4;
return total + 16; //header 16 bytes
}
//@override
virtual size_t size() const {
if (LIKELY(getDataLen() != 0))
return getDataLen() + 16;
size_t total = 1 + 2 + 4;
if (pkey != NULL)
total += pkey->encoded_size();
if (kvmap != NULL) {
tair_keyvalue_map::iterator itr = kvmap->begin();
while (itr != kvmap->end()) {
total += itr->first->encoded_size();
total += itr->second->encoded_size();
++itr;
}
}
if (server_flag != TAIR_SERVERFLAG_CLIENT)
total += 4;
return total + 16; //header 16 bytes
}
char *RawDataEncoder::encode(int seq, int &sz)
{
char *p = m_buf;
{
int n;
char *h = getHeader(seq, n);
memcpy(p, h, n);
p += n;
}
if (seq == 0) {
int n;
char *pp = getDataHeader(n);
memcpy(p, pp, n);
p += n;
} else {
// Image data
int N = packetNum();
int datalen = 0;
if (seq + 1 < N) {
datalen = UNIT_DATA_SIZE;
} else { // last packet
int datasize = getDataLen();
int left = datasize % UNIT_DATA_SIZE;
datalen = left != 0? left: UNIT_DATA_SIZE;
}
BINARY_SET_DATA_S_INCR(p, unsigned short, datalen);
char *data = getData();
char *pp = data + UNIT_DATA_SIZE*(seq-1);
memcpy(p, pp, datalen);
p += datalen;
}
{
int n;
char *f = getFooter(n);
memcpy(p, f, n);
p += n;
}
sz = p - m_buf;
setPacketSize(m_buf, sz);
return m_buf;
}
/*
** 拓展数据空间
*/
void Buffer::expand(int need)
{
if (head == NULL) {
tail = data = head = (unsigned char*)malloc(need);
end = head + need;
} else if (getFreeLen() < need) { // 空间不够
unsigned char* newbuf = NULL;
int hl = getHeadLen();
int dl = getDataLen();
int sl = getSize();
int bufsize = std::max(sl , need) * 2;
newbuf = (unsigned char*)malloc(bufsize);
assert(newbuf);
memcpy(newbuf , head, sl);
free(head);
head = newbuf;
data = hl + head;
tail = data + dl;
end = head + bufsize;
}
}
void USART1_IRQHandler(void) //串口1中断服务程序
{
uint8_t Res;
if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET) //接收中断(接收寄存器满中断)
{
Res =USART_ReceiveData(USART1);//(USART1->DR); //读取接收到的数据
if(Res<=0x14 && Res >0)
{
Dac1_Set_Vol(R[Res - 0x01]); //设定DAC值;
}
else if(Res>0x20 && Res<=0x34)
{
Dac2_Set_Vol(R[Res - 0x21]); //设定DAC值;
}
else if (Res==0)
{
Dac1_Set_Vol(0); //关闭DAC1
}
else if (Res==0x20)
{
Dac2_Set_Vol(0); //关闭DAC2
}
/* 以下报文方法废弃，但保留下来 */
// switch (Res)
// {
// case 'M' :
// DacChannel = 1; //DAC1数据
// DacValue = 0;
// break;
// case 'N' :
// DacChannel = 2; //DAC2数据
// DacValue = 0;
// break;
// default: //处理数据组
// if(BitCounter < 4 ) //正在接收
// {
// DacStack[BitCounter] = Res;
// BitCounter++; //下标自减
// }
// else
// { //数据接收完成
// BitCounter = 0;
// DacValue = DacStack[0]<<12 + DacStack[1]<<8 + DacStack[2]<<4 + DacStack[3];
// switch (DacChannel) //判断通道几的数据
// {
// case 1 :
// Dac1_Set_Vol(DacValue); //设定DAC值
// break;
// case 2 :
// Dac2_Set_Vol(DacValue); //设定DAC值
// break;
// default:
// break;
// }
// }
// break;
// }
}
if(USART_GetITStatus(USART1, USART_IT_TXE) != RESET) //发送中断(发送寄存器空中断)
{
if(loopCount < getDataLen()) //正在发送
{
send16B(SendData0, SendData1, loopCount);
loopCount++;
}
else //发送完成
{
USART_ITConfig(USART1, USART_IT_TXE, DISABLE);
loopCount = 0;
//DataStack0[StackCursor0] = getTIM2Period(); //低频测量方法
DataStack0[StackCursor0] = getTIM2Frequency(); //高频测量方法
SendData0 = pretreatment0(); //预处理
//DataStack1[StackCursor1] = getTIM3Period();
DataStack1[StackCursor1] = getTIM3Frequency(); //高频测量方法
SendData1 = pretreatment1(); //预处理
}
}
}
int main(int argc, char *argv[])
{
double probLoss, probCorruption;
int sockfd, newsockfd, portno, pid, CWnd;
socklen_t clilen;
struct sockaddr_in serv_addr, cli_addr;
struct Header packetHeader;
struct sigaction sa;
time_t t;
srand((unsigned)time(&t));
if (argc < 5) {
fprintf(stderr, "ERROR, missing argument\n");
exit(1);
}
CWnd = atoi(argv[2]);
probLoss = atoi(argv[3]);
probCorruption = atoi(argv[4]);
sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if (sockfd < 0)
error("ERROR opening socket");
memset(&serv_addr, 0, sizeof(serv_addr));
portno = atoi(argv[1]);
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = INADDR_ANY;
serv_addr.sin_port = htons(portno);
if (bind(sockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0)
error("ERROR on binding");
int n, loss = 0, corruption = 0, base = 0, nextSeqnum = 0, seq = 0,
ack = 0, numUnacked = 0, i, j, k, len, cumAck, sizeCliAddr;
char buffer[1024];
char packetBuffer[packetBufferSize][maxPacketSize + 1];
int nxtPtr = 0, nxtFree = 0, count = 0;
char unacked[CWnd][maxPacketSize + 1];
struct Header recvAck, data;
char filename[1024];
FILE * fp;
char packet[maxPacketSize + 1];
int cur;
//col 1: 0 unacked, 1 acked or unused
//col 2: window seq num
//col 3: expected ack
int window[CWnd][3];
memset(packet, 0, sizeof(packet));
for (i = 0; i < CWnd; i++)
{
window[i][0] = 1;
window[i][1] = 0;
window[i][2] = 0;
}
memset((struct sigaction *) &sa, 0, sizeof(sa));
sa.sa_handler = setTimeout;
sa.sa_flags = SA_SIGINFO;
sigaction(SIGALRM, &sa, NULL);
//eventually, it seems here that the loop eventually stops sending
//packets to the receiver and the receiver is just left hanging...
while (1)
{
memset(buffer, 0, 1024);
// read if timeout has not occured
if (timeout != 1)
{
sizeCliAddr = sizeof(cli_addr);
n = recvfrom(sockfd, buffer, sizeof(buffer), 0,
(struct sockaddr *) &cli_addr, &sizeCliAddr);
}
else errno = EINTR;
if (errno == EINTR)
{
if (timeout == 1)
{
timeout = 0;
k = base + CWnd;
for (i = base; i < k; i++)
for (j = 0; j < CWnd; j++)
if (window[j][0] == 0 && window[j][1] == i)
{
n = sendto(sockfd, unacked[j], sizeof(unacked[j]), 0,
(struct sockaddr *) &cli_addr, sizeof(cli_addr));
if (n < 0)
error("ERROR reading from socket");
printf("\nPacket Sent: \n");
printPacket(unacked[j]);
break;
}
alarm(dur);
errno = 0;
continue;
}
else
error("ERROR reading from socket");
}
else if (n < 0)
error("ERROR reading from socket");
// if no loss or corruption
loss = isHit(probLoss);
corruption = isHit(probCorruption);
if (loss != 1 && corruption != 1)
{
// if client asks for file
if (getDataLen(buffer) > 0)
{
//eventually, this block of code never gets called but there are still text left to transmit...a mystery...
printPacket(buffer);
memset(filename, 0, 1024);
getFileName(buffer, filename);
printf("File Requested: %s\n", filename);
fp = fopen(filename, "r");
if (fp == NULL)
error("Failed to open file");
cur = fgetc(fp);
len = 0;
data.srcPort = ntohs(serv_addr.sin_port);
data.destPort = ntohs(cli_addr.sin_port);
data.ack = 0;
data.flag = 0;
i = headerLen;
while (1)
{
if (len < maxPacketSize - headerLen && cur != EOF)
{
packet[i] = (char)cur;
cur = fgetc(fp);
len++;
i++;
}
if (len == maxPacketSize - headerLen || cur == EOF)
{
data.seq = seq;
data.dataLen = (short)len;
data.checkSum = (short)1;
if (cur == EOF)
data.flag = 1;
memcpy(packet, (struct Header *) &data, headerLen);
if (nextSeqnum < base + CWnd)
{
for (i = 0; i < CWnd; i++)
if (window[i][0] == 1)
{
window[i][0] = 0;
window[i][1] = nextSeqnum;
window[i][2] = ack + len;
n = sendto(sockfd, packet, sizeof(packet), 0,
(struct sockaddr *) &cli_addr, sizeof(cli_addr));
if (n < 0)
error("ERROR writing to socket");
if (nextSeqnum == base)
alarm(dur);
printf("\nPacket sent:\n");
printPacket(packet);
memcpy(&unacked[i][0], &packet[0], sizeof(packet));
seq += len;
ack += len;
i = headerLen;
len = 0;
nextSeqnum++;
break;
}
}
else
{
memcpy(packetBuffer[nxtFree], packet,
maxPacketSize);
nxtFree++;
count++;
//adding this helped a bit but not entirely if the file is very large
seq += len;
ack += len;
len = 0;
i = headerLen;
}
memset(packet, 0, sizeof(packet));
if (cur == EOF)
{
data.flag = 0;
break;
}
}
}
fclose(fp);
fileRequest = 0;
}
// if client sends ACK
else
{
//this isn't run until all the packets have been sent in the first window
//that is, if the CWnd is 10, then nextSeqnum only goes up until 10 and then
//the packets go into packetBuffer
//the packets in packetBuffer, after all the first set of packets are sent, are now being sent
//but what happens after the packets in packetBuffer are all sent?
printf("\nPacket Received:\n");
printPacket(buffer);
cumAck = getAck(buffer);
j = 0;
for (i = 0; i < CWnd; i++)
{
if (window[i][1] >= base && cumAck >= window[i][2] &&
window[i][0] == 0)
{
j++;
window[i][0] = 1;
if (window[i][1] == base)
alarm(dur);
if (count > 0)
{
count--;
//printf("Sending in the other else branch.\n");
n = sendto(sockfd, packetBuffer[nxtPtr],
sizeof(packetBuffer[nxtPtr]), 0,
(struct sockaddr *) &cli_addr, sizeof(cli_addr));
if (n < 0)
error("ERROR writing to socket");
printPacket(packetBuffer[nxtPtr]);
nxtPtr = (nxtPtr + 1) % packetBufferSize;
nxtFree = (nxtFree + 1) % packetBufferSize;
// TODO: add stuff regarding window
}
}
}
base += j;
}
}
// if loss or corruption do nothing
else
{
if (loss == 1 && corruption == 0)
printf("Packet Lost:\n");
else if (corruption == 1 && loss == 0)
printf("Packet Corrupted:\n");
else printf("Packet Corrupted and Lost:\n");
loss = 0;
corruption = 0;
printPacket(buffer);
}
}
close(sockfd);
return 0;
}
