?login_element?

Subversion Repositories NedoOS

Rev

Rev 2199 | Blame | Compare with Previous | Last modification | View Log | Download

  1. #include <stdlib.h>
  2. #include <stdio.h>
  3. #include <string.h>
  4. #include <oscalls.h>
  5. #include <osfs.h>
  6. #include <intrz80.h>
  7. #include <graphic.h>
  8. #include <../common/terminal.c>
  9. #include <tcp.h>
  10.  
  11. #define true 1
  12. #define false 0
  13.  
  14. unsigned int RBR_THR = 0xf8ef;
  15. unsigned int IER = 0xf9ef;
  16. unsigned int IIR_FCR = 0xfaef;
  17. unsigned int LCR = 0xfbef;
  18. unsigned int MCR = 0xfcef;
  19. unsigned int LSR = 0xfdef;
  20. unsigned int MSR = 0xfeef;
  21. unsigned int SR = 0xffef;
  22. unsigned int divider = 1;
  23. unsigned char comType = 0;
  24. unsigned int espType = 32;
  25.  
  26. unsigned char picture[16384];
  27. unsigned char netbuf[6000];
  28.  
  29. unsigned char minRating[] = "0000000000";
  30. struct fileStruct
  31. {
  32.   long picId;
  33.   unsigned int picYear;
  34.   unsigned long totalAmount;
  35.   unsigned char picRating[8];
  36.   unsigned char picName[256];
  37.   unsigned char picType[64];
  38.   unsigned char authorIds[64];
  39.   unsigned char authorTitle[64];
  40.   unsigned char authorRealName[64];
  41.   unsigned char afn[128];
  42.   unsigned char pfn[128];
  43.   unsigned char fileName[128];
  44. } curFileStruct;
  45.  
  46. struct window
  47. {
  48.   unsigned char x;
  49.   unsigned char y;
  50.   unsigned char w;
  51.   unsigned char h;
  52.   unsigned char text;
  53.   unsigned char back;
  54.   unsigned char tittle[80];
  55. } curWin;
  56.  
  57. struct sockaddr_in dnsaddress;
  58. struct sockaddr_in targetadr;
  59. struct readstructure readStruct;
  60.  
  61. unsigned char ver[] = "3.7";
  62. const unsigned char sendOk[] = "SEND OK";
  63. const unsigned char gotWiFi[] = "WIFI GOT IP";
  64. unsigned char buffer[] = "0000000000";
  65. unsigned char userAgent[] = " HTTP/1.1\r\nHost: zxart.ee\r\nUser-Agent: Mozilla/4.0 (compatible; MSIE5.01; NedoOS; GetPic)\r\n\r\n\0";
  66. unsigned char zxart[] = "zxart.ee";
  67. unsigned char keypress, verbose, randomPic, slideShow, netDriver;
  68.  
  69. unsigned long contLen;
  70. unsigned long count = 0;
  71. unsigned int headlng;
  72. unsigned int slideShowTime = 0;
  73. unsigned int loaded;
  74.  
  75. unsigned char crlf[2] = {13, 10};
  76. unsigned char cmd[512];
  77. unsigned char link[512];
  78. unsigned char fileIdChar[10];
  79.  
  80. void clearStatus(void)
  81. {
  82. }
  83.  
  84. void emptyKeys(void)
  85. {
  86.   unsigned char loop, key;
  87.   do
  88.   {
  89.     key = OS_GETKEY();
  90.     if (loop > 64)
  91.     {
  92.       break;
  93.     }
  94.     loop++;
  95.   } while (key != 0);
  96. }
  97.  
  98. void spaces(unsigned char number)
  99. {
  100.   while (number > 0)
  101.   {
  102.     putchar(' ');
  103.     number--;
  104.   }
  105. }
  106. void quit(void)
  107. {
  108.   OS_CLS(0);
  109.   OS_SETGFX(-1);
  110.   exit(0);
  111. }
  112.  
  113. void infoBox(struct window w, unsigned char *message)
  114. {
  115.   unsigned char wcount, tempx, tittleStart;
  116.  
  117.   w.h++;
  118.   OS_SETXY(w.x, w.y - 1);
  119.   BDBOX(w.x, w.y, w.w + 1, w.h, w.back, 32);
  120.   OS_SETXY(w.x, w.y);
  121.   OS_SETCOLOR(w.text);
  122.   putchar(201);
  123.   for (wcount = 0; wcount < w.w; wcount++)
  124.   {
  125.     putchar(205);
  126.   }
  127.   putchar(187);
  128.   OS_SETXY(w.x, w.y + w.h);
  129.   putchar(200);
  130.   for (wcount = 0; wcount < w.w; wcount++)
  131.   {
  132.     putchar(205);
  133.   }
  134.   putchar(188);
  135.  
  136.   tempx = w.x + w.w + 1;
  137.   for (wcount = 1; wcount < w.h; wcount++)
  138.   {
  139.     OS_SETXY(w.x, w.y + wcount);
  140.     putchar(186);
  141.     OS_SETXY(tempx, w.y + wcount);
  142.     putchar(186);
  143.   }
  144.   tittleStart = w.x + (w.w / 2) - (strlen(w.tittle) / 2);
  145.   OS_SETXY(tittleStart, w.y);
  146.   printf("[%s]", w.tittle);
  147.  
  148.   OS_SETXY(w.x + 1, w.y + 1);
  149.   OS_SETCOLOR(w.back);
  150.   tittleStart = w.x + (w.w / 2) - (strlen(message) / 2);
  151.   OS_SETXY(tittleStart, w.y + 1);
  152.   printf("%s", message);
  153. }
  154.  
  155. void printHelp(void)
  156. {
  157.   OS_SETCOLOR(67);
  158.   printf("   GETPIC [%s] zxart.ee picture viewer for nedoNET\n\r", ver);
  159.   OS_SETCOLOR(6);
  160.   printf("-------------------------------------------------------\n\r");
  161.   printf(" Управление:\n\r");
  162.   printf(" 'ESC' - выход из программы;\n\r");
  163.   printf(" '<-' или 'B' к последним картинкам;\n\r");
  164.   printf(" '->' или 'Пробел' к более старым картинкам\n\r");
  165.   printf(" 'J' Прыжок на  указанную по счету картинку\n\r");
  166.   printf(" 'I' Просмотр экрана информации о картинках\n\r");
  167.   printf(" 'S' Сохранить картинку на диск в текущую папку\n\r");
  168.   printf(" 'V' не выводить информацию об авторах\n\r");
  169.   printf(" 'R' переход в режим  случайная картинка с рейтингом 4+\n\r");
  170.   printf(" 'A' переход в режим  слайд-шоу\n\r");
  171.   printf(" 'D' Переключение режима ZXNETUSB/ESP-COM\n\r");
  172.   printf(" 'T' Продолжительность одного слайда в int-ах \n\r");
  173.   printf(" 'M' Минимальный рейтинг для случайного воспроизведения. \n\r");
  174.   printf(" 'H' Данная справочная информация\n\r");
  175.   printf("-----------------Нажмите любую кнопку------------------\n\r");
  176.   OS_SETCOLOR(70);
  177.   keypress = getchar();
  178.   OS_CLS(0);
  179. }
  180.  
  181. void delay(unsigned long counter)
  182. {
  183.   unsigned long start, finish;
  184.   counter = counter / 20;
  185.   if (counter < 1)
  186.   {
  187.     counter = 1;
  188.   }
  189.   start = time();
  190.   finish = start + counter;
  191.  
  192.   while (start < finish)
  193.   {
  194.     start = time();
  195.   }
  196. }
  197.  
  198. ///////////////////////////
  199. #include <../common/esp-com.c>
  200. #include <../common/network.c>
  201. //////////////////////////
  202.  
  203. int testOperation2(unsigned char *process, int socket)
  204. {
  205.   if (socket < 0)
  206.   {
  207.     printf("%s: [ERROR:", process);
  208.     errorPrint(-socket);
  209.     printf("]\r\n");
  210.     YIELD();
  211.     return -socket;
  212.   }
  213.   return 1;
  214. }
  215.  
  216. int cutHeader(unsigned int todo)
  217. {
  218.   unsigned int err;
  219.   unsigned char *count1;
  220.  
  221.   err = httpError();
  222.   if (err != 200)
  223.   {
  224.     printf("\r\nHTTP response:[%u]\r\n", err);
  225.     printf("^^^^^^^^^^^^^^^^^^^^^\r\n");
  226.     puts(netbuf);
  227.     getchar();
  228.   }
  229.   count1 = strstr(netbuf, "Content-Length:");
  230.   if (count1 == NULL)
  231.   {
  232.     printf("contLen  not found \r\n");
  233.     contLen = 0;
  234.   }
  235.   else
  236.   {
  237.     contLen = atol(count1 + 15);
  238.     // printf("Content-Length: %lu \n\r", contLen);
  239.   }
  240.  
  241.   count1 = strstr(netbuf, "\r\n\r\n");
  242.   if (count1 == NULL)
  243.   {
  244.     printf("header not found\r\n");
  245.   }
  246.   else
  247.   {
  248.     headlng = ((unsigned int)count1 - (unsigned int)netbuf + 4);
  249.     // printf("header %u bytes\r\n", headlng);
  250.   }
  251.   return todo - headlng;
  252. }
  253.  
  254. char *str_replace(char *dst, int num, const char *str, const char *orig, const char *rep)
  255. {
  256.   const char *ptr;
  257.   size_t len1 = strlen(orig);
  258.   size_t len2 = strlen(rep);
  259.   char *tmp = dst;
  260.  
  261.   num -= 1;
  262.   while ((ptr = strstr(str, orig)) != NULL)
  263.   {
  264.     num -= (ptr - str) + len2;
  265.     if (num < 1)
  266.       break;
  267.  
  268.     strncpy(dst, str, (size_t)(ptr - str));
  269.     dst += ptr - str;
  270.     strncpy(dst, rep, len2);
  271.     dst += len2;
  272.     str = ptr + len1;
  273.   }
  274.  
  275.   for (; (*dst = *str) && (num > 0); --num)
  276.   {
  277.     ++dst;
  278.     ++str;
  279.   }
  280.   return tmp;
  281. }
  282.  
  283. char fillPictureEsp(void)
  284. {
  285.   unsigned char sizeLink = 0;
  286.   unsigned long downloaded = 0;
  287.   unsigned char byte, count = 0;
  288.   unsigned int todo = 0;
  289.   unsigned char *count1;
  290.  
  291.   strcpy(link, netbuf);
  292.   sizeLink = strlen(link);
  293.   do
  294.   {
  295.     sendcommand("AT+CIPSTART=\"TCP\",\"zxart.ee\",80");
  296.     getAnswer2(); // CONNECT or ERROR or link is not valid
  297.     count1 = strstr(netbuf, "CONNECT");
  298.   } while (count1 == NULL);
  299.  
  300.   getAnswer2();                                   // OK
  301.   sprintf(netbuf, "AT+CIPSEND=%u", sizeLink + 2); // second CRLF in send command
  302.   sendcommand(netbuf);
  303.   getAnswer2();
  304.   do
  305.   {
  306.     byte = uart_readBlock();
  307.     // putchar(byte);
  308.   } while (byte != '>');
  309.   sendcommand(link);
  310.   count = 0;
  311.   do
  312.   {
  313.     byte = uart_readBlock();
  314.     if (byte == sendOk[count])
  315.     {
  316.       count++;
  317.     }
  318.     else
  319.     {
  320.       count = 0;
  321.     }
  322.   } while (count < strlen(sendOk));
  323.   uart_readBlock(); // CR
  324.   uart_readBlock(); // LF
  325.   downloaded = 0;
  326.   do
  327.   {
  328.     headlng = 0;
  329.     todo = recvHead();
  330.     getdataEsp(todo); // Requested size
  331.     if (downloaded == 0)
  332.     {
  333.       todo = cutHeader(todo);
  334.     }
  335.  
  336.     if (downloaded + todo > sizeof(picture))
  337.     {
  338.       printf("dataBuffer overrun... %u reached \n\r", downloaded + todo);
  339.       return false;
  340.     }
  341.  
  342.     memcpy(picture + downloaded, netbuf + headlng, todo);
  343.     downloaded = downloaded + todo;
  344.   } while (downloaded < contLen);
  345.   sendcommand("AT+CIPCLOSE");
  346.   getAnswer2(); // CLOSED
  347.   getAnswer2(); // OK
  348.   return true;
  349. }
  350.  
  351. char fillPictureNet(void)
  352. {
  353.   int todo;
  354.   unsigned int downloaded = 0;
  355.   char socket, retry;
  356.   picture[0] = 0;
  357.   retry = 3;
  358.   socket = OpenSock(AF_INET, SOCK_STREAM);
  359.   if (testOperation2("OS_NETSOCKET", socket) != 1)
  360.   {
  361.     getchar();
  362.     quit();
  363.   }
  364.   todo = netConnect(socket, retry);
  365.   if (testOperation2("OS_NETCONNECT", todo) != 1)
  366.   {
  367.     getchar();
  368.     quit();
  369.   }
  370.   todo = tcpSend(socket, (unsigned int)&netbuf, strlen(netbuf), retry);
  371.   if (testOperation2("OS_WIZNETWRITE", todo) != 1)
  372.   {
  373.     getchar();
  374.     quit();
  375.   }
  376.  
  377.   do
  378.   {
  379.     headlng = 0;
  380.     todo = tcpRead(socket, retry);
  381.     testOperation("OS_WIZNETREAD", todo); // Quit if too many retries
  382.  
  383.     if (downloaded == 0)
  384.     {
  385.       todo = cutHeader(todo);
  386.     }
  387.  
  388.     if (downloaded + todo > sizeof(picture))
  389.     {
  390.       printf("dataBuffer overrun... %u reached \n\r", downloaded + todo);
  391.       return false;
  392.     }
  393.     memcpy(picture + downloaded, netbuf + headlng, todo);
  394.     downloaded = downloaded + todo;
  395.   } while (downloaded != contLen);
  396.  
  397.   netShutDown(socket, 0);
  398.   picture[downloaded + 1] = 0;
  399.   return true;
  400. }
  401.  
  402. void nameRepair(unsigned char *pfn, unsigned int tfnSize)
  403. {
  404.  
  405.   str_replace(pfn, tfnSize, pfn, "\\", "_");
  406.   str_replace(pfn, tfnSize, pfn, "/", "_");
  407.   str_replace(pfn, tfnSize, pfn, ":", "_");
  408.   str_replace(pfn, tfnSize, pfn, "*", "_");
  409.   str_replace(pfn, tfnSize, pfn, "?", "_");
  410.   str_replace(pfn, tfnSize, pfn, "<", "_");
  411.   str_replace(pfn, tfnSize, pfn, ">", "_");
  412.   str_replace(pfn, tfnSize, pfn, "|", "_");
  413.   str_replace(pfn, tfnSize, pfn, " ", "_");
  414.   str_replace(pfn, tfnSize, pfn, "&#039;", "'");
  415.   str_replace(pfn, tfnSize, pfn, "&amp;", "&");
  416.   str_replace(pfn, tfnSize, pfn, "&quot;", "'");
  417.   str_replace(pfn, tfnSize, pfn, "&gt;", ")");
  418.   str_replace(pfn, tfnSize, pfn, "&lt;", "(");
  419.   str_replace(pfn, tfnSize, pfn, "\"", "'");
  420. }
  421.  
  422. void stringRepair(unsigned char *pfn, unsigned int tSize)
  423. {
  424.   str_replace(pfn, tSize, pfn, "&#039;", "'");
  425.   str_replace(pfn, tSize, pfn, "&amp;", "&");
  426.   str_replace(pfn, tSize, pfn, "&gt;", ">");
  427.   str_replace(pfn, tSize, pfn, "&lt;", "<");
  428.   str_replace(pfn, tSize, pfn, "&quot;", "\"");
  429.   str_replace(pfn, tSize, pfn, "\\/", "/");
  430. }
  431.  
  432. void ncReplace(void)
  433. {
  434.   unsigned char len;
  435.   for (len = 0; len < strlen(curFileStruct.afn); len++)
  436.   {
  437.     if ((curFileStruct.afn[len] < ' ') || (curFileStruct.afn[len] > 0xef) || (curFileStruct.afn[len] > 0x7e && curFileStruct.afn[len] < 0xb0))
  438.     {
  439.       curFileStruct.afn[len] = '_';
  440.     }
  441.   }
  442.  
  443.   for (len = 0; len < strlen(curFileStruct.pfn); len++)
  444.   {
  445.     if ((curFileStruct.pfn[len] < ' ') || (curFileStruct.pfn[len] > 0xef) || (curFileStruct.pfn[len] > 0x7e && curFileStruct.pfn[len] < 0xb0))
  446.     {
  447.       curFileStruct.pfn[len] = '_';
  448.     }
  449.   }
  450. }
  451.  
  452. unsigned char savePic(unsigned long fileId)
  453. {
  454.   FILE *fp2;
  455.   unsigned char afnSize, tfnSize;
  456.  
  457.   afnSize = sizeof(curFileStruct.afn) - 1;
  458.   tfnSize = sizeof(curFileStruct.pfn) - 1;
  459.  
  460.   strcpy(curFileStruct.afn, curFileStruct.authorTitle);
  461.   nameRepair(curFileStruct.afn, afnSize);
  462.  
  463.   strcpy(curFileStruct.pfn, curFileStruct.picName);
  464.   nameRepair(curFileStruct.pfn, tfnSize);
  465.   ncReplace();
  466.  
  467.   sprintf(curFileStruct.fileName, "%s-%s-%ld.scr", curFileStruct.afn, curFileStruct.pfn, fileId);
  468.   if (strlen(curFileStruct.fileName) > 62)
  469.   {
  470.     sprintf(fileIdChar, "-%ld", fileId);
  471.     str_replace(curFileStruct.fileName, sizeof(curFileStruct.fileName) - 1, curFileStruct.fileName, fileIdChar, "");
  472.     curFileStruct.fileName[50] = '\0';
  473.     strcat(curFileStruct.fileName, fileIdChar);
  474.     strcat(curFileStruct.fileName, ".scr");
  475.   }
  476.   OS_SETSYSDRV();
  477.   OS_MKDIR("../downloads");        // Create if not exist
  478.   OS_MKDIR("../downloads/getpic"); // Create if not exist
  479.   OS_CHDIR("../downloads/getpic");
  480.   fp2 = OS_CREATEHANDLE(curFileStruct.fileName, 0x80);
  481.   if (((int)fp2) & 0xff)
  482.   {
  483.     printf("%s creating error\r\n", curFileStruct.fileName);
  484.     getchar();
  485.     quit();
  486.   }
  487.   OS_WRITEHANDLE(picture, fp2, 6912);
  488.   OS_CLOSEHANDLE(fp2);
  489.   return 0;
  490. }
  491.  
  492. int pos(unsigned char *s, unsigned char *c, unsigned int n, unsigned int startPos)
  493. {
  494.   unsigned int i, j;
  495.   unsigned int lenC, lenS;
  496.  
  497.   for (lenC = 0; c[lenC]; lenC++)
  498.     ;
  499.   for (lenS = 0; s[lenS]; lenS++)
  500.     ;
  501.  
  502.   for (i = startPos; i <= lenS - lenC; i++)
  503.   {
  504.     for (j = 0; s[i + j] == c[j]; j++)
  505.       ;
  506.  
  507.     if (j - lenC == 1 && i == lenS - lenC && !(n - 1))
  508.       return i;
  509.     if (j == lenC)
  510.       if (n - 1)
  511.         n--;
  512.       else
  513.         return i;
  514.   }
  515.   return -1;
  516. }
  517.  
  518. const char *parseJson(unsigned char *property)
  519. {
  520.   unsigned int w, lng, lngp1, findEnd, listPos;
  521.   unsigned char terminator;
  522.   int n;
  523.   n = -1;
  524.   // netbuf[0] = '\0';
  525.   n = pos(picture, property, 1, 0);
  526.   if (n == -1)
  527.   {
  528.     strcpy(netbuf, "-");
  529.     // printf("Property %s not found", property);
  530.     return netbuf;
  531.   }
  532.   lng = n - 1 + strlen(property);
  533.   if (picture[lng] == ':')
  534.   {
  535.     terminator = 0;
  536.   }
  537.   if (picture[lng] == '\"')
  538.   {
  539.     terminator = '\"';
  540.   }
  541.   if (picture[lng] == '[')
  542.   {
  543.     terminator = ']';
  544.   }
  545.  
  546.   findEnd = 1;
  547.   lngp1 = lng + 1;
  548.  
  549.   while (42)
  550.   {
  551.  
  552.     if ((picture[lngp1 + findEnd] == ','))
  553.     {
  554.       if (terminator == 0)
  555.       {
  556.         break;
  557.       }
  558.       if ((picture[lng + findEnd] == terminator))
  559.       {
  560.         findEnd--;
  561.         break;
  562.       }
  563.     }
  564.     findEnd++;
  565.   }
  566.   listPos = 0;
  567.   for (w = lngp1; w < findEnd + lngp1; w++)
  568.   {
  569.     netbuf[listPos] = picture[w];
  570.     listPos++;
  571.   }
  572.   netbuf[listPos] = 0;
  573.   return netbuf;
  574. }
  575.  
  576. void convert866(void)
  577. {
  578.   unsigned int lng, targetPos, w, q = 0;
  579.   unsigned char buffer[8], one, two;
  580.   unsigned int decVal;
  581.   lng = strlen(netbuf);
  582.   targetPos = lng + 1;
  583.  
  584.   while (q < lng)
  585.   {
  586.     one = netbuf[q];
  587.     two = netbuf[q + 1];
  588.     if (one == 92 && two == 117)
  589.     {
  590.       q = q + 2;
  591.       for (w = 0; w < 4; w++)
  592.       {
  593.         buffer[w] = netbuf[q + w];
  594.       }
  595.       q = q + 4;
  596.       buffer[4] = '\0';
  597.       decVal = (unsigned int)strtol(buffer, NULL, 16);
  598.  
  599.       if (decVal < 1088)
  600.       {
  601.         decVal = decVal - 912;
  602.       }
  603.       if (decVal > 1087)
  604.       {
  605.         decVal = decVal - 864;
  606.       }
  607.       if (decVal == 1025)
  608.       {
  609.         decVal = 240;
  610.       }
  611.       if (decVal == 1105)
  612.       {
  613.         decVal = 241;
  614.       }
  615.  
  616.       netbuf[targetPos] = decVal;
  617.     }
  618.     else
  619.     {
  620.       netbuf[targetPos] = netbuf[q];
  621.       q++;
  622.     }
  623.     targetPos++;
  624.   }
  625.   netbuf[targetPos] = 0;
  626.  
  627.   for (w = lng + 1; w < targetPos + 1; w++)
  628.   {
  629.     netbuf[w - lng - 1] = netbuf[w];
  630.   }
  631. }
  632.  
  633. long processJson(unsigned long startPos, unsigned char limit, unsigned char queryNum)
  634. {
  635.   unsigned int tSize;
  636.   unsigned char *count1, result;
  637.   switch (queryNum)
  638.   {
  639.   case 0:
  640.     sprintf(netbuf, "GET /api/export:zxPicture/filter:zxPictureType=standard/limit:%u/start:%lu/order:date,desc%s", limit, startPos, userAgent);
  641.     break;
  642.   case 1:
  643.     sprintf(netbuf, "GET /api/types:zxPicture/export:zxPicture/language:eng/start:0/limit:1/order:rand/filter:zxPictureMinRating=%s;zxPictureType=standard%s", minRating, userAgent);
  644.     break;
  645.   case 99: // GET /jsonElementData/elementId:182798
  646.     sprintf(netbuf, "GET /jsonElementData/elementId:%lu%s", startPos, userAgent);
  647.     break;
  648.   }
  649.  
  650.   switch (netDriver)
  651.   {
  652.   case 0:
  653.     result = fillPictureNet();
  654.     break;
  655.   case 1:
  656.     result = fillPictureEsp();
  657.     break;
  658.   }
  659.  
  660.   count1 = strstr(picture, "responseStatus\":\"success");
  661.   if (count1 == NULL)
  662.   {
  663.     OS_CLS(0);
  664.     OS_SETCOLOR(66);
  665.     puts("Picture[]:");
  666.     puts(picture);
  667.     puts("---------------");
  668.     printf("PROCESS JSON: [ERROR: Bad responseStatus.] [Query:%u][Pic:%lu]\r\n", queryNum, startPos);
  669.     YIELD();
  670.     getchar();
  671.     return -1;
  672.   }
  673.  
  674.   count1 = strstr(picture, "\"id\":");
  675.   if (count1 == NULL)
  676.   {
  677.     parseJson("\"totalAmount\":");
  678.  
  679.     if (atol(netbuf) == 0)
  680.     {
  681.       return -3;
  682.     }
  683.  
  684.     if (netbuf[0] != '-')
  685.     {
  686.       return -4;
  687.     }
  688.     OS_CLS(0);
  689.     OS_SETCOLOR(66);
  690.     puts("Picture[]:");
  691.     puts(picture);
  692.     puts("---------------");
  693.     printf("PROCESS JSON: [ERROR: ID not found.] [Query:%u][Pic:%lu]\r\n", queryNum, startPos);
  694.     YIELD();
  695.     return -2;
  696.   }
  697.   netbuf[0] = 0;
  698.  
  699.   switch (queryNum)
  700.   {
  701.   case 0:
  702.   case 1:
  703.     parseJson("\"id\":");
  704.     curFileStruct.picId = atol(netbuf);
  705.     parseJson(",\"title\":\"");
  706.     convert866();
  707.     strcpy(curFileStruct.picName, netbuf);
  708.     tSize = sizeof(curFileStruct.picName);
  709.     stringRepair(curFileStruct.picName, tSize);
  710.  
  711.     parseJson(",\"type\":\"");
  712.     strcpy(curFileStruct.picType, netbuf);
  713.     parseJson("\"rating\":\"");
  714.     strcpy(curFileStruct.picRating, netbuf);
  715.     parseJson("\"year\":\"");
  716.     curFileStruct.picYear = atoi(netbuf);
  717.     parseJson("\"totalAmount\":");
  718.     curFileStruct.totalAmount = atol(netbuf);
  719.     parseJson("\"authorIds\":[");
  720.     strcpy(curFileStruct.authorIds, netbuf);
  721.     break;
  722.   case 99:
  723.     parseJson(",\"title\":\"");
  724.     convert866();
  725.     strcpy(curFileStruct.authorTitle, netbuf);
  726.     parseJson(",\"realName\":\"");
  727.     convert866();
  728.     strcpy(curFileStruct.authorRealName, netbuf);
  729.     break;
  730.   }
  731.   return curFileStruct.picId;
  732. }
  733.  
  734. void printData(void)
  735. {
  736.   OS_SETCOLOR(70);
  737.   printf(" #: ");
  738.   OS_SETCOLOR(71);
  739.   printf("%lu", count);
  740.   OS_SETCOLOR(70);
  741.   printf(" ID: ");
  742.   OS_SETCOLOR(71);
  743.   printf("%lu ", curFileStruct.picId);
  744.   OS_SETCOLOR(70);
  745.   printf(" Total Pics: ");
  746.   OS_SETCOLOR(71);
  747.   printf("%lu\r\n", curFileStruct.totalAmount);
  748.   OS_SETCOLOR(70);
  749.   printf(" Author: ");
  750.   OS_SETCOLOR(69);
  751.   printf("%s\r\n", curFileStruct.authorTitle);
  752.   OS_SETCOLOR(70);
  753.   printf(" TITLE: ");
  754.   OS_SETCOLOR(67);
  755.   printf("%s\r\n", curFileStruct.picName);
  756.   OS_SETCOLOR(70);
  757.   printf(" RATING: ");
  758.   OS_SETCOLOR(71);
  759.   printf("%s", curFileStruct.picRating);
  760.   OS_SETCOLOR(70);
  761.   printf(" YEAR: ");
  762.   OS_SETCOLOR(71);
  763.   printf("%u\r\n", curFileStruct.picYear);
  764.   OS_SETCOLOR(70);
  765.   printf(" AuthorsIDs ");
  766.   OS_SETCOLOR(71);
  767.   printf("%s", curFileStruct.authorIds);
  768.   OS_SETCOLOR(70);
  769.   printf(" Real name: ");
  770.   OS_SETCOLOR(71);
  771.   printf("%s\r\n", curFileStruct.authorRealName);
  772.   OS_SETCOLOR(69);
  773.   printf("\r\n");
  774.   printf("\r\n");
  775.  
  776.   OS_SETCOLOR(70);
  777.  
  778.   OS_SETCOLOR(70);
  779.   printf(" Query: ");
  780.   OS_SETCOLOR(71);
  781.   if (randomPic)
  782.   {
  783.     printf("Random pic with %s+ rating\r\n", minRating);
  784.   }
  785.   else
  786.   {
  787.     puts("Sequental from newest");
  788.   }
  789.   OS_SETCOLOR(70);
  790.   printf(" Mode : ");
  791.   OS_SETCOLOR(71);
  792.  
  793.   if (slideShow)
  794.   {
  795.     printf("Slide-show, %u ints \r\n", slideShowTime);
  796.   }
  797.   else
  798.   {
  799.     puts("Manual show");
  800.   }
  801.  
  802.   // YIELD();
  803. }
  804.  
  805. unsigned char inputBox(struct window w, unsigned char *prefilled)
  806. {
  807.   unsigned char wcount, tempx, tittleStart;
  808.   unsigned char byte, counter;
  809.   w.h++;
  810.   OS_SETXY(w.x, w.y - 1);
  811.   BDBOX(w.x, w.y, w.w + 1, w.h, w.back, 32);
  812.   OS_SETXY(w.x, w.y);
  813.   OS_SETCOLOR(w.text);
  814.   putchar(201);
  815.   for (wcount = 0; wcount < w.w; wcount++)
  816.   {
  817.     putchar(205);
  818.   }
  819.   putchar(187);
  820.   OS_SETXY(w.x, w.y + w.h);
  821.   putchar(200);
  822.   for (wcount = 0; wcount < w.w; wcount++)
  823.   {
  824.     putchar(205);
  825.   }
  826.   putchar(188);
  827.  
  828.   tempx = w.x + w.w + 1;
  829.   for (wcount = 1; wcount < w.h; wcount++)
  830.   {
  831.     OS_SETXY(w.x, w.y + wcount);
  832.     putchar(186);
  833.     OS_SETXY(tempx, w.y + wcount);
  834.     putchar(186);
  835.   }
  836.   tittleStart = w.x + (w.w / 2) - (strlen(w.tittle) / 2);
  837.   OS_SETXY(tittleStart, w.y);
  838.   printf("[%s]", w.tittle);
  839.   OS_SETXY(w.x + 1, w.y + 1);
  840.   OS_SETCOLOR(w.back);
  841.   putchar(219);
  842.  
  843.   cmd[0] = 0;
  844.  
  845.   counter = strlen(prefilled);
  846.   if (counter != 0)
  847.   {
  848.     strcpy(cmd, prefilled);
  849.     goto skipKeys;
  850.   }
  851.  
  852.   do
  853.   {
  854.     byte = OS_GETKEY();
  855.     if (byte != 0)
  856.     {
  857.       switch (byte)
  858.       {
  859.       case 0x08:
  860.         if (counter > 0)
  861.         {
  862.           counter--;
  863.           cmd[counter] = 0;
  864.         }
  865.         break;
  866.       case 0x0d:
  867.  
  868.         if (counter == 0)
  869.         {
  870.           return false;
  871.         }
  872.         else
  873.         {
  874.           return true;
  875.         }
  876.  
  877.       case 31:
  878.         break;
  879.       case 250:
  880.         break;
  881.       case 249:
  882.         break;
  883.       case 248:
  884.         break;
  885.       case 251: // Right
  886.         break;
  887.       case 252: // Del
  888.         OS_SETXY(w.x + 1, w.y + 1);
  889.         spaces(counter + 1);
  890.         cmd[0] = 0;
  891.         counter = 0;
  892.         break;
  893.       case 27:
  894.         cmd[0] = 0;
  895.         return false;
  896.       default:
  897.         if (counter < w.w - 1)
  898.         {
  899.           cmd[counter] = byte;
  900.           counter++;
  901.           cmd[counter] = 0;
  902.         }
  903.         break;
  904.       }
  905.     skipKeys:
  906.       OS_SETXY(w.x + 1, w.y + 1);
  907.       printf("%s", cmd);
  908.       putchar(219);
  909.       if (byte == 0x08)
  910.       {
  911.         putchar(' ');
  912.       }
  913.     }
  914.     YIELD();
  915.   } while (42);
  916.   return false;
  917. }
  918.  
  919. void safeKeys(unsigned char keypress)
  920. {
  921.   switch (keypress)
  922.   {
  923.   case 27:
  924.     OS_SETCOLOR(70);
  925.     printf("Good bye...\r\n");
  926.     delayLong(500);
  927.     quit();
  928.     break;
  929.   case 'j':
  930.   case 'J':
  931.     curWin.w = 13;
  932.     curWin.x = 80 / 2 - curWin.w / 2 - 2;
  933.     curWin.y = 11;
  934.     curWin.h = 1;
  935.     curWin.text = 103;
  936.     curWin.back = 103;
  937.     strcpy(curWin.tittle, "# of pic:");
  938.     if (inputBox(curWin, ""))
  939.     {
  940.       sscanf(cmd, "%lu", &count);
  941.       if (count > curFileStruct.totalAmount - 1)
  942.       {
  943.         count = curFileStruct.totalAmount - 1;
  944.       }
  945.     }
  946.     break;
  947.   case 't':
  948.   case 'T':
  949.     curWin.w = 20;
  950.     curWin.x = 80 / 2 - curWin.w / 2 - 2;
  951.     curWin.y = 11;
  952.     curWin.h = 1;
  953.     curWin.text = 103;
  954.     curWin.back = 103;
  955.     strcpy(curWin.tittle, "Slide time(ints)");
  956.     if (inputBox(curWin, ""))
  957.     {
  958.       sscanf(cmd, "%u", &slideShowTime);
  959.       OS_CLS(0);
  960.       OS_SETCOLOR(70);
  961.       printf("Slide duration set to %u ints.", slideShowTime);
  962.       delayLong(500);
  963.     }
  964.     break;
  965.   case 'v':
  966.   case 'V':
  967.     verbose = !verbose;
  968.  
  969.     if (verbose == 0)
  970.     {
  971.       BOX(1, 1, 80, 25, 40, ' ');
  972.       AT(1, 1);
  973.     }
  974.     break;
  975.   case 'h':
  976.   case 'H':
  977.     printHelp();
  978.     break;
  979.   case 'r':
  980.   case 'R':
  981.     randomPic = !randomPic;
  982.     OS_SETCOLOR(70);
  983.     if (verbose == 1)
  984.     {
  985.       if (randomPic == 1)
  986.       {
  987.         printf("    Random mode enabled...\r\n");
  988.         count = 0;
  989.         delayLong(500);
  990.       }
  991.       else
  992.       {
  993.         printf("    Sequental mode enabled...\r\n");
  994.         count = 0;
  995.         delayLong(500);
  996.       }
  997.     }
  998.     break;
  999.   case 'a':
  1000.   case 'A':
  1001.     slideShow = !slideShow;
  1002.     OS_SETCOLOR(70);
  1003.     if (slideShow == 1)
  1004.     {
  1005.       if (verbose == 1)
  1006.         printf("    SlideShow mode enabled...\r\n\r\n");
  1007.       slideShowTime = 150;
  1008.       delayLong(500);
  1009.     }
  1010.     else
  1011.     {
  1012.       if (verbose == 1)
  1013.         printf("    Manual mode enabled...\r\n\r\n");
  1014.       slideShowTime = 0;
  1015.       delayLong(500);
  1016.     }
  1017.     break;
  1018.   case 'd':
  1019.   case 'D':
  1020.     netDriver = !netDriver;
  1021.     OS_SETCOLOR(70);
  1022.     if (netDriver == 1)
  1023.     {
  1024.       printf("    ESP-COM mode enabled...\r\n");
  1025.       loadEspConfig();
  1026.       uart_init(divider);
  1027.       espReBoot();
  1028.       printf("    ESP-COM inited...\r\n");
  1029.       delayLong(500);
  1030.     }
  1031.     else
  1032.     {
  1033.       if (verbose == 1)
  1034.         printf("    NedoNET mode enabled...");
  1035.       delayLong(500);
  1036.     }
  1037.     break;
  1038.   case 'm':
  1039.   case 'M':
  1040.     curWin.w = 22;
  1041.     curWin.x = 80 / 2 - curWin.w / 2 - 2;
  1042.     curWin.y = 1;
  1043.     curWin.h = 1;
  1044.     curWin.text = 103;
  1045.     curWin.back = 103;
  1046.     strcpy(curWin.tittle, "Минимальная оценка:");
  1047.  
  1048.     if (inputBox(curWin, ""))
  1049.     {
  1050.       char counter;
  1051.       for (counter = 0; counter < strlen(cmd); counter++)
  1052.       {
  1053.         if ((((cmd[counter] < '0') || (cmd[counter] > '9'))) && cmd[counter] != '.')
  1054.         {
  1055.           counter = 0;
  1056.           break;
  1057.         }
  1058.       }
  1059.       if (counter != 0)
  1060.       {
  1061.         strncpy(minRating, cmd, 5);
  1062.         count = 0;
  1063.       }
  1064.     }
  1065.   default:
  1066.     break;
  1067.   }
  1068. }
  1069.  
  1070. void init(void)
  1071. {
  1072.   OS_SETSYSDRV();
  1073.   OS_MKDIR("../downloads");        // Create if not exist
  1074.   OS_MKDIR("../downloads/getpic"); // Create if not exist
  1075.   OS_CHDIR("../downloads/getpic");
  1076.  
  1077.   count = 0;
  1078.   verbose = 1;
  1079.   randomPic = 0;
  1080.   slideShow = 0;
  1081.   netDriver = 0;
  1082.   strcpy(minRating, "4.0");
  1083.  
  1084.   targetadr.family = AF_INET;
  1085.   targetadr.porth = 00;
  1086.   targetadr.portl = 80;
  1087.   targetadr.b1 = 217; // D9
  1088.   targetadr.b2 = 146; // 92
  1089.   targetadr.b3 = 69;  // 45
  1090.   targetadr.b4 = 13;  // 0D
  1091. }
  1092.  
  1093. C_task main(void)
  1094. {
  1095.   long iddqd, idkfa;
  1096.   char result;
  1097.  
  1098.   OS_HIDEFROMPARENT();
  1099.   OS_SETGFX(0x86);
  1100.   OS_CLS(0);
  1101.  
  1102.   init();
  1103.  
  1104.   printHelp();
  1105.   safeKeys(keypress);
  1106.  
  1107.   if (netDriver == 0)
  1108.   {
  1109.  
  1110.     get_dns();
  1111.     dnsResolve("zxart.ee");
  1112.     printf("\r\n");
  1113.   }
  1114.  
  1115. start:
  1116.   keypress = 0;
  1117.   switch (randomPic)
  1118.   {
  1119.   case 0:
  1120.  
  1121.     iddqd = processJson(count, 1, 0);
  1122.     break;
  1123.   case 1:
  1124.     iddqd = processJson(0, 1, 1);
  1125.     break;
  1126.   }
  1127.  
  1128.   OS_SETCOLOR(70);
  1129.   switch (iddqd)
  1130.   {
  1131.   case -3: // return 0 pictures
  1132.     strcpy(minRating, "1.0");
  1133.     printf("\r\n No picture is returned in query. Minimal rating is set to %s\r\n", minRating);
  1134.     delayLong(500);
  1135.     goto start;
  1136.   case -4: // return xxxx picture, but empty body.
  1137.     puts("Empty body is returned. Next picture, please.");
  1138.     delayLong(500);
  1139.     count++;
  1140.     goto start;
  1141.   }
  1142.  
  1143.   if (iddqd < 0)
  1144.   {
  1145.     count++;
  1146.     keypress = getchar();
  1147.     safeKeys(keypress);
  1148.     goto start;
  1149.   }
  1150.  
  1151.   if (verbose == 1)
  1152.   {
  1153.     idkfa = processJson(atol(curFileStruct.authorIds), 0, 99);
  1154.     if (idkfa < 0)
  1155.     {
  1156.       printf(" Cant parse curFileStruct.authorIds = %s \r\n\r\n", curFileStruct.authorIds);
  1157.       count++;
  1158.       getchar();
  1159.       goto start;
  1160.     }
  1161.   }
  1162.   if (strcmp(curFileStruct.picType, "standard") != 0)
  1163.   {
  1164.     printf("  >>Format '%s' not supported, skipped \n\r", curFileStruct.picType);
  1165.     count++;
  1166.     goto start;
  1167.   }
  1168.   sprintf(netbuf, "GET /file/id:%lu%s", iddqd, userAgent);
  1169.   switch (netDriver)
  1170.   {
  1171.   case 0:
  1172.     result = fillPictureNet();
  1173.     break;
  1174.   case 1:
  1175.     result = fillPictureEsp();
  1176.     break;
  1177.   }
  1178.  
  1179. review:
  1180.   OS_CLS(0);
  1181.   YIELD();
  1182.   keypress = viewScreen6912((unsigned int)&picture, slideShowTime);
  1183.   emptyKeys();
  1184.  
  1185.   ///// Keys only for pictures
  1186.   if (keypress == 's' || keypress == 'S')
  1187.   {
  1188.     savePic(iddqd);
  1189.     printf("%s saved.", curFileStruct.fileName);
  1190.     delayLong(500);
  1191.     count++;
  1192.   }
  1193.  
  1194.   if (keypress == 248 || keypress == 'b' || keypress == 'B')
  1195.   {
  1196.     if (count > 0)
  1197.     {
  1198.       count--;
  1199.     }
  1200.   }
  1201.   if (keypress == 251 || keypress == 32)
  1202.   {
  1203.     count++;
  1204.     goto start;
  1205.   }
  1206.   if (keypress == 'i' || keypress == 'I')
  1207.   {
  1208.     printData();
  1209.     getchar();
  1210.     goto review;
  1211.   }
  1212.   safeKeys(keypress);
  1213.   goto start;
  1214. }
  1215.