// Draws a box and fills it in with the given color
void drawBoxFill(char x, char y, char height, char width, int color) {
    char Hig = 0;
    char Low = color & 0x00ff;
    int i = 0;
    int j = 0;
    Hig = color >> 8;

    sendcomand(ST7735_CASET); // Column addr set
    senddata(0x00);
    senddata(x); // XSTART
    senddata(0x00);
    senddata(x + width); // XEND

    sendcomand(ST7735_RASET); // Row addr set
    senddata(0x00);
    senddata(y); // YSTART
    senddata(0x00);
    senddata(y + height); // YEND

    sendcomand(ST7735_RAMWR);

    for (j = 0; j <= width; j++) {
        for (i = 0; i <= height; i++) {
            senddata(Low);
            senddata(Hig);
        }
    }
}

bool DVR::updateChannels()
{
	TDVRPacket pk;
	int res;
	
	pk.setCmd(0x11);
	pk.setExtLen(16);
	
	for (size_t i = 0; i < m_conns.size(); i++)
		pk.raw[8 + m_conns[i].channel] = 1; // 1-yes, 0-no
		
	res = senddata(m_controlFd, pk.raw, 32);
	if (res == -1)
	{
		setError(ConnectionError, getErrorText("unable to send channel start packet"));
		return false;
	}
	uint8_t extdata[16];
	memset(extdata, 0, 16);
	
	// if 1, only thumbnails are being sent
	for (size_t i = 0; i < m_conns.size(); i++)
		extdata[m_conns[i].channel] = 0;
		
	res = senddata(m_controlFd, extdata, 16);
	if (res == -1)
	{
		setError(ConnectionError, getErrorText("unable to send channel start extdata"));
		return false;
	}
	return true;
}

////////////////////////////////////////////////////
////////////////////////////////////////////////////
///////6 bytes each time before sending to the server to send all need////////////////
char send_head(char *cmd,unsigned int body_len)
{
    unsigned char body_len1;
    unsigned char body_len2;
    body_len1=body_len/256;
    body_len2=body_len%256;
    //Packg inpackg 6 byte;
    if ((sendbytes = senddata(ssl,sockfd,"00",sizeof("00")-1)) == -1)
    {
        perror("send head");
        exit(1);
    }//perror("send");
    if ((sendbytes = senddata(ssl,sockfd,cmd,strlen(cmd))) == -1)
    {
        perror("send");
        exit(1);
    }//perror("send cmd");
    //DEBUG_printf("sizeof(cmd)=%d\n",strlen(cmd));
    if ((sendbytes = senddata(ssl,sockfd,&body_len1, sizeof(char))) == -1)
    {
        perror("send");
        exit(1);
    }
    if ((sendbytes = senddata(ssl,sockfd,&body_len2, sizeof(char))) == -1)
    {
        perror("send");
        exit(1);
    }
    return 1;
}

/*DISPATCHER_UIPCALL(smtp_appcall, state)*/
void
smtp_appcall(void *state)
{
  if(uip_connected()) {
    /*    senddata();*/
    return;
  }
  if(uip_acked()) {
    acked();
  }
  if(uip_newdata()) {
    newdata();
  }
  if(uip_rexmit() ||
     uip_newdata() ||
     uip_acked()) {
    senddata();
  } else if(uip_poll()) {    
    senddata();
  }
  /*  if(uip_closed()) {
    printf("Dnoe\n");
    }*/


}

