void handle_read(struct cloner *cloner)
{
int ret;
#define OPS(x,y) ((x<<16)|(y&0xffff))
switch(cloner->cmd->read.ops) {
#ifdef CONFIG_JZ_MMC
case OPS(MMC,0):
case OPS(MMC,1):
case OPS(MMC,2):
realloc_buf(cloner, ((cloner->cmd->read.length + 0x200) & (~(0x200 - 1))));
ret = mmc_read_x((cloner->cmd->read.ops & 0xffff),
cloner->read_req->buf,
cloner->cmd->read.partation + cloner->cmd->read.offset,
cloner->cmd->read.length);
break;
#endif
default:
ret = clmg_read(cloner);
break;
}
if (ret < 0)
cloner->ack = ret;
else
cloner->ack = 0;
if (cloner->args->transfer_data_chk)
cloner->crc = local_crc32(0xffffffff, cloner->read_req->buf, cloner->cmd->read.length);
//printf("handle read cloner->crc %x\n", cloner->crc);
/*always transfer data*/
cloner->read_req->length = cloner->cmd->read.length;
//usb_ep_queue(cloner->ep_in, cloner->read_req, 0);
#undef OPS
}
int handle_check(struct cloner *cloner)
{
unsigned int buf[128];
int ret = 0, check_buf = 0;
#define OPS(x,y) ((x<<16)|(y&0xffff))
switch(cloner->cmd->read.ops) {
#ifdef CONFIG_JZ_MMC
case OPS(MMC,0):
case OPS(MMC,1):
case OPS(MMC,2):
ret = mmc_read_x((cloner->cmd->check.ops & 0xffff), buf,
cloner->cmd->check.partation + cloner->cmd->check.offset,
512);
check_buf = buf[0];
break;
#endif
default:
ret = clmg_check(cloner);
break;
}
if (!ret && check_buf == cloner->cmd->check.check)
return 0;
else
return -EINVAL;
#undef OPS
}
//int http_post(char* url, char* data)
void http_callback(void *data)
{
OPS("### @ API : Callback - Thread[%d]", pthread_self());
// struct data
apiclient* apis = (void**)data;
char *post;
NEW(post, HTTP_POST_SIZE);
strcpy(post, apis->data);
pthread_mutex_unlock(&apis->mxlock);
// apply memory
char *host_name, *uri, *header, *next;
NEW(host_name, 32);
NEW(uri, 101);
//get host name
next = mid_value( apis->APICallback, "//", "/", host_name, 31 );
next = mid_value( next, "/", NULL, uri, 100 );
DEL(next);
//connect
int http_sock = qqsocket_create( TCP, NULL, 0 );
//printf(http_sock);
if( http_sock <= 0 )
{
DEL(host_name);
DEL(uri);
OPS("### @ API : Callback Connect Server Error.");
return;
}
NEW( header, KB(4) );
qqsocket_connect( http_sock, host_name, 80 );
sprintf( header,
"POST /%s HTTP/1.1\r\n"
"HOST: %s\r\n"
"User-Agent: QQRobot.APIServer.Agent\r\n"
"X-Powered-By: %s\r\n"
"Content-Type: application/x-www-form-urlencoded\r\n"
"Content-Length: %d\r\n\r\n"
"%s"
, uri, host_name, "*****@*****.**", strlen(post), post );
DEL(post);
DEL(host_name);
DEL(uri);
// Test
DBG("\n###HTTP POST\n%s\n########\n", header);
qqsocket_send( http_sock, (uchar*)header, strlen(header) );
DEL(header);
char *response;
NEW(response, KB(4));
qqsocket_recv( http_sock, (uchar*)response, KB(4) );
char *result;
NEW(result, 1024);
mid_value(response, "<result>", "</result>", result, 1024);
OPS("### @ API : Callback Result : %s", result);
DEL(response);
DEL(result);
qqsocket_close( http_sock );
//DEL(http_sock);
pthread_detach(pthread_self());
}
static void _svoGNGInit(svo_gng_t *gng)
{
const void *is;
svo_gng_node_t *n1 = NULL, *n2 = NULL;
size_t i;
bor_real_t maxbeta;
gng->cycle = 1L;
// initialize error heap
if (gng->err_heap)
borPairHeapDel(gng->err_heap);
gng->err_heap = borPairHeapNew(errHeapLT, (void *)gng);
// precompute beta^n
if (gng->beta_n)
BOR_FREE(gng->beta_n);
gng->beta_n = BOR_ALLOC_ARR(bor_real_t, gng->params.lambda);
gng->beta_n[0] = gng->params.beta;
for (i = 1; i < gng->params.lambda; i++){
gng->beta_n[i] = gng->beta_n[i - 1] * gng->params.beta;
}
// precompute beta^(n * lambda)
if (gng->beta_lambda_n)
BOR_FREE(gng->beta_lambda_n);
maxbeta = gng->beta_n[gng->params.lambda - 1];
gng->beta_lambda_n_len = 1000;
gng->beta_lambda_n = BOR_ALLOC_ARR(bor_real_t, gng->beta_lambda_n_len);
gng->beta_lambda_n[0] = maxbeta;
for (i = 1; i < gng->beta_lambda_n_len; i++){
gng->beta_lambda_n[i] = gng->beta_lambda_n[i - 1] * maxbeta;
}
if (gng->ops.init){
OPS(gng, init)(&n1, &n2, OPS_DATA(gng, init));
}else{
is = OPS(gng, input_signal)(OPS_DATA(gng, input_signal));
n1 = OPS(gng, new_node)(is, OPS_DATA(gng, new_node));
is = OPS(gng, input_signal)(OPS_DATA(gng, input_signal));
n2 = OPS(gng, new_node)(is, OPS_DATA(gng, new_node));
}
nodeAdd(gng, n1);
nodeAdd(gng, n2);
edgeNew(gng, n1, n2);
}
void http_send_file(int sock, char *file)
{
FILE *fp;
fp = fopen(file, "rb");
if( fp != NULL )
{
OPS("### @ HTTP : Send File : %s", file);
// header
char *http;
NEW(http, 256);
//memset(http, 0, 128);
strcat(http, "HTTP/1.1 200 OK\r\n");
strcat(http, "Content-Type: image/png\r\n");
strcat(http, "\r\n");
// send
send(sock, http, strlen(http), 0);
// body
char *buffer;
NEW(buffer, 512);
while( !feof(fp) )
{
fread(buffer, 512, 1, fp);
send(sock, buffer, 512, 0);
}
fclose(fp);
// Close
shutdown(sock, SD_BOTH);
closesocket(sock);
// Clear
DEL(http);
DEL(buffer);
//DEL(sock);
//DEL(fp);
}
else
{
OPS("### @ HTTP : File Not Found : %s", file);
//DEL(sock);
DEL(fp);
http_send(sock, "FILE NOT FOUND");
}
}
void http_send(int sock, char *message)
{
OPS("### @ HTTP : Send Message: %s", message);
// build
char *http;
NEW(http, 1024);
//memset(http, 0, 1024);
strcat(http, "HTTP/1.1 200 OK\r\n");
strcat(http, "Content-Type: text/html\r\n");
strcat(http, "\r\n");
strcat(http, message);
// Send
send(sock, http, strlen(http), 0);
// Close
shutdown(sock, SD_BOTH);
closesocket(sock);
// Clear
DEL(http);
//DEL(sock);
}
void handle_write(struct usb_ep *ep,struct usb_request *req)
{
struct cloner *cloner = req->context;
if(req->status == -ECONNRESET) {
cloner->ack = -ECONNRESET;
return;
}
if (req->actual != req->length) {
printf("write transfer length is err,actual=%08x,length=%08x\n",req->actual,req->length);
cloner->ack = -EIO;
return;
}
if(cloner->cmd_type == VR_UPDATE_CFG) {
cloner->ack = 0;
return;
}
if (cloner->args->transfer_data_chk) {
uint32_t tmp_crc = local_crc32(0xffffffff,req->buf,req->actual);
if (cloner->cmd->write.crc != tmp_crc) {
printf("crc is errr! src crc=%08x crc=%08x\n",cloner->cmd->write.crc,tmp_crc);
cloner->ack = -EINVAL;
return;
}
}
#define OPS(x,y) ((x<<16)|(y&0xffff))
switch(cloner->cmd->write.ops) {
case OPS(I2C,RAW):
cloner->ack = i2c_program(cloner);
break;
#ifdef CONFIG_JZ_NAND_MGR
case OPS(NAND,IMAGE):
cloner->ack = nand_program(cloner);
break;
#endif
#ifdef CONFIG_MTD_NAND_JZ
case OPS(NAND, MTD_RAW):
cloner->ack = nand_mtd_raw_program(cloner);
break;
case OPS(NAND, MTD_UBI):
cloner->ack = nand_mtd_ubi_program(cloner);
break;
#endif
#ifdef CONFIG_JZ_MMC
case OPS(MMC,0):
case OPS(MMC,1):
case OPS(MMC,2):
cloner->ack = mmc_program(cloner,cloner->cmd->write.ops & 0xffff);
break;
#endif
#ifdef CONFIG_CMD_EFUSE
case OPS(EFUSE,RAW):
cloner->ack = efuse_program(cloner);
break;
#endif
case OPS(SPI_NOR,RAW):
cloner->ack = spi_program(cloner);
break;
#ifdef CONFIG_MTD_SPINAND
case OPS(SPI_NAND,RAW):
cloner->ack = spinand_program(cloner);
break;
#endif
#ifdef CONFIG_JZ_SFC
case OPS(SFC_NOR,RAW):
cloner->ack = sfc_program(cloner);
break;
#endif
#ifdef CONFIG_MTD_SFCNAND
case OPS(SFC_NAND,RAW):
cloner->ack = spinand_program(cloner);
break;
#endif
case OPS(MEMORY,RAW):
cloner->ack = 0;
break;
case OPS(REGISTER,RAW):
{
volatile unsigned int *tmp = (void *)cloner->cmd->write.partation;
if((unsigned)tmp > 0xb0000000 && (unsigned)tmp < 0xb8000000) {
*tmp = *((int*)cloner->write_req->buf);
cloner->ack = 0;
} else {
printf("OPS(REGISTER,RAW): not supported address.");
cloner->ack = -ENODEV;
}
}
break;
default:
cloner->ack = clmg_write(cloner);
}
#undef OPS
}
void APISelect(void *data)
{
OPS("### @ API : Accept Success - Thread[%d]", pthread_self());
// struct data
qqclient* qq = ((void**)data)[0];
qq->api_select_count ++ ;
apiclient* apis = ((void**)data)[1];
int client = apis->sock;
pthread_mutex_unlock(&apis->mxsock);
// Request
char *buffer;
NEW(buffer, REQUEST_BUFFER);
// Select 模型读取请求
fd_set fdRead;
struct timeval fdRTV = {1, 0};
FD_ZERO(&fdRead);
FD_SET(client, &fdRead);
switch ( select(client, &fdRead, NULL, NULL, &fdRTV) )
{
default:
if ( FD_ISSET(client, &fdRead) )
{
recv(client, buffer, REQUEST_BUFFER, 0);
}
}
if ( strlen(buffer) < 9 )
{
OPS("### @ API : Request Unavailable.");
DEL(buffer);
return;
}
// Request Test
DBG("##### Request Begin #####\n%s\n##### Request End #####\n", buffer);
char *http;
NEW(http, 16);
mid_value(buffer, "GET ", " HTTP/1.1", http, 16);
if ( strstr(http, "/v?") >0 )
{
// 验证码读取
char *uid, *file;
NEW(uid, 18);
NEW(file, 32);
if ( strstr(http, "&") > 0 )
{
mid_value(http, "/v?", "&", uid, 18);
}
else
{
mid_value(http, "/v?", NULL, uid, 18);
}
sprintf(file, "./verify/%s.png", uid);
http_send_file(client, file);
DEL(uid);
DEL(file);
DEL(http);
DEL(buffer);
return;
}
else if ( strstr(http, "/send?") > 0 )
{
// 发送自定义信息
char *msg;
NEW(msg, REQUEST_BUFFER);
mid_value(buffer, "GET /send?", " HTTP/1.1", msg, REQUEST_BUFFER);
api_callback_build("http.send", msg);
DEL(msg);
http_send(client, "Message Sends OK.");
DEL(http);
DEL(buffer);
return;
}
else if ( strlen(http) > 0 )
{
http_send(client, "QQRobot API Server.");
DEL(http);
DEL(buffer);
return;
}
DEL(http);
char *api;
NEW(api, API_BUFFER);
mid_value(buffer, "API ", " MOYO/1.1", api, API_BUFFER);
if (strlen(api) == 0)
{
http_send(client, "API IS EMPTY");
DEL(api);
DEL(buffer);
return;
}
// API Commands
char *response;
NEW(response, RESPONSE_BUFFER);
// Check SecKey
char *seckey;
NEW(seckey, 255);
mid_value(buffer, "<seckey>", "</seckey>", seckey, 255);
if ( strcmp(apis->APISeckey, seckey)!=0 )
{
strcat(response, "ACCESS DENIED");
OPS("### @ API : Denied of : %s", api);
DEL(seckey);
goto API_RESPONSE;
}
DEL(seckey);
// API Runs
OPS("### @ API : Command of : %s ...Runs ...", api);
// ##### API of login #####
if ( stricmp(api, "login.create")==0 )
{
char *uid, *password;
NEW(uid, 10);
NEW(password, 32);
mid_value(buffer, "<uid>", "</uid>", uid, 10);
mid_value(buffer, "<password>", "</password>", password, 32);
strcat(response, myqq_login(atoi(uid), password));
//printf("Done of %s.\n", api);
DEL(uid);
DEL(password);
}
else if ( stricmp(api, "login.destroy")==0 )
{
strcat(response, myqq_logout());
//printf("Done of %s.\n", api);
}
else if ( stricmp(api, "login.verify")==0 )
{
char *vcode;
NEW(vcode, 4);
mid_value(buffer, "<verify>", "</verify>", vcode, 4);
if ( qq->process == P_VERIFYING )
{
qqclient_verify(qq, vcode);
OPS("### @ API : [Input] Verify Code : %s", vcode);
strcat(response, myqq_resume_login());
}
else
{
strcat(response, "DONT NEED");
}
//printf("Done of %s.\n", api);
DEL(vcode);
}
else if ( stricmp(api, "login.check")==0 )
{
strcat(response, myqq_check_login(qq));
//printf("Done of %s.\n", api);
}
// ##### API of buddy #####
else if ( stricmp(api, "buddy.name")==0 )
{
char *uid;
NEW(uid, 10);
mid_value(buffer, "<uid>", "</uid>", uid, 10);
strcat(response, myqq_get_buddy_name(qq, atoi(uid)));
//printf("Done of %s.\n", api);
DEL(uid);
}
else if ( stricmp(api, "buddy.send")==0 )
{
char *uid, *message;
NEW(uid, 10);
NEW(message, SEND_MESSAGE_SIZE);
mid_value(buffer, "<uid>", "</uid>", uid, 10);
mid_value(buffer, "<message>", "</message>", message, SEND_MESSAGE_SIZE);
if ( myqq_send_im_to_buddy(qq, atoi(uid), message, 0) )
{
strcat(response, "SEND FAILED");
}
else
{
strcat(response, "SEND SUCCESS");
}
//printf("Done of %s.\n", api);
DEL(uid);
DEL(message);
}
else if ( stricmp(api, "buddy.info")==0 )
{
char *uid;
NEW(uid, 10);
mid_value(buffer, "<uid>", "</uid>", uid, 10);
char *info;
NEW(info, KB(4));
myqq_get_buddy_info(qq, atoi(uid), info, KB(4));
strcat(response, info);
//printf("Done of %s.\n", api);
DEL(uid);
DEL(info);
}
else if ( stricmp(api, "buddy.list")==0 )
{
char *online;
NEW(online, 3);
mid_value(buffer, "<online>", "</online>", online, 3);
char *info;
NEW(info, BUDDY_BUF_SIZE);
if ( stricmp(online, "yes")==0 )
{
myqq_get_buddy_list(qq, info, BUDDY_BUF_SIZE, 1);
}
else
{
myqq_get_buddy_list(qq, info, BUDDY_BUF_SIZE, 0);
}
strcat(response, info);
//printf("Done of %s.\n", api);
DEL(online);
DEL(info);
}
// ##### API of qun #####
else if ( stricmp(api, "qun.name")==0 )
{
char *gid;
NEW(gid, 10);
mid_value(buffer, "<gid>", "</gid>", gid, 10);
strcat(response, myqq_get_qun_name(qq, atoi(gid)));
//printf("Done of %s.\n", api);
DEL(gid);
}
else if ( stricmp(api, "qun.send")==0 )
{
char *gid, *message;
NEW(gid, 10);
NEW(message, SEND_MESSAGE_SIZE);
mid_value(buffer, "<gid>", "</gid>", gid, 10);
mid_value(buffer, "<message>", "</message>", message, SEND_MESSAGE_SIZE);
if ( myqq_send_im_to_qun(qq, atoi(gid), message, 0) )
{
strcat(response, "SEND FAILED");
}
else
{
strcat(response, "SEND SUCCESS");
}
//printf("Done of %s.\n", api);
DEL(gid);
DEL(message);
}
else if ( stricmp(api, "qun.buddy.name")==0 )
{
char *gid, *uid;
NEW(gid, 10);
NEW(uid, 10);
mid_value(buffer, "<gid>", "</gid>", gid, 10);
mid_value(buffer, "<uid>", "</uid>", uid, 10);
strcat(response, myqq_get_qun_member_name(qq, atoi(gid), atoi(uid)));
//printf("Done of %s.\n", api);
DEL(gid);
DEL(uid);
}
else if ( stricmp(api, "qun.info")==0 )
{
char *gid;
NEW(gid, 10);
mid_value(buffer, "<gid>", "</gid>", gid, 10);
char *info;
NEW(info, KB(4));
myqq_get_qun_info(qq, atoi(gid), info, KB(4));
strcat(response, info);
//printf("Done of %s.\n", api);
DEL(gid);
DEL(info);
}
else if ( stricmp(api, "qun.list")==0 )
{
char *info;
NEW(info, QUN_BUF_SIZE);
myqq_get_qun_list(qq, info, QUN_BUF_SIZE);
strcat(response, info);
//printf("Done of %s.\n", api);
DEL(info);
}
else if ( stricmp(api, "qun.buddy.list")==0 )
{
char *gid, *online;
NEW(gid, 10);
NEW(online, 3);
mid_value(buffer, "<gid>", "</gid>", gid, 10);
mid_value(buffer, "<online>", "</online>", online, 3);
char *info;
NEW(info, BUDDY_BUF_SIZE);
if ( stricmp(online, "yes")==0 )
{
myqq_get_qun_member_list(qq, atoi(gid), info, BUDDY_BUF_SIZE, 1);
}
else
{
myqq_get_qun_member_list(qq, atoi(gid), info, BUDDY_BUF_SIZE, 0);
}
strcat(response, info);
//printf("Done of %s.\n", api);
DEL(gid);
DEL(online);
DEL(info);
}
// ##### API of me #####
else if ( stricmp(api, "me.sleep")==0 )
{
char *power;
NEW(power, 3);
mid_value(buffer, "<power>", "</power>", power, 3);
if ( strcmp(power, "on")==0 )
{
apis->APISleep = 1;
}
else
{
apis->APISleep = 0;
}
strcat(response, "SWITCH SUCCESS");
//printf("Done of %s.\n", api);
DEL(power);
}
else if ( stricmp(api, "me.list.update")==0 )
{
qun_update_all(qq);
buddy_update_list(qq);
group_update_list(qq);
if ( qqclient_wait(qq, 10)<0 )
{
strcat(response, "UPDATE FAILED");
}
else
{
strcat(response, "UPDATE SUCCESS");
}
//printf("Done of %s.\n", api);
}
else if ( stricmp(api, "me.autoreply")==0 )
{
char *power;
NEW(power, 3);
mid_value(buffer, "<power>", "</power>", power, 3);
if ( strcmp(power, "on")==0 )
{
myqq_auto_reply(1);
}
else
{
myqq_auto_reply(0);
}
strcat(response, "SWITCH SUCCESS");
//printf("Done of %s.\n", api);
DEL(power);
}
else if ( stricmp(api, "me.status.update")==0 )
{
char *status;
NEW(status, 6);
mid_value(buffer, "<status>", "</status>", status, 6);
if( strcmp( status, "away") == 0 )
qqclient_change_status( qq, QQ_AWAY );
else if( strcmp( status, "online") == 0 )
qqclient_change_status( qq, QQ_ONLINE );
else if( strcmp( status, "hidden") == 0 )
qqclient_change_status( qq, QQ_HIDDEN );
else if( strcmp( status, "killme") == 0 )
qqclient_change_status( qq, QQ_KILLME );
else if( strcmp( status, "busy") == 0 )
qqclient_change_status( qq, QQ_BUSY );
strcat(response, "UPDATE SUCCESS");
//printf("Done of %s.\n", api);
DEL(status);
}
else if ( stricmp(api, "me.buddy.add")==0 )
{
char *uid, *message;
NEW(uid, 10);
NEW(message, 50);
mid_value(buffer, "<uid>", "</uid>", uid, 10);
mid_value(buffer, "<message>", "</message>", message, 50);
qqclient_add(qq, atoi(uid), message);
strcat(response, "ADD SUCCESS");
//printf("Done of %s.\n", api);
DEL(uid);
DEL(message);
}
else if ( stricmp(api, "me.buddy.del")==0 )
{
char *uid;
NEW(uid, 10);
mid_value(buffer, "<uid>", "</uid>", uid, 10);
qqclient_del(qq, atoi(uid));
strcat(response, "DELETE SUCCESS");
//printf("Done of %s.\n", api);
DEL(uid);
}
else
{
strcat(response, "UNKNOWN API COMMAND");
OPS("### @ API : Command Unknown : %s", api);
}
API_RESPONSE:
// Send
send(client, response, strlen(response), 0);
// print
OPS("### @ API : Command of : %s ...Done.", api);
// Response Test
DBG("##### Response Begin #####\n%s\n##### Response End #####\n", response);
// Close
shutdown(client, SD_BOTH);
closesocket(client);
// Clear
DEL(response);
//DEL(client);
pthread_detach(pthread_self());
}
static void _svoGNGLearn(svo_gng_t *gng, size_t step)
{
const void *input_signal;
bor_net_node_t *nn;
svo_gng_node_t *n1, *n2, *n;
bor_net_edge_t *nedge;
svo_gng_edge_t *edge;
bor_real_t dist2;
bor_list_t *list, *item, *item_tmp;
// 1. Get input signal
input_signal = OPS(gng, input_signal)(OPS_DATA(gng, input_signal));
// 2. Find two nearest nodes to input signal
OPS(gng, nearest)(input_signal, &n1, &n2, OPS_DATA(gng, nearest));
// 3. Create connection between n1 and n2 if doesn't exist and set age
// to zero
nedge = borNetNodeCommonEdge(&n1->node, &n2->node);
if (!nedge){
edge = edgeNew(gng, n1, n2);
}else{
edge = bor_container_of(nedge, svo_gng_edge_t, edge);
}
edge->age = 0;
// 4. Increase error counter of winner node
dist2 = OPS(gng, dist2)(input_signal, n1, OPS_DATA(gng, dist2));
nodeIncError(gng, n1, dist2 * gng->beta_n[gng->params.lambda - step]);
// 5. Adapt nodes to input signal using fractions eb and en
// + 6. Increment age of all edges by one
// + 7. Remove edges with age higher than age_max
OPS(gng, move_towards)(n1, input_signal, gng->params.eb,
OPS_DATA(gng, move_towards));
// adapt also direct topological neighbors of winner node
list = borNetNodeEdges(&n1->node);
BOR_LIST_FOR_EACH_SAFE(list, item, item_tmp){
nedge = borNetEdgeFromNodeList(item);
edge = bor_container_of(nedge, svo_gng_edge_t, edge);
nn = borNetEdgeOtherNode(&edge->edge, &n1->node);
n = bor_container_of(nn, svo_gng_node_t, node);
// increase age (6.)
edge->age += 1;
// remove edge if it has age higher than age_max (7.)
if (edge->age > gng->params.age_max){
edgeDel(gng, edge);
if (borNetNodeEdgesLen(nn) == 0){
// remove node if not connected into net anymore
nodeRemove(gng, n);
n = NULL;
}
}
// move node (5.)
if (n){
OPS(gng, move_towards)(n, input_signal, gng->params.en,
OPS_DATA(gng, move_towards));
}
}