void* sock_consume(void *arg){ // NOTE: arg will be a pointer to the linked list of available sockets.
	int newsock = 0;
	linkedlist* socks = (linkedlist*)(arg);
	while(still_running){
		pthread_mutex_lock(socks->listlock);
		while((socks->tail)->socket == -1){
			pthread_cond_wait(socks->listempty, socks->listlock);
		}
		newsock = list_remove(&socks->head);
		pthread_mutex_unlock(socks->listlock);
		char* buffer = malloc(sizeof(char)*1024);
		if(getrequest(newsock,buffer,1024)==0){
			char* filename = malloc(sizeof(char)*strlen(buffer));
			if(buffer[0] == '/') {
				strcpy(filename, (const char*)(buffer + 1));
				printf("_%s_\n_%s_\n",buffer, filename);		
			} else{
				strcpy(filename, (const char*)(buffer));
			}			
			char * request = NULL; //What is going to be passed to sendata (either the 200 or 404)
			struct stat *finfo = malloc(sizeof(struct stat));
			if(0 == stat((const char*)filename, finfo)){
				int size = (int)(finfo->st_size);
				//Fill request with the HTTP header.
				char* header = malloc(sizeof(int)*(strlen(HTTP_200)));
				sprintf(header, HTTP_200, size);
				int reqsize = sizeof(int)*strlen(header) + size;
				request = malloc(reqsize);
				strcpy(request,(const char*) header);
				int reqpos = strlen(header);

				//Fill the rest of request with things from the file.
				int fdesc = open((const char*) filename, O_SYNC); 
				char* buf = malloc(sizeof(char)*1024);
				int moredata = read(fdesc, (void*)buf, 1024);
				for(; moredata>0; moredata = read(fdesc, (void*)buf, 1024)){
					strncpy(request+reqpos, (const char*) buf, moredata);
					reqpos+=moredata;
				}
				request[reqpos] = '\0';
				senddata(newsock, (const char*) request, reqsize);
				close(fdesc);
				free(header);
				
			}else{
				request = malloc(sizeof(char)*strlen(HTTP_404));
				strcpy(request, (const char*)(HTTP_404));
				senddata(newsock, (const char*) request, strlen(request));
				
			}
			//Do the logging of stuff to the file.			
			
			free(request);
			free(finfo);
			free(filename);
		}
		free(buffer);	
	}
	return NULL;
}

// Cleans the entire screen as a certain color
void clean(int color) {

    char Hig = 0;
    int x = 0;
    int y = 0;
    char Low = color & 0x00ff;
    color >>= 8;
    Hig = color;

    sendcomand(ST7735_CASET); // Column addr set
    senddata(0x00);
    senddata(0); // XSTART
    senddata(0x00);
    senddata(V); // XEND

    sendcomand(ST7735_RASET); // Row addr set
    senddata(0x00);
    senddata(0); // YSTART
    senddata(0x00);
    senddata(H); // YEND

    sendcomand(ST7735_RAMWR);

    for (x = 0; x < V; x++) {
        for (y = 0; y < H; y++) {
            senddata(Low);
            senddata(Hig);
        }
    }
}

int server::download(char *buf){
	char attnam[10],temp[10];
	char data[Max_buf-40];//读取附件
	char sendbuf[Max_buf];//待发送内容
	int i;
	FILE *fatta;
	i=0;
	sscanf(buf,"%s%s",temp,attnam);//获取附件名
	fatta=fopen(attnam,"r");
	if(fatta==NULL){
		//处理未找到
		strcpy_s(sendbuf,"Attach\n\0");
		strcat_s(sendbuf,"Not found!!!\n\0");
		senddata(sendbuf);
		return 0;
	}
	strcpy_s(sendbuf,"Contents\n\0");
	//strcat_s(sendbuf,attnam);
	//strcat_s(sendbuf,"\n\0");
	while (!feof(fatta))
		data[i++]=fgetc(fatta);
	//读取附件内容
	i--;
	data[i]='\0';
	fclose(fatta);
	strcat_s(sendbuf,data);
	senddata(sendbuf);

	return 0;
}

/*-----------------------------------------------------------------------------------*/
void
webclient_appcall(void)
{
  if(uip_connected()) {
    s.timer = 0;
    s.state = WEBCLIENT_STATE_STATUSLINE;
    senddata();
    webclient_connected();
    return;
  }

  if(s.state == WEBCLIENT_STATE_CLOSE) {
    webclient_closed();
    uip_abort();
    return;
  }

  if(uip_aborted()) {
    webclient_aborted();
  }
  if(uip_timedout()) {
    webclient_timedout();
  }

  
  if(uip_acked()) {
    s.timer = 0;
    acked();
  }
  if(uip_newdata()) {
    s.timer = 0;
    newdata();
  }
  if(uip_rexmit() ||
     uip_newdata() ||
     uip_acked()) {
    senddata();
  } else if(uip_poll()) {
    ++s.timer;
    if(s.timer == WEBCLIENT_TIMEOUT) {
      webclient_timedout();
      uip_abort();
      return;
    }
        /*    senddata();*/
  }

  if(uip_closed()) {
    if(s.httpflag != HTTPFLAG_MOVED) {
      /* Send NULL data to signal EOF. */
      webclient_datahandler(NULL, 0);
    } else {
      if(resolv_lookup(s.host) == NULL) {
	resolv_query(s.host);
      }
      webclient_get(s.host, s.port, s.file);
    }
  }
}

int mc_store(mcContext *c, const item_data *item, int need_response, const char *store_type) {
  int ret;
  char cmd[512] = {'\0'};
  u_char *data = item->_buffer ;
  size_t data_len = item->_size;

  if ((data_len > MCCLI_MAX_VALUESIZE) || (data_len <= 0)) {
    //value size overflowing
    return MEM_SYSTEM_ERROR;
  }
  //socket send/recv failed count over, reconnect
  if (c->maxsrtimes <= c->srtimes) {
    if (MCCLI_OK != mc_reconnect(c)) {
      //socket reconnect failed count over
      if (c->maxrctimes <= c->rctimes) {
        if (MCCLI_OK != changetoslv(c)) {
          //change mc-server failed, continue connect to old server
          return MEM_SYSTEM_ERROR;
        }
      }
    }
  }
  if (!(c->fd)) {
    return MEM_SYSTEM_ERROR;
  }

  if (need_response == 0) {
    sprintf(cmd, "%s %s %d %lu %lu noreply\r\n", store_type, item->_key, item->_flag, item->_expire, data_len);
  } else {
    sprintf(cmd, "%s %s %d %lu %lu\r\n", store_type, item->_key, item->_flag, item->_expire, data_len);
  }

  if (MCCLI_OK != senddata(c, cmd, (int)strlen(cmd))) {
    __mcErrorErrorno(c, "send cmd");
    return MEM_SYSTEM_ERROR;
  }

  if (MCCLI_OK != senddata(c, (char *)data, data_len)) {
    __mcErrorErrorno(c, "send datalen");
    return MEM_SYSTEM_ERROR;
  }

  if (MCCLI_OK != senddata(c, "\r\n", 2)) {
    __mcErrorErrorno(c, "send \\r\\n");
    return MEM_SYSTEM_ERROR;
  }

  if (need_response != 0) {
    ret = get_reply(c, 0);
  } else {
    ret = MEM_NO_RESPONSE;
  }

  return ret;
}

/******************************************************************************
* void exosite_appcall(void)
*
* This function is uIP's application function.  It is called whenever a uIP 
* event occurs (e.g. when a new connection is established, new data arrives, 
* sent data is acknowledged, data needs to be retransmitted, etc.).
* 
******************************************************************************/ 
void exosite_appcall(void)
{
  if(uip_connected()) {
    s.timer = 0;
    senddata();
    return;
  }

  if(s.state == EXO_STATE_CLOSE) {
    uip_abort();
    return;
  }
  
  if(uip_aborted()) {
  }
  if(uip_timedout()) {
  }

  if(uip_acked()) {
    s.timer = 0;
    acked();
  }

  if(uip_newdata()) {
    s.timer = 0;
    newdata();
  }
 
  if(uip_rexmit() || uip_newdata() || uip_acked()) {
    senddata();
  } else if(uip_poll()) {
    ++s.timer;
    if(s.timer == EXO_TIMEOUT) {
      uip_abort();
      return;
    }
  }
#if 0  
  if(uip_closed()) {
    if(s.httpflag != HTTPFLAG_MOVED) {
      memset(s.rxdata,0,sizeof(s.rxdata));
    } else {
      if(resolv_lookup(s.host) == NULL) {
	      resolv_query(s.host);
      }
    }
  }
#endif

}

static bool sendfile(int sock, long partition_id, FILE *f)
{
    fseek(f, 0, SEEK_END);
    long filesize = ftell(f);
    rewind(f);
    if (filesize == EOF)
        return false;
    if (!sendlong(sock, filesize))
        return false;
    if (!sendlong(sock, filesize))
        return false;
    if (filesize > 0)
    {
        char buffer[1024];
        do
        {
            size_t num = min(filesize, sizeof(buffer));
            num = fread(buffer, 1, num, f);
            if (num < 1)
                return false;
            if (!senddata(sock, buffer, num, 0))
                return false;
            filesize -= num;
        }
        while (filesize > 0);
    }
    return true;
}

int sendfile(int sock, FILE *f)
{
    // calculate file size
    fseek(f, 0, SEEK_END);
    long filesize = ftell(f);
    rewind(f);
    if (filesize == EOF)
        return 0;
    if (sendlong(sock, filesize) == 0)
        return 0;
    // send file using a buffer length of 1024 bytes
    if (filesize > 0)
    {
        char buffer[1024];
        do
        {
            size_t num = min(filesize, sizeof(buffer));
            num = fread(buffer, 1, num, f);
            if (num < 1)
                return 0;
            if (senddata(sock, buffer, num) == 0)
                return 0;
            filesize -= num;
        }
        while (filesize > 0);
    }
    return 1;
}    

/*---------------------------------------------------------------------------*/
void
telnetd_appcall(void *ts)
{
  if(uip_connected()) {
    tcp_markconn(uip_conn, &s);
    buf_init(&buf);
    s.bufptr = 0;
    s.state = STATE_NORMAL;
    shell_start();
  }

  if(s.state == STATE_CLOSE) {
    s.state = STATE_NORMAL;
    uip_close();
    return;
  }
  if(uip_closed() ||
     uip_aborted() ||
     uip_timedout()) {
    closed();
  }
  if(uip_acked()) {
    acked();
  }
  if(uip_newdata()) {
    newdata();
  }
  if(uip_rexmit() ||
     uip_newdata() ||
     uip_acked() ||
     uip_connected() ||
     uip_poll()) {
    senddata();
  }
}

void initkey()
{
	P1=0xFF;
	delay1ms(25);
	senddata(0xA4);
	cls=1;
}

int main(int argc, char** argv) {
    int socket;

    int rc;
    uint16_t msg_size = MAX_MSGSIZE;

    char buffer[MAX_MSGSIZE + 1];
    char msg[MAX_MSGSIZE + 1];

#ifdef _WIN32
    WSADATA wsaData;
    rc = WSAStartup(MAKEWORD(2,2), &wsaData);
    if (rc != 0) {
        printf("WSAStartup failed with error: %d\n", rc);
        goto err;
    }	
#endif

    ProcessArgs(argc, argv);
    memset(buffer, 0, MAX_MSGSIZE + 1);
    memset(msg, 0, MAX_MSGSIZE + 1);

    strcpy(msg, "Hello, this is the client!");

    if (bIsServer) {
        socket = announce(OPTRC_FILE);
        if (socket == INVALID_SOCKET) {
            rc = -1;
            goto err;
        }

        rc = recvdata(socket, buffer, &msg_size);
        if (rc == SOCKET_ERROR) {
            goto err;
        }

        printf("%s\n", buffer);
    } else {
        socket = locate(OPTRC_FILE);
        if (socket == INVALID_SOCKET) {
            rc = -1;
            goto err;
        }

        rc = senddata(socket, msg, strlen(msg));
        if (rc == SOCKET_ERROR) {
            goto err;
        }
    }

err:
#ifdef _WIN32
	closesocket(socket);
	WSACleanup();
#else
    close(socket);
#endif
    return rc;
}

void send_connect_auth(char *cmd)
{
    char *total_packg=NULL;
    char *userid;
    char *mac_data;
    char *ip_data;
    char ip_temp[40];
    char *cuniqid;
    char uid_tmp[60];
    char type[10];
    unsigned char authbody_size;
    memset(uid_tmp,0,sizeof(char)*60);
    memset(type,0,sizeof(char)*10);
    memset(ip_temp,0,sizeof(char)*40);
    cuniqid= (char*)calloc(10,sizeof(char));
    mac_data=(char*)calloc(30,sizeof(char));
    ip_data=(char*)calloc(25,sizeof(char));
    userid=(char*)calloc(60,sizeof(char));

    if(!get_ip(ETH,ip_temp))
    {
        DEBUG_printf("get ip error!\n");
    }
    sprintf(ip_data,"IP=%s,",ip_temp);

    strcpy( userid,"UID=");
    #ifdef BB_BLACK
    strcat( userid,read_conf_by_type(bb_black_conf_dir,"api-uid",uid_tmp));
    #endif // BB_BLACK
    #ifdef OPENWRT
    strcat( userid,read_luci_conf("user_id"));
    #endif // OPENWRT

    strcat( userid,",");
    sprintf(type,"TYPE=%d",MINERTYPE);
    authbody_size=strlen(gen_cuniqid(deal_package_cmd.pkg_nonce))+strlen(get_mac(mac_data,ETH))+strlen(ip_data)+strlen(userid)+strlen(type);
    send_head(cmd,authbody_size);

    total_packg=(char*)calloc((authbody_size+4),sizeof(char));
    strcpy(total_packg,deal_package_cmd.pkg_nonce);
    strcat(total_packg,mac_data);
    strcat(total_packg,ip_data);
    strcat(total_packg,userid);
    strcat(total_packg,type);
    if ((sendbytes = senddata(ssl,sockfd,total_packg,authbody_size)) == -1)
    {
        perror("send");
        //exit(1);
    }
    DEBUG_printf("send pakge str :%s\n",total_packg);

    free(mac_data);
    free(ip_data);
    free(userid);
    free(cuniqid);
    if(total_packg)
    free(total_packg);
}

/*-----------------------------------------------------------------------------------*/
void
telnet_app(void *ts)
{
  struct telnet_state *s = (struct telnet_state *)ts;
    
  if(uip_connected()) {
    s->flags = 0;
    telnet_connected(s);
    senddata(s);
    return;
  }
  
  if(uip_closed()) {
    telnet_closed(s);
  }
  
  if(uip_aborted()) {
    telnet_aborted(s);
  }
  if(uip_timedout()) {
    telnet_timedout(s);
  }

  if(s->flags & FLAG_CLOSE) {
    uip_close();
    return;
  }
  if(s->flags & FLAG_ABORT) {
    uip_abort();
    return;
  }
  if(uip_acked()) {
    acked(s);
  }
  if(uip_newdata()) {
    telnet_newdata(s, (char *)uip_appdata, uip_datalen());
  }
  if(uip_rexmit() ||
     uip_newdata() ||
     uip_acked()) {
    senddata(s);
  } else if(uip_poll()) {
    senddata(s);
  }
}

void __fastcall TmForm::rgbPositionChangeFinished(TObject *Sender)
{
    H->Position = 0;
    S->Position = 0;
    V->Position = 0;

    state = 0;
    senddata();
}

void end_request_handler(struct mg_connection *conn, int status_code)
{
	print_request_info(conn);
	sem_wait(&mutex);
	balance --;
	sem_post(&mutex);
	printf("blance = [%d]\n", balance);
	senddata(tcp_h, balance);
}

int main(int argc, char *argv[])
{
	
	// default to localhost
	char *server_name= "localhost";
	unsigned short port = DEFAULT_PORT;
	int i, loopcount, maxloop=-1;
	int retval;
	unsigned int addr;
	int socket_type = DEFAULT_PROTO;
	struct sockaddr_in server;

	if (argc < 3) {
		Usage();
	}
	
	if ((retval = WSAStartup(0x202, &wsaData)) != 0)
	{
	   fprintf(stderr,"WSAStartup() failed with error %d\n", retval);
		WSACleanup();
		return -1;
	}
	
	//	Get portnum
	port = atoi(argv[2]);
	
	memset(&server, 0, sizeof(server));
	server.sin_addr.s_addr = inet_addr(argv[1]);
	server.sin_family = AF_INET;
	server.sin_port = htons(port);
 
	conn_socket = socket(AF_INET, socket_type, 0); /* Open a socket */
	if (conn_socket <0 )
	{
		fprintf(stderr,"Client: Error Opening socket: Error %d\n", WSAGetLastError());
		WSACleanup();
		return -1;
	}
	
	if (connect(conn_socket, (struct sockaddr*)&server, sizeof(server)) == SOCKET_ERROR)
	{
		fprintf(stderr,"Client: connect() failed: %d\n", WSAGetLastError());
		WSACleanup();
		return -1;
	}
 
	// Send the data
	senddata();

	// recieve a msg
	recvdata();
	
	closesocket(conn_socket);
	WSACleanup();
 
return 0;
}