PageRenderTime 887ms CodeModel.GetById 47ms RepoModel.GetById 9ms app.codeStats 1ms

/unused/old/tmp.c

https://github.com/AWildColin/Webkey
C | 1447 lines | 1325 code | 78 blank | 44 comment | 330 complexity | 1b2e994c9d0511b7e206619fd76bfcf2 MD5 | raw file
Possible License(s): GPL-3.0, LGPL-3.0, GPL-2.0, LGPL-2.1 
    

  1. /*
    2. 

  2. Copyright (C) 2010  Peter Mora, Zoltan Papp
    3. 

    4. 

  4. This program is free software: you can redistribute it and/or modify
    5. 

  5. it under the terms of the GNU General Public License as published by
    6. 

  6. the Free Software Foundation, either version 3 of the License, or
    7. 

  7. (at your option) any later version.
    8. 

    9. 

  9. This program is distributed in the hope that it will be useful,
    10. 

  10. but WITHOUT ANY WARRANTY; without even the implied warranty of
    11. 

  11. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    12. 

  12. GNU General Public License for more details.
    13. 

    14. 

  14. You should have received a copy of the GNU General Public License
    15. 

  15. along with this program.  If not, see <http://www.gnu.org/licenses/>.
    16. 

  16. */
    17. 

  17. 

  18. #include "suinput.h"
    19. 

  19. #include <stdio.h>
    20. 

  20. //#include <sys/types.h>
    21. 

  21. //#include <sys/socket.h>
    22. 

  22. //#include <netinet/in.h>
    23. 

  23. #include <stdlib.h>
    24. 

  24. #include <strings.h>
    25. 

  25. #include "KeycodeLabels.h"
    26. 

  26. #include <vector>
    27. 

  27. #include "kcm.h"
    28. 

  28. #include <sys/mman.h>
    29. 

  29. #include <linux/fb.h>
    30. 

  30. #include "png.h"
    31. 

  31. #include <errno.h>
    32. 

  32. #include <signal.h>
    33. 

  33. #include <sys/wait.h>
    34. 

  34. 

  35. #include <limits.h>
    36. 

  36. #include "mongoose.h"
    37. 

  37. 

  38. //#include <sys/wait.h>
    39. 

  39. //#include <unistd.h>
    40. 

  40. #include <linux/input.h>
    41. 

  41. 

  42. #undef stderr
    43. 

  43. FILE *stderr = stderr;
    44. 

  44. 

  45. #ifdef MYDEB
    46. 

  46. #define FB_DEVICE "/android/dev/graphics/fb0"
    47. 

  47. #else
    48. 

  48. #define FB_DEVICE "/dev/graphics/fb0"
    49. 

  49. #endif
    50. 

  50. 

  51. static int exit_flag;
    52. 

  52. static int touchcount=0;
    53. 

  53. static std::string dir;
    54. 

  54. static int dirdepth = 0;
    55. 

  55. static std::string passfile;
    56. 

  56. static std::string admin_password;
    57. 

  57. struct mg_context       *ctx;
    58. 

  58. 

  59. static void
    60. 

  60. signal_handler(int sig_num)
    61. 

  61. {
    62. 

  62.         if (sig_num == SIGCHLD)
    63. 

  63.                 while (waitpid(-1, &sig_num, WNOHANG) > 0);
    64. 

  64.         else
    65. 

  65.                 exit_flag = sig_num;
    66. 

  66. }
    67. 

  67. 

  68. 

  69. static int fbfd = -1;
    70. 

  70. static void *fbmmap = MAP_FAILED;
    71. 

  71. static int bytespp = 0;
    72. 

  72. static struct fb_var_screeninfo scrinfo;
    73. 

  73. static png_byte* pict = NULL;
    74. 

  74. static png_byte** graph = NULL;
    75. 

  75. static int touchfd = -1;
    76. 

  76. static __s32 xmin;
    77. 

  77. static __s32 xmax;
    78. 

  78. static __s32 ymin;
    79. 

  79. static __s32 ymax;
    80. 

  80. static int newsockfd = -1;
    81. 

  81. 

  82. //base
    83. 

  83. static const char* KCM_BASE[] ={
    84. 

  84. "A 'A' '2' 'a' 'A'",
    85. 

  85. "B 'B' '2' 'b' 'B'",
    86. 

  86. "C 'C' '2' 'c' 'C'",
    87. 

  87. "D 'D' '3' 'd' 'D'",
    88. 

  88. "E 'E' '3' 'e' 'E'",
    89. 

  89. "F 'F' '3' 'f' 'F'",
    90. 

  90. "G 'G' '4' 'g' 'G'",
    91. 

  91. "H 'H' '4' 'h' 'H'",
    92. 

  92. "I 'I' '4' 'i' 'I'",
    93. 

  93. "J 'J' '5' 'j' 'J'",
    94. 

  94. "K 'K' '5' 'k' 'K'",
    95. 

  95. "L 'L' '5' 'l' 'L'",
    96. 

  96. "M 'M' '6' 'm' 'M'",
    97. 

  97. "N 'N' '6' 'n' 'N'",
    98. 

  98. "O 'O' '6' 'o' 'O'",
    99. 

  99. "P 'P' '7' 'p' 'P'",
    100. 

  100. "Q 'Q' '7' 'q' 'Q'",
    101. 

  101. "R 'R' '7' 'r' 'R'",
    102. 

  102. "S 'S' '7' 's' 'S'",
    103. 

  103. "T 'T' '8' 't' 'T'",
    104. 

  104. "U 'U' '8' 'u' 'U'",
    105. 

  105. "V 'V' '8' 'v' 'V'",
    106. 

  106. "W 'W' '9' 'w' 'W'",
    107. 

  107. "X 'X' '9' 'x' 'X'",
    108. 

  108. "Y 'Y' '9' 'y' 'Y'",
    109. 

  109. "Z 'Z' '9' 'z' 'Z'",
    110. 

  110. "COMMA ',' ',' ',' '?'",
    111. 

  111. "PERIOD '.' '.' '.' '/'",
    112. 

  112. "AT '@' 0x00 '@' '~'",
    113. 

  113. "SPACE 0x20 0x20 0x20 0x20",
    114. 

  114. "ENTER 0xa 0xa 0xa 0xa",
    115. 

  115. "0 '0' '0' '0' ')'",
    116. 

  116. "1 '1' '1' '1' '!'",
    117. 

  117. "2 '2' '2' '2' '@'",
    118. 

  118. "3 '3' '3' '3' '#'",
    119. 

  119. "4 '4' '4' '4' '$'",
    120. 

  120. "5 '5' '5' '5' '%'",
    121. 

  121. "6 '6' '6' '6' '^'",
    122. 

  122. "7 '7' '7' '7' '&'",
    123. 

  123. "8 '8' '8' '8' '*'",
    124. 

  124. "9 '9' '9' '9' '('",
    125. 

  125. "TAB 0x9 0x9 0x9 0x9",
    126. 

  126. "GRAVE '`' '`' '`' '~'",
    127. 

  127. "MINUS '-' '-' '-' '_'",
    128. 

  128. "EQUALS '=' '=' '=' '+'",
    129. 

  129. "LEFT_BRACKET '[' '[' '[' '{'",
    130. 

  130. "RIGHT_BRACKET ']' ']' ']' '}'",
    131. 

  131. "BACKSLASH '\\' '\\' '\\' '|'",
    132. 

  132. "SEMICOLON ';' ';' ';' ':'",
    133. 

  133. "APOSTROPHE '\'' '\'' '\'' '\"'",
    134. 

  134. "STAR '*' '*' '*' '<'",
    135. 

  135. "POUND '#' '#' '#' '>'",
    136. 

  136. "PLUS '+' '+' '+' '+'",
    137. 

  137. "SLASH '/' '/' '/' '?'"
    138. 

  138. };
    139. 

  139. 

  140. //  ,!,",#,$,%,&,',(,),*,+,,,-,.,/
    141. 

  141. int spec1[] = {62,8,75,10,11,12,14,75,16,7,15,70,55,69,56,56,52};                      
    142. 

  142. int spec1sh[] = {0,1,1,1,1,1,1,0,1,1,1,1,0,0,0,1};
    143. 

  143. // :,;,<,=,>,?,@
    144. 

  144. int spec2[] = {74,74,17,70,18,55,77};
    145. 

  145. int spec2sh[] = {1,0,1,0,1,1,0};
    146. 

  146. // [,\,],^,_,`
    147. 

  147. int spec3[] = {71,73,72,13,69,68};
    148. 

  148. int spec3sh[] = {0,0,0,1,1,0};
    149. 

  149. // {,|,},~
    150. 

  150. int spec4[] = {71,73,72,68};
    151. 

  151. int spec4sh[] = {1,1,1,1,0};
    152. 

  152. 

  153. 

  154. struct BIND{
    155. 

  155. 	int ajax;
    156. 

  156. 	int disp;
    157. 

  157. 	int kcm;
    158. 

  158. 	bool kcm_sh;
    159. 

  159. 	bool sms;
    160. 

  160. };
    161. 

  161. 

  162. struct FAST{
    163. 

  163. 	bool show;
    164. 

  164. 	char* name;
    165. 

  165. 	int  ajax;
    166. 

  166. };
    167. 

  167. 

  168. static std::vector<BIND*> speckeys;
    169. 

  169. static std::vector<FAST*> fastkeys;
    170. 

  170. static int uinput_fd = -1;
    171. 

  171. 

  172. bool startswith(char* st, char* patt)
    173. 

  173. {
    174. 

  174. 	int i = 0;
    175. 

  175. 	while(patt[i])
    176. 

  176. 	{
    177. 

  177. 		if (st[i] == 0 || st[i]-patt[i])
    178. 

  178. 			return false;
    179. 

  179. 		i++;
    180. 

  180. 	}
    181. 

  181. 	return true;
    182. 

  182. }
    183. 

  183. 

  184. char* itoa(char* buff, int value)
    185. 

  185. {
    186. 

  186. 	unsigned int i = 0;
    187. 

  187. 	bool neg = false;
    188. 

  188. 	if (value<0)
    189. 

  189. 	{
    190. 

  190. 		neg = true;
    191. 

  191. 		value=-value;
    192. 

  192. 	}
    193. 

  193. 	if (value==0)
    194. 

  194. 		buff[i++] = '0';
    195. 

  195. 	else
    196. 

  196. 		while(value)
    197. 

  197. 		{
    198. 

  198. 			buff[i++] = '0'+(char)(value%10);
    199. 

  199. 			value = value/10;
    200. 

  200. 		}
    201. 

  201. 	if (neg)
    202. 

  202. 		buff[i++] = '-';
    203. 

  203. 	unsigned int j = 0;
    204. 

  204. 	for(j = 0; j < (i>>1); j++)
    205. 

  205. 	{
    206. 

  206. 		char t = buff[j];
    207. 

  207. 		buff[j] = buff[i-j-1];
    208. 

  208. 		buff[i-j-1] = t;
    209. 

  209. 	}
    210. 

  210. 	buff[i++]=0;
    211. 

  211. 	return buff;
    212. 

  212. }
    213. 

  213. 

  214. int getnum(char* st)
    215. 

  215. {
    216. 

  216. 	int r = 0;
    217. 

  217. 	int i = 0;
    218. 

  218. 	bool neg = false;
    219. 

  219. 	if (st[i]=='-')
    220. 

  220. 	{
    221. 

  221. 		neg = true;
    222. 

  222. 		i++;
    223. 

  223. 	}
    224. 

  224. 	while ('0'<=st[i] && '9'>=st[i])
    225. 

  225. 	{
    226. 

  226. 		r = r*10+(int)(st[i]-'0');
    227. 

  227. 		i++;
    228. 

  228. 	}
    229. 

  229. 	if (neg)
    230. 

  230. 		return -r;
    231. 

  231. 	else
    232. 

  232. 		return r;
    233. 

  233. }
    234. 

  234. 

  235. void send_ok(struct mg_connection *conn)
    236. 

  236. 

  237. {
    238. 

  238. 	mg_printf(conn,"HTTP/1.1 200 OK\r\nCache-Control: no-store, no-cache, must-revalidate\r\nCache-Control: post-check=0, pre-check=0\r\nPragma: no-cache\r\n\r\n");
    239. 

  239. }
    240. 

  240. void clear()
    241. 

  241. {
    242. 

  242. 	int i;
    243. 

  243. 	for(i=0; i < speckeys.size(); i++)
    244. 

  244. 		if (speckeys[i])
    245. 

  245. 			delete speckeys[i];
    246. 

  246. 	speckeys.clear();
    247. 

  247. 	for(i=0; i < fastkeys.size(); i++)
    248. 

  248. 		if (fastkeys[i])
    249. 

  249. 		{
    250. 

  250. 			delete[] fastkeys[i]->name;
    251. 

  251. 			delete fastkeys[i];
    252. 

  252. 		}
    253. 

  253. 	fastkeys.clear();
    254. 

  254. 	if (uinput_fd != -1)
    255. 

  255. 		suinput_close(uinput_fd);
    256. 

  256. 	if (pict)
    257. 

  257. 		delete[] pict;
    258. 

  258. 	pict = NULL;
    259. 

  259. 	if (graph)
    260. 

  260. 		delete[] graph;
    261. 

  261. 	graph = NULL;
    262. 

  262. }
    263. 

  263. 

  264. void error(const char *msg,const char *msg2 = NULL, const char *msg3=NULL, const char * msg4=NULL)
    265. 

  265. {
    266. 

  266.     perror(msg);
    267. 

  267.     if (msg2) perror(msg2);
    268. 

  268.     if (msg3) perror(msg3);
    269. 

  269.     if (msg4) perror(msg4);
    270. 

  270.     clear();
    271. 

  271.     exit(1);
    272. 

  272. }
    273. 

  273. FILE* fo(const char* filename, const char* mode)
    274. 

  274. {
    275. 

  275. 	std::string longname = dir + filename;
    276. 

  276. 	FILE* ret = fopen(longname.c_str(),mode);
    277. 

  277. 	if (!ret)
    278. 

  278. 		error("Couldn't open ",longname.c_str(), " with mode ", mode);
    279. 

  279. 	else
    280. 

  280. 		printf("%s is opened.\n",longname.c_str());
    281. 

  281. 	return ret;
    282. 

  282. }
    283. 

  283. 

  284. 

  285. 

  286. void init_uinput()
    287. 

  287. {
    288. 

  288. 	clear();
    289. 

  289. 	int i;
    290. 

  290. //	FILE* kl = fopen("/android/system/usr/keylayout/AndroControll.kl","w");
    291. 

  291. #ifdef MYDEB
    292. 

  292. 	FILE* kl = fopen("/android/dev/AndroControll.kl","w");
    293. 

  293. #else
    294. 

  294. 	FILE* kl = fopen("/dev/AndroControll.kl","w");
    295. 

  295. #endif
    296. 

  296. 	if (!kl)
    297. 

  297. 	{
    298. 

  298. 		error("Couldn't open AndroControll.kl for writing.\n");
    299. 

  299. 	}
    300. 

  300. 	printf("AndroControll.kl is opened.\n");
    301. 

  301. 	i = 0;
    302. 

  302. 	while (KEYCODES[i].value)
    303. 

  303. 	{
    304. 

  304. 		fprintf(kl,"key %d   %s   WAKE\n",KEYCODES[i].value,KEYCODES[i].literal);
    305. 

  305. 		FAST* load = new FAST;
    306. 

  306. 		load->show = 0;
    307. 

  307. 		load->name = new char[strlen(KEYCODES[i].literal)+1];
    308. 

  308. 		strcpy(load->name,KEYCODES[i].literal);
    309. 

  309. 		load->ajax = 0;
    310. 

  310. 		fastkeys.push_back(load);
    311. 

  311. 		i++;
    312. 

  312. 	}
    313. 

  313. 	fclose(kl);
    314. 

  314. 

  315. 	FILE* fk = fo("fast_keys.txt","r");
    316. 

  316. 	int test;
    317. 

  317. 	int ajax, show, id;
    318. 

  318. 	while(fscanf(fk,"%d %d %d\n",&id,&show,&ajax) == 3)
    319. 

  319. 	{
    320. 

  320. 		if (id-1 < i)
    321. 

  321. 		{
    322. 

  322. 			fastkeys[id-1]->ajax = ajax;
    323. 

  323. 			fastkeys[id-1]->show = show;
    324. 

  324. 		}
    325. 

  325. 	}
    326. 

  326. 	fclose(fk);
    327. 

  327. 

  328. 	FILE* sk = fo("spec_keys.txt","r");
    329. 

  329. 	int disp, sms;
    330. 

  330. 	while(fscanf(sk,"%d %d %d\n",&sms,&ajax,&disp) == 3)
    331. 

  331. 	{
    332. 

  332. 		BIND* load = new BIND;
    333. 

  333. 		load->ajax = ajax;
    334. 

  334. 		load->disp = disp;
    335. 

  335. 		load->sms = sms;
    336. 

  336. 		speckeys.push_back(load);
    337. 

  337. 	}
    338. 

  338. 	fclose(sk);
    339. 

  339. 	
    340. 

  340. 

  341. //	FILE* kcm = fopen("/android/system/usr/keychars/AndroControll.kcm","w");
    342. 

  342. #ifdef MYDEB
    343. 

  343. 	FILE* kcm = fopen("/android/dev/AndroControll.kcm","w");
    344. 

  344. #else
    345. 

  345. 	FILE* kcm = fopen("/dev/AndroControll.kcm","w");
    346. 

  346. #endif
    347. 

  347. 	if (!kcm)
    348. 

  348. 	{
    349. 

  349. 		error("Couldn't open AndroControll.kcm for writing.\n");
    350. 

  350. 	}
    351. 

  351. 	printf("AndroControll.kcm is opened.\n");
    352. 

  352. 	fprintf(kcm,"[type=QWERTY]\n# keycode       display number  base    caps    alt     caps_alt\n");
    353. 

  353. 	for(i=0; i<53; i++)
    354. 

  354. 	{
    355. 

  355. 		int k = 0;
    356. 

  356. 		if (2*i < speckeys.size())
    357. 

  357. 		{
    358. 

  358. 			k = speckeys[2*i]->disp;
    359. 

  359. 			speckeys[2*i]->kcm_sh = false;
    360. 

  360. 			if (i<28)
    361. 

  361. 				speckeys[2*i]->kcm = 29+i;
    362. 

  362. 			if (28==i)
    363. 

  363. 				speckeys[2*i]->kcm = 77;
    364. 

  364. 			if (29==i)
    365. 

  365. 				speckeys[2*i]->kcm = 62;
    366. 

  366. 			if (30==i)
    367. 

  367. 				speckeys[2*i]->kcm = 66;
    368. 

  368. 			if (30<i && i<41)
    369. 

  369. 				speckeys[2*i]->kcm = i-31+7;
    370. 

  370. 			if (42==i)
    371. 

  371. 				speckeys[2*i]->kcm = 61;
    372. 

  372. 			//finish it....
    373. 

  373. 		}
    374. 

  374. 		int l = 0;
    375. 

  375. 		if (2*i+1 < speckeys.size())
    376. 

  376. 		{
    377. 

  377. 			l = speckeys[2*i+1]->disp;
    378. 

  378. 			speckeys[2*i+1]->kcm_sh = true;
    379. 

  379. 			if (i<28)
    380. 

  380. 				speckeys[2*i+1]->kcm = 29+i;
    381. 

  381. 			if (28==i)
    382. 

  382. 				speckeys[2*i+1]->kcm = 77;
    383. 

  383. 			if (29==i)
    384. 

  384. 				speckeys[2*i+1]->kcm = 62;
    385. 

  385. 			if (30==i)
    386. 

  386. 				speckeys[2*i+1]->kcm = 66;
    387. 

  387. 			if (30<i && i<41)
    388. 

  388. 				speckeys[2*i+1]->kcm = i-31+7;
    389. 

  389. 			if (42==i)
    390. 

  390. 				speckeys[2*i+1]->kcm = 61;
    391. 

  391. 			//finish it....
    392. 

  392. 		}
    393. 

  393. 		fprintf(kcm,"%s %d %d\n",KCM_BASE[i],k,l);
    394. 

  394. 	}
    395. 

  395. 	fclose(kcm);
    396. 

  396. //	if (compile("/android/system/usr/keychars/AndroControll.kcm","/android/system/usr/keychars/AndroControll.kcm.bin"))
    397. 

  397. #ifdef MYDEB
    398. 

  398. 	if (compile("/android/dev/AndroControll.kcm","/android/dev/AndroControll.kcm.bin"))
    399. 

  399. #else
    400. 

  400. 	if (compile("/dev/AndroControll.kcm","/dev/AndroControll.kcm.bin"))
    401. 

  401. #endif
    402. 

  402. 	{
    403. 

  403. 		error("Couldn't compile kcm to kcm.bin\n");
    404. 

  404. 	}
    405. 

  405. 	printf("kcm.bin is compiled.\n");
    406. 

  406. 

  407. 	struct input_id uid = {
    408. 

  408. 		0x06,//BUS_VIRTUAL, /* Bus type. */
    409. 

  409. 		1, /* Vendor id. */
    410. 

  410. 		1, /* Product id. */
    411. 

  411. 		1 /* Version id. */
    412. 

  412. 	};
    413. 

  413. //	uinput_fd = suinput_open("../../../sdcard/AndroControll", &uid);
    414. 

  414. 	printf("suinput init...\n");
    415. 

  415. 	std::string devname;
    416. 

  416. 	for (i=0; i < dirdepth; i++)
    417. 

  417. 		devname = devname + "../";
    418. 

  418. 	devname = devname + "dev/AndroControll";
    419. 

  419. 	uinput_fd = suinput_open(devname.c_str(), &uid);
    420. 

  420. }
    421. 

  421. 

  422. //from android-vnc-server
    423. 

  423. 

  424. static void init_fb(void)
    425. 

  425. {
    426. 

  426.         size_t pixels;
    427. 

  427. 

  428.         pixels = scrinfo.xres * scrinfo.yres;
    429. 

  429.         bytespp = scrinfo.bits_per_pixel / 8;
    430. 

  430. 

  431.         printf("xres=%d, yres=%d, xresv=%d, yresv=%d, xoffs=%d, yoffs=%d, bpp=%d\n",
    432. 

  432.           (int)scrinfo.xres, (int)scrinfo.yres,
    433. 

  433.           (int)scrinfo.xres_virtual, (int)scrinfo.yres_virtual,
    434. 

  434.           (int)scrinfo.xoffset, (int)scrinfo.yoffset,
    435. 

  435.           (int)scrinfo.bits_per_pixel);
    436. 

  436. 

  437. 

  438.         fbmmap = mmap(NULL, pixels * bytespp, PROT_READ, MAP_SHARED, fbfd, 0);
    439. 

  439. 

  440.         if (fbmmap == MAP_FAILED)
    441. 

  441.         {
    442. 

  442.                 perror("mmap");
    443. 

  443.                 exit(EXIT_FAILURE);
    444. 

  444.         }
    445. 

  445. 	pict  = new png_byte[scrinfo.yres*scrinfo.xres*3];
    446. 

  446. 	if (scrinfo.yres > scrinfo.xres)	//orientation might be changed
    447. 

  447. 		graph = new png_byte*[scrinfo.yres];
    448. 

  448. 	else
    449. 

  449. 		graph = new png_byte*[scrinfo.xres];
    450. 

  450. }
    451. 

  451. 

  452. void init_touch()
    453. 

  453. {
    454. 

  454. 	int i;
    455. 

  455. #ifdef MYDEB
    456. 

  456. 	char touch_device[26] = "/android/dev/input/event0";
    457. 

  457. #else
    458. 

  458. 	char touch_device[18] = "/dev/input/event0";
    459. 

  459. #endif
    460. 

  460. 	for (i=0; i<10; i++)
    461. 

  461. 	{
    462. 

  462. 		char name[256]="Unknown";
    463. 

  463. 		touch_device[sizeof(touch_device)-2] = '0'+(char)i;
    464. 

  464. 		struct input_absinfo info;
    465. 

  465. 		if((touchfd = open(touch_device, O_RDWR)) == -1)
    466. 

  466. 		{
    467. 

  467. 			continue;
    468. 

  468. 		}
    469. 

  469. 		printf("searching for touch device, opening %s ... ",touch_device);
    470. 

  470. 		// Get the Range of X and Y
    471. 

  471. 		if(ioctl(touchfd, EVIOCGABS(ABS_X), &info))
    472. 

  472. 		{
    473. 

  473. 			printf("failed\n");
    474. 

  474. 			close(touchfd);
    475. 

  475. 			touchfd = -1;
    476. 

  476. 			continue;
    477. 

  477. 		}
    478. 

  478. 		xmin = info.minimum;
    479. 

  479. 		xmax = info.maximum;
    480. 

  480. 		if(ioctl(touchfd, EVIOCGABS(ABS_Y), &info)) {
    481. 

  481. 			printf("failed\n");
    482. 

  482. 			close(touchfd);
    483. 

  483. 			touchfd = -1;
    484. 

  484. 			continue;
    485. 

  485. 		}
    486. 

  486. 		if (xmin < 0 || xmin == xmax)	// xmin < 0 for the compass
    487. 

  487. 		{
    488. 

  488. 			printf("failed\n");
    489. 

  489. 			close(touchfd);
    490. 

  490. 			touchfd = -1;
    491. 

  491. 			continue;
    492. 

  492. 		}
    493. 

  493. 		if (ioctl(touchfd, EVIOCGNAME(sizeof(name)),name) < 0)
    494. 

  494. 		{
    495. 

  495. 			printf("failed\n");
    496. 

  496. 			close(touchfd);
    497. 

  497. 			touchfd = -1;
    498. 

  498. 			continue;
    499. 

  499. 		}
    500. 

  500. 		printf("success, device name is %s\n",name);
    501. 

  501. 		ymin = info.minimum;
    502. 

  502. 		ymax = info.maximum;
    503. 

  503. 		printf("xmin = %d, xmax = %d, ymin = %d, ymax = %d\n",xmin,xmax,ymin,ymax);
    504. 

  504. 		return;
    505. 

  505. 	}
    506. 

  506. }
    507. 

  507. 

  508. void update_image(int orient,int lowres)
    509. 

  509. {
    510. 

  510. 	FILE            *fp;
    511. 

  511. 	png_structp     png_ptr;
    512. 

  512. 	png_infop       info_ptr;
    513. 

  513. 

  514. 	fp = fo("tmp.png", "wb");
    515. 

  515. 

  516. 	png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
    517. 

  517. 	info_ptr = png_create_info_struct(png_ptr);
    518. 

  518. 	png_init_io(png_ptr, fp);
    519. 

  519. 	png_set_compression_level(png_ptr, 1);
    520. 

  520. 

  521. 

  522. 	int rr = scrinfo.red.offset;
    523. 

  523. 	int rl = 8-scrinfo.red.length;
    524. 

  524. 	int gr = scrinfo.green.offset;
    525. 

  525. 	int gl = 8-scrinfo.green.length;
    526. 

  526. 	int br = scrinfo.blue.offset;
    527. 

  527. 	int bl = 8-scrinfo.blue.length;
    528. 

  528. 	int i = 0;
    529. 

  529. 	int j;
    530. 

  530. 	printf("rr=%d, rl=%d, gr=%d, gl=%d, br=%d, bl=%d\n",rr,rl,gr,gl,br,bl);
    531. 

  531. 	
    532. 

  532. 	if (orient == 0)
    533. 

  533. 		png_set_IHDR(png_ptr, info_ptr, scrinfo.xres>>lowres, scrinfo.yres>>lowres,
    534. 

  534. 			8,//  scrinfo.bits_per_pixel,
    535. 

  535. 			PNG_COLOR_TYPE_RGB, PNG_INTERLACE_NONE,
    536. 

  536. 			PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
    537. 

  537. 	else
    538. 

  538. 		png_set_IHDR(png_ptr, info_ptr, scrinfo.yres>>lowres, scrinfo.xres>>lowres,
    539. 

  539. 			8,//  scrinfo.bits_per_pixel,
    540. 

  540. 			PNG_COLOR_TYPE_RGB, PNG_INTERLACE_NONE,
    541. 

  541. 			PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
    542. 

  542. 

  543. 	int x = scrinfo.xres;
    544. 

  544. 	int y = scrinfo.yres;
    545. 

  545. 	int m = scrinfo.yres*scrinfo.xres;
    546. 

  546. 	int k;
    547. 

  547. 	int p = 0;
    548. 

  548. 	i = 0;
    549. 

  549. 	if (lowres) // I use if outside the for, maybe it's faster this way
    550. 

  550. 	{
    551. 

  551. 		if (bytespp == 2) //16 bit
    552. 

  552. 		{
    553. 

  553. 			unsigned short int* map = (unsigned short int*)fbmmap;
    554. 

  554. 			if (orient == 0) //vertical
    555. 

  555. 			{
    556. 

  556. 				for (j = 0; j < y; j+=2)
    557. 

  557. 				{
    558. 

  558. 					for (k = 0; k < x; k+=2)
    559. 

  559. 					{
    560. 

  560. 						pict[i++] = ((map[p]>>rr<<rl)+(map[p+1]>>rr<<rl)+(map[p+x]>>rr<<rl)+(map[p+x+1]>>rr<<rl)>>2);
    561. 

  561. 						pict[i++] = ((map[p]>>gr<<gl)+(map[p+1]>>gr<<gl)+(map[p+x]>>gr<<gl)+(map[p+x+1]>>gr<<gl)>>2);
    562. 

  562. 						pict[i++] = ((map[p]>>br<<bl)+(map[p+1]>>br<<bl)+(map[p+x]>>br<<bl)+(map[p+x+1]>>br<<bl)>>2);
    563. 

  563. 						p+=2;
    564. 

  564. 					}
    565. 

  565. 					p+=x;
    566. 

  566. 				}
    567. 

  567. 			}
    568. 

  568. 			else //horizontal
    569. 

  569. 			{
    570. 

  570. 				for (j = 0; j < x; j+=2)
    571. 

  571. 				{
    572. 

  572. 					p = (x-j-1);
    573. 

  573. 					for (k = 0; k < y; k+=2)
    574. 

  574. 					{
    575. 

  575. 						pict[i++] = ((map[p]>>rr<<rl)+(map[p-1]>>rr<<rl)+(map[p+x]>>rr<<rl)+(map[p+x-1]>>rr<<rl)>>2);
    576. 

  576. 						pict[i++] = ((map[p]>>gr<<gl)+(map[p-1]>>gr<<gl)+(map[p+x]>>gr<<gl)+(map[p+x-1]>>gr<<gl)>>2);
    577. 

  577. 						pict[i++] = ((map[p]>>br<<bl)+(map[p-1]>>br<<bl)+(map[p+x]>>br<<bl)+(map[p+x-1]>>br<<bl)>>2);
    578. 

  578. 						p += 2*x;
    579. 

  579. 					}
    580. 

  580. 				}
    581. 

  581. 			}
    582. 

  582. 		}
    583. 

  583. 		if (bytespp == 4) //32 bit
    584. 

  584. 		{
    585. 

  585. 			unsigned int* map = (unsigned int*)fbmmap;
    586. 

  586. 			if (orient == 0) //vertical
    587. 

  587. 			{
    588. 

  588. 				for (j = 0; j < y; j+=2)
    589. 

  589. 				{
    590. 

  590. 					for (k = 0; k < x; k+=2)
    591. 

  591. 					{
    592. 

  592. 						pict[i++] = ((map[p]>>rr<<rl)+(map[p+1]>>rr<<rl)+(map[p+x]>>rr<<rl)+(map[p+x+1]>>rr<<rl)>>2);
    593. 

  593. 						pict[i++] = ((map[p]>>gr<<gl)+(map[p+1]>>gr<<gl)+(map[p+x]>>gr<<gl)+(map[p+x+1]>>gr<<gl)>>2);
    594. 

  594. 						pict[i++] = ((map[p]>>br<<bl)+(map[p+1]>>br<<bl)+(map[p+x]>>br<<bl)+(map[p+x+1]>>br<<bl)>>2);
    595. 

  595. 						p+=2;
    596. 

  596. 					}
    597. 

  597. 					p+=x;
    598. 

  598. 				}
    599. 

  599. 			}
    600. 

  600. 			else //horizontal
    601. 

  601. 			{
    602. 

  602. 				for (j = 0; j < x; j+=2)
    603. 

  603. 				{
    604. 

  604. 					p = (x-j-1);
    605. 

  605. 					for (k = 0; k < y; k+=2)
    606. 

  606. 					{
    607. 

  607. 						pict[i++] = ((map[p]>>rr<<rl)+(map[p-1]>>rr<<rl)+(map[p+x]>>rr<<rl)+(map[p+x-1]>>rr<<rl)>>2);
    608. 

  608. 						pict[i++] = ((map[p]>>gr<<gl)+(map[p-1]>>gr<<gl)+(map[p+x]>>gr<<gl)+(map[p+x-1]>>gr<<gl)>>2);
    609. 

  609. 						pict[i++] = ((map[p]>>br<<bl)+(map[p-1]>>br<<bl)+(map[p+x]>>br<<bl)+(map[p+x-1]>>br<<bl)>>2);
    610. 

  610. 						p += 2*x;
    611. 

  611. 					}
    612. 

  612. 				}
    613. 

  613. 			}
    614. 

  614. 		}
    615. 

  615. 	}
    616. 

  616. 	else //hires
    617. 

  617. 	{
    618. 

  618. 		if (bytespp == 2)
    619. 

  619. 		{
    620. 

  620. 			unsigned short int* map = (unsigned short int*)fbmmap;
    621. 

  621. 			if (orient == 0) //vertical
    622. 

  622. 			{
    623. 

  623. 				for (j = 0; j < m; j++)
    624. 

  624. 				{
    625. 

  625. 					pict[i++] = map[j]>>rr<<rl;
    626. 

  626. 					pict[i++] = map[j]>>gr<<gl;
    627. 

  627. 					pict[i++] = map[j]>>br<<bl;
    628. 

  628. 				}
    629. 

  629. 			}
    630. 

  630. 			else //horizontal
    631. 

  631. 			{
    632. 

  632. 				for (j = 0; j < x; j++)
    633. 

  633. 				{
    634. 

  634. 					p = (x-j-1);
    635. 

  635. 					for (k = 0; k < y; k++)
    636. 

  636. 					{
    637. 

  637. 						pict[i++] = map[p]>>rr<<rl;
    638. 

  638. 						pict[i++] = map[p]>>gr<<gl;
    639. 

  639. 						pict[i++] = map[p]>>br<<bl;
    640. 

  640. 						p += x;
    641. 

  641. 					}
    642. 

  642. 				}
    643. 

  643. 			}
    644. 

  644. 		}
    645. 

  645. 		if (bytespp == 4)
    646. 

  646. 		{
    647. 

  647. 			unsigned int* map = (unsigned int*)fbmmap;
    648. 

  648. 			if (orient == 0) //vertical
    649. 

  649. 			{
    650. 

  650. 				for (j = 0; j < m; j++)
    651. 

  651. 				{
    652. 

  652. 					pict[i++] = map[j]>>rr<<rl;
    653. 

  653. 					pict[i++] = map[j]>>gr<<gl;
    654. 

  654. 					pict[i++] = map[j]>>br<<bl;
    655. 

  655. 				}
    656. 

  656. 			}
    657. 

  657. 			else //horizontal
    658. 

  658. 			{
    659. 

  659. 				for (j = 0; j < x; j++)
    660. 

  660. 				{
    661. 

  661. 					p = (x-j-1);
    662. 

  662. 					for (k = 0; k < y; k++)
    663. 

  663. 					{
    664. 

  664. 						pict[i++] = map[p]>>rr<<rl;
    665. 

  665. 						pict[i++] = map[p]>>gr<<gl;
    666. 

  666. 						pict[i++] = map[p]>>br<<bl;
    667. 

  667. 						p += x;
    668. 

  668. 					}
    669. 

  669. 				}
    670. 

  670. 			}
    671. 

  671. 		}
    672. 

  672. 	}
    673. 

  673. 	if (orient == 0)
    674. 

  674. 	{
    675. 

  675. 		for (i = 0; i < y>>lowres; i++)
    676. 

  676. 			graph[i] = pict+(i*x*3>>lowres);
    677. 

  677. 	}	
    678. 

  678. 	else
    679. 

  679. 	{
    680. 

  680. 		for (i = 0; i < x>>lowres; i++)
    681. 

  681. 			graph[i] = pict+(i*y*3>>lowres);
    682. 

  682. 	}
    683. 

  683. 

  684. 	png_write_info(png_ptr, info_ptr);
    685. 

  685. 	png_write_image(png_ptr, graph);
    686. 

  686. 	png_write_end(png_ptr, info_ptr);
    687. 

  687. 	png_destroy_write_struct(&png_ptr, &info_ptr);
    688. 

  688. 	fclose(fp);
    689. 

  689. }
    690. 

  690. 

  691. static void
    692. 

  692. touch(struct mg_connection *conn,
    693. 

  693.                 const struct mg_request_info *ri, void *data)
    694. 

  694. {
    695. 

  695. 	int n = strlen(ri->uri);
    696. 

  696.        	if (n<8)
    697. 

  697. 		return;
    698. 

  698. 	int orient = 0;
    699. 

  699. 	if (ri->uri[7]=='h')
    700. 

  700. 		orient = 1;
    701. 

  701. 	int i = 8;
    702. 

  702. 	int x = getnum(ri->uri+i);
    703. 

  703. 	while (i<n && ri->uri[i++]!='_');
    704. 

  704. 	int y = getnum(ri->uri+i);
    705. 

  705. 	while (i<n && ri->uri[i++]!='_');
    706. 

  706. 	int down = getnum(ri->uri+i);
    707. 

  707. 	if(touchfd != -1 && scrinfo.xres && scrinfo.yres)
    708. 

  708. 	{
    709. 

  709. 		struct input_event ev;
    710. 

  710. 

  711. 		if (orient)
    712. 

  712. 		{
    713. 

  713. 			int t = x;
    714. 

  714. 			x = scrinfo.xres-y;
    715. 

  715. 			y = t;
    716. 

  716. 		}
    717. 

  717. 		if (x < 0) x = 0;
    718. 

  718. 		if (y < 0) y = 0;
    719. 

  719. 		if (x > scrinfo.xres) x = scrinfo.xres;
    720. 

  720. 		if (y > scrinfo.yres) y = scrinfo.yres;
    721. 

  721. 		// Calculate the final x and y
    722. 

  722. 		x = xmin + (x * (xmax - xmin)) / (scrinfo.xres);
    723. 

  723. 		y = ymin + (y * (ymax - ymin)) / (scrinfo.yres);
    724. 

  724. 

  725. 		memset(&ev, 0, sizeof(ev));
    726. 

  726. 

  727. 		// Then send a BTN_TOUCH
    728. 

  728. 		if (down != 2)
    729. 

  729. 		{
    730. 

  730. 			gettimeofday(&ev.time,0);
    731. 

  731. 			ev.type = EV_KEY;
    732. 

  732. 			ev.code = BTN_TOUCH;
    733. 

  733. 			ev.value = down;
    734. 

  734. 			if(write(touchfd, &ev, sizeof(ev)) < 0)
    735. 

  735. 				printf("touchfd write failed.\n");
    736. 

  736. 		}
    737. 

  737. 		gettimeofday(&ev.time,0);
    738. 

  738. 		ev.type = EV_ABS;
    739. 

  739. 		ev.code = 48;
    740. 

  740. 		ev.value = down>0?100:0;
    741. 

  741. 		if(write(touchfd, &ev, sizeof(ev)) < 0)
    742. 

  742. 			printf("touchfd write failed.\n");
    743. 

  743. 		// Then send the X
    744. 

  744. 		gettimeofday(&ev.time,0);
    745. 

  745. 		ev.type = EV_ABS;
    746. 

  746. 		ev.code = ABS_X;
    747. 

  747. 		ev.value = x;
    748. 

  748. 		if(write(touchfd, &ev, sizeof(ev)) < 0)
    749. 

  749. 			printf("touchfd write failed.\n");
    750. 

  750. 		// Then send the X
    751. 

  751. 		gettimeofday(&ev.time,0);
    752. 

  752. 		ev.type = EV_ABS;
    753. 

  753. 		ev.code = 53;//ABS_X;
    754. 

  754. 		ev.value = x;
    755. 

  755. 		if(write(touchfd, &ev, sizeof(ev)) < 0)
    756. 

  756. 			printf("touchfd write failed.\n");
    757. 

  757. 

  758. 		// Then send the Y
    759. 

  759. 		gettimeofday(&ev.time,0);
    760. 

  760. 		ev.type = EV_ABS;
    761. 

  761. 		ev.code = ABS_Y;
    762. 

  762. 		ev.value = y;
    763. 

  763. 		if(write(touchfd, &ev, sizeof(ev)) < 0)
    764. 

  764. 			printf("touchfd write failed.\n");
    765. 

  765. 		// Then send the Y
    766. 

  766. 		gettimeofday(&ev.time,0);
    767. 

  767. 		ev.type = EV_ABS;
    768. 

  768. 		ev.code = 54;//ABS_Y;
    769. 

  769. 		ev.value = y;
    770. 

  770. 		if(write(touchfd, &ev, sizeof(ev)) < 0)
    771. 

  771. 			printf("touchfd write failed.\n");
    772. 

  772. 

  773. 		// Finally send the SYN
    774. 

  774. 		gettimeofday(&ev.time,0);
    775. 

  775. 		ev.type = EV_SYN;
    776. 

  776. 		ev.code = 2;
    777. 

  777. 		ev.value = 0;
    778. 

  778. 		if(write(touchfd, &ev, sizeof(ev)) < 0)
    779. 

  779. 			printf("touchfd write failed.\n");
    780. 

  780. 		gettimeofday(&ev.time,0);
    781. 

  781. 		ev.type = EV_SYN;
    782. 

  782. 		ev.code = 0;
    783. 

  783. 		ev.value = 0;
    784. 

  784. 		if(write(touchfd, &ev, sizeof(ev)) < 0)
    785. 

  785. 			printf("touchfd write failed.\n");
    786. 

  786. 

  787. 		//printf("%d. injectTouch x=%d, y=%d, down=%d\n", touchcount++, x, y, down);    
    788. 

  788. 

  789. 	}
    790. 

  790. 	send_ok(conn);
    791. 

  791. }
    792. 

  792. static void
    793. 

  793. key(struct mg_connection *conn,
    794. 

  794.                 const struct mg_request_info *ri, void *data)
    795. 

  795. {
    796. 

  796. 	bool sms_mode = false;
    797. 

  797. 	int key = 0;
    798. 

  798. 	bool old = false;
    799. 

  799. 	int orient = 0;
    800. 

  800. 	printf("%s\n",ri->uri);
    801. 

  801. 		// /oldkey_hn-22 -> -22 key with normal mode, horisontal
    802. 

  802. 	int n = 0;
    803. 

  803. 	if (startswith(ri->uri,"/oldkey") && strlen(ri->uri)>10) 
    804. 

  804. 	{
    805. 

  805. 		n = 9;
    806. 

  806. 		old = true;
    807. 

  807. 	}
    808. 

  808. 	else
    809. 

  809. 	if (strlen(ri->uri)>6)
    810. 

  810. 	{
    811. 

  811. 		n = 6;
    812. 

  812. 	}
    813. 

  813. 	else
    814. 

  814. 		return;
    815. 

  815. 	if (ri->uri[n-2] == 'h')
    816. 

  816. 		orient = 1;
    817. 

  817. 	if (ri->uri[n-1] == 's')
    818. 

  818. 		sms_mode = true;
    819. 

  819. 	if (ri->uri[++n] == 0)
    820. 

  820. 		return;
    821. 

  821. 	send_ok(conn);
    822. 

  822. 	while(1)
    823. 

  823. 	{
    824. 

  824. 		key = getnum(ri->uri+n);
    825. 

  825. 		if (old && key < 0)
    826. 

  826. 			key = -key;
    827. 

  827. 		if (key == 0) // I don't know how, but it happens
    828. 

  828. 		{
    829. 

  829. 			send_ok(conn);
    830. 

  830. 			return;
    831. 

  831. 		}
    832. 

  832. 		printf("KEY %d\n",key);
    833. 

  833. 		int i;
    834. 

  834. 		if (sms_mode)
    835. 

  835. 			for (i=0; i < speckeys.size(); i++)
    836. 

  836. 				if ((speckeys[i]->ajax == key || (old && speckeys[i]->ajax == -key)) && speckeys[i]->sms)
    837. 

  837. 				{
    838. 

  838. 					printf("pressed: %d\n",speckeys[i]->kcm);
    839. 

  839. 					suinput_press(uinput_fd, 57); //left alt
    840. 

  840. 					if (speckeys[i]->kcm_sh)
    841. 

  841. 						suinput_press(uinput_fd, 59); //left shift
    842. 

  842. 					suinput_click(uinput_fd, speckeys[i]->kcm);
    843. 

  843. 					suinput_release(uinput_fd, 57); //left alt
    844. 

  844. 					if (speckeys[i]->kcm_sh)
    845. 

  845. 						suinput_release(uinput_fd, 59); //left shift
    846. 

  846. 					break;
    847. 

  847. 				}
    848. 

  848. 		if (!sms_mode || i == speckeys.size())
    849. 

  849. 			for (i=0; i < speckeys.size(); i++)
    850. 

  850. 				if ((speckeys[i]->ajax == key|| (old && speckeys[i]->ajax == -key) ) && speckeys[i]->sms == false)
    851. 

  851. 				{
    852. 

  852. 					printf("pressed: %d\n",speckeys[i]->kcm);
    853. 

  853. 					suinput_press(uinput_fd, 57); //left alt
    854. 

  854. 					if (speckeys[i]->kcm_sh)
    855. 

  855. 						suinput_press(uinput_fd, 59); //left shift
    856. 

  856. 					suinput_click(uinput_fd, speckeys[i]->kcm);
    857. 

  857. 					suinput_release(uinput_fd, 57); //left alt
    858. 

  858. 					if (speckeys[i]->kcm_sh)
    859. 

  859. 						suinput_release(uinput_fd, 59); //left shift
    860. 

  860. 				}
    861. 

  861. 		for (i=0; i < fastkeys.size(); i++)
    862. 

  862. 			if (fastkeys[i]->ajax == key || (old && fastkeys[i]->ajax == -key))
    863. 

  863. 			{
    864. 

  864. 				int k = i+1;
    865. 

  865. 				if (orient)
    866. 

  866. 				{
    867. 

  867. 					if (k == 19) //up -> right
    868. 

  868. 						k = 22;
    869. 

  869. 					else if (k == 20) //down -> left
    870. 

  870. 						k = 21;
    871. 

  871. 					else if (k == 21) //left -> up
    872. 

  872. 						k = 19;
    873. 

  873. 					else if (k == 22) //right -> down
    874. 

  874. 						k = 20;
    875. 

  875. 				}
    876. 

  876. 				suinput_click(uinput_fd, k);
    877. 

  877. 			}
    878. 

  878. 		if (48<=key && key < 58)
    879. 

  879. 			suinput_click(uinput_fd, key-48+7);
    880. 

  880. 		if (97<=key && key < 123)
    881. 

  881. 			suinput_click(uinput_fd, key-97+29);
    882. 

  882. 		if (65<=key && key < 91)
    883. 

  883. 		{
    884. 

  884. 			suinput_press(uinput_fd, 59); //left shift
    885. 

  885. 			suinput_click(uinput_fd, key-65+29);
    886. 

  886. 			suinput_release(uinput_fd, 59); //left shift
    887. 

  887. 		}
    888. 

  888. 		if (32<=key && key <= 47)
    889. 

  889. 		{
    890. 

  890. 			if (spec1sh[key-32]) suinput_press(uinput_fd, 59); //left shift
    891. 

  891. 			suinput_click(uinput_fd, spec1[key-32]);
    892. 

  892. 			if (spec1sh[key-32]) suinput_release(uinput_fd, 59); //left shift
    893. 

  893. 		}
    894. 

  894. 		if (58<=key && key <= 64)
    895. 

  895. 		{
    896. 

  896. 			if (spec2sh[key-58]) suinput_press(uinput_fd, 59); //left shift
    897. 

  897. 			suinput_click(uinput_fd, spec2[key-58]);
    898. 

  898. 			if (spec2sh[key-58]) suinput_release(uinput_fd, 59); //left shift
    899. 

  899. 		}
    900. 

  900. 		if (91<=key && key <= 96)
    901. 

  901. 		{
    902. 

  902. 			if (spec3sh[key-91]) suinput_press(uinput_fd, 59); //left shift
    903. 

  903. 			suinput_click(uinput_fd, spec3[key-91]);
    904. 

  904. 			if (spec3sh[key-91]) suinput_release(uinput_fd, 59); //left shift
    905. 

  905. 		}
    906. 

  906. 		if (123<=key && key <= 127)
    907. 

  907. 		{
    908. 

  908. 			if (spec4sh[key-123]) suinput_press(uinput_fd, 59); //left shift
    909. 

  909. 			suinput_click(uinput_fd, spec4[key-123]);
    910. 

  910. 			if (spec4sh[key-123]) suinput_release(uinput_fd, 59); //left shift
    911. 

  911. 		}
    912. 

  912. 		if (key == -8 || (old && key == 8)) suinput_click(uinput_fd, 67); //BACKSPACE -> DEL
    913. 

  913. 		if (key == -13 || (old && key == 13)) suinput_click(uinput_fd, 66); //ENTER
    914. 

  914. 		while (ri->uri[n] != '_')
    915. 

  915. 		{
    916. 

  916. 		       if (ri->uri[++n] == 0)
    917. 

  917. 			       return;
    918. 

  918. 		}
    919. 

  919. 		if (ri->uri[++n] == 0)
    920. 

  920. 			return;
    921. 

  921. 		usleep(1000);
    922. 

  922. 	}
    923. 

  923. 

  924. }
    925. 

  925. 

  926. 

  927. static void
    928. 

  928. savebuttons(struct mg_connection *conn,
    929. 

  929.                 const struct mg_request_info *ri, void *data)
    930. 

  930. {
    931. 

  931. 	int i;
    932. 

  932. 	for (i=0; i < fastkeys.size(); i++)
    933. 

  933. 		fastkeys[i]->show = false;
    934. 

  934. 	int n = ri->post_data_len;
    935. 

  935. 	i = 0;
    936. 

  936. 	while(i<n)
    937. 

  937. 	{
    938. 

  938. 		if (startswith(ri->post_data+i,"show_"))
    939. 

  939. 		{
    940. 

  940. 			i+=5;
    941. 

  941. 			int id = getnum(ri->post_data+i);
    942. 

  942. 			if (id-1<fastkeys.size())
    943. 

  943. 				fastkeys[id-1]->show = true;
    944. 

  944. 			printf("SHOW %d\n",id-1);
    945. 

  945. 		}
    946. 

  946. 		else if (startswith(ri->post_data+i,"keycode_"))
    947. 

  947. 		{
    948. 

  948. 			i+=8;
    949. 

  949. 			int id = getnum(ri->post_data+i);
    950. 

  950. 			while (i<n && ri->post_data[i++]!='=');
    951. 

  951. 			int ajax = getnum(ri->post_data+i);
    952. 

  952. 			if (id-1<fastkeys.size())
    953. 

  953. 				fastkeys[id-1]->ajax = ajax;
    954. 

  954. 		}
    955. 

  955. 		while (i<n && ri->post_data[i++]!='&');
    956. 

  956. 	}
    957. 

  957. 

  958. 	FILE* fk = fo("fast_keys.txt","w");
    959. 

  959. 	for (i=0;i<fastkeys.size();i++)
    960. 

  960. 	{
    961. 

  961. 		fprintf(fk,"%d %d %d\n",i+1,fastkeys[i]->show,fastkeys[i]->ajax);
    962. 

  962. 	}
    963. 

  963. 	fclose(fk);
    964. 

  964. 	mg_printf(conn,"HTTP/1.1 200 OK\r\nContent-Type: text/html; charset=utf-8\r\n\r\n<html><head><meta http-equiv=\"refresh\" content=\"0;url=/\"></head><body>redirecting</body></html>");
    965. 

  965. 

  966. }
    967. 

  967. static void
    968. 

  968. savekeys(struct mg_connection *conn,
    969. 

  969.                 const struct mg_request_info *ri, void *data)
    970. 

  970. {
    971. 

  971. 	int i;
    972. 

  972. 	int n = ri->post_data_len;
    973. 

  973. 	for (i=0; i < speckeys.size(); i++)
    974. 

  974. 		if (speckeys[i])
    975. 

  975. 			delete speckeys[i];
    976. 

  976. 	speckeys.clear();
    977. 

  977. 	for (i=0; i < 106; i++)
    978. 

  978. 	{
    979. 

  979. 		BIND* load = new BIND;
    980. 

  980. 		load->ajax = load->disp = load->sms = 0;
    981. 

  981. 		speckeys.push_back(load);
    982. 

  982. 	}
    983. 

  983. 	i = 0;
    984. 

  984. 	while(i<n)
    985. 

  985. 	{
    986. 

  986. 		if (startswith(ri->post_data+i,"sms_"))
    987. 

  987. 		{
    988. 

  988. 			i+=4;
    989. 

  989. 			int id = getnum(ri->post_data+i);
    990. 

  990. 			if (id-1<speckeys.size())
    991. 

  991. 				speckeys[id-1]->sms = true;
    992. 

  992. 		}
    993. 

  993. 		else if (startswith(ri->post_data+i,"keycode_"))
    994. 

  994. 		{
    995. 

  995. 			i+=8;
    996. 

  996. 			int id = getnum(ri->post_data+i);
    997. 

  997. 			while (i<n && ri->post_data[i++]!='=');
    998. 

  998. 			int ajax = getnum(ri->post_data+i);
    999. 

  999. 			if (id-1<speckeys.size())
    1000. 

  1000. 				speckeys[id-1]->ajax = ajax;
    1001. 

  1001. 		}
    1002. 

  1002. 		else if (startswith(ri->post_data+i,"tokeycode_"))
    1003. 

  1003. 		{
    1004. 

  1004. 			i+=10;
    1005. 

  1005. 			int id = getnum(ri->post_data+i);
    1006. 

  1006. 			while (i<n && ri->post_data[i++]!='=');
    1007. 

  1007. 			int disp = getnum(ri->post_data+i);
    1008. 

  1008. 			if (id-1<speckeys.size())
    1009. 

  1009. 				speckeys[id-1]->disp = disp;
    1010. 

  1010. 		}
    1011. 

  1011. 		while (i<n && ri->post_data[i++]!='&');
    1012. 

  1012. 	}
    1013. 

  1013. 

  1014. 	FILE* sk = fo("spec_keys.txt","w");
    1015. 

  1015. 	for(i=0; i <speckeys.size(); i++)
    1016. 

  1016. 		if (speckeys[i]->ajax || speckeys[i]->disp || speckeys[i]->disp)
    1017. 

  1017. 			fprintf(sk,"%d %d %d\n",speckeys[i]->sms,speckeys[i]->ajax,speckeys[i]->disp);
    1018. 

  1018. 	fclose(sk);
    1019. 

  1019. 	init_uinput();
    1020. 

  1020. 	mg_printf(conn,"HTTP/1.1 200 OK\r\nContent-Type: text/html; charset=utf-8\r\n\r\n<html><head><meta http-equiv=\"refresh\" content=\"0;url=/\"></head><body>redirecting</body></html>");
    1021. 

  1021. }
    1022. 

  1022. 

  1023. static void
    1024. 

  1024. helppng(struct mg_connection *conn,
    1025. 

  1025.                 const struct mg_request_info *ri, void *data)
    1026. 

  1026. {
    1027. 

  1027. 	send_ok(conn);
    1028. 

  1028. 	FILE* f = fo("help.png","rb");
    1029. 

  1029. 	fseek (f , 0 , SEEK_END);
    1030. 

  1030. 	int lSize = ftell (f);
    1031. 

  1031. 	rewind (f);
    1032. 

  1032. 	char* filebuffer = new char[lSize+1];
    1033. 

  1033. 	fread(filebuffer,1,lSize,f);
    1034. 

  1034. 	filebuffer[lSize] = 0;
    1035. 

  1035. 	mg_write(conn,filebuffer,lSize);
    1036. 

  1036. 	fclose(f);
    1037. 

  1037. }
    1038. 

  1038. static void
    1039. 

  1039. helphtml(struct mg_connection *conn,
    1040. 

  1040.                 const struct mg_request_info *ri, void *data)
    1041. 

  1041. {
    1042. 

  1042. 	send_ok(conn);
    1043. 

  1043. 	FILE* f = fo("help.html","rb");
    1044. 

  1044. 	fseek (f , 0 , SEEK_END);
    1045. 

  1045. 	int lSize = ftell (f);
    1046. 

  1046. 	rewind (f);
    1047. 

  1047. 	char* filebuffer = new char[lSize+1];
    1048. 

  1048. 	fread(filebuffer,1,lSize,f);
    1049. 

  1049. 	filebuffer[lSize] = 0;
    1050. 

  1050. 	mg_write(conn,filebuffer,lSize);
    1051. 

  1051. 	fclose(f);
    1052. 

  1052. }
    1053. 

  1053. static void
    1054. 

  1054. index(struct mg_connection *conn,
    1055. 

  1055.                 const struct mg_request_info *ri, void *data)
    1056. 

  1056. {
    1057. 

  1057. 	send_ok(conn);
    1058. 

  1058. 	FILE* f = fo("index.html","rb");
    1059. 

  1059. 	fseek (f , 0 , SEEK_END);
    1060. 

  1060. 	int lSize = ftell (f);
    1061. 

  1061. 	rewind (f);
    1062. 

  1062. 	char* filebuffer = new char[lSize+1];
    1063. 

  1063. 	fread(filebuffer,1,lSize,f);
    1064. 

  1064. 	filebuffer[lSize] = 0;
    1065. 

  1065. 	mg_write(conn,filebuffer,lSize);
    1066. 

  1066. 	fclose(f);
    1067. 

  1067. 	int i;
    1068. 

  1068. 	for (i=0; i < fastkeys.size(); i++)
    1069. 

  1069. 		if (fastkeys[i]->show)
    1070. 

  1070. 		{
    1071. 

  1071. 			mg_printf(conn,"<input type=\"button\" class=\"butt\" value=\"%s\" onclick=\"makeRequest('button_%d','')\"/>",fastkeys[i]->name,i+1);
    1072. 

  1072. 		}
    1073. 

  1073. 	mg_printf(conn,"</div><div id=\"res\">results</div></div><script type=\"text/javascript\" language=\"javascript\">document.images.screenshot.onmousemove=move; function setWidth(orient){ if (orient == 1) document.images.screenshot.width=\"%d\"; else document.images.screenshot.width=\"%d\";}</script></body></html>",scrinfo.yres,scrinfo.xres);
    1074. 

  1074. 	delete[] filebuffer;
    1075. 

  1075. }
    1076. 

  1076. static void
    1077. 

  1077. button(struct mg_connection *conn,
    1078. 

  1078.                 const struct mg_request_info *ri, void *data)
    1079. 

  1079. {
    1080. 

  1080. 	int key = getnum(ri->uri+8);
    1081. 

  1081. 	printf("button %d\n",key);
    1082. 

  1082. 	suinput_click(uinput_fd, key);
    1083. 

  1083. 	send_ok(conn);
    1084. 

  1084. }
    1085. 

  1085. static void
    1086. 

  1086. config_buttons(struct mg_connection *conn,
    1087. 

  1087.                 const struct mg_request_info *ri, void *data)
    1088. 

  1088. {
    1089. 

  1089. 	FILE* f = fo("config_buttons.html","rb");
    1090. 

  1090. 	fseek (f , 0 , SEEK_END);
    1091. 

  1091. 	printf("file fseeked\n");
    1092. 

  1092. 	int lSize = ftell (f);
    1093. 

  1093. 	printf("file ftold, size=%d\n",lSize);
    1094. 

  1094. 	rewind (f);
    1095. 

  1095. 	printf("file rewinded\n");
    1096. 

  1096. 	char* filebuffer = new char[lSize+1];
    1097. 

  1097. 	fread(filebuffer,1,lSize,f);
    1098. 

  1098. 	printf("file read\n");
    1099. 

  1099. 	filebuffer[lSize] = 0;
    1100. 

  1100. 	mg_write(conn,filebuffer,lSize);
    1101. 

  1101. 	printf("file sent\n");
    1102. 

  1102. 	fclose(f);
    1103. 

  1103. 	printf("file closed\n");
    1104. 

  1104. 	mg_printf(conn,"<table border=\"1\">\n");
    1105. 

  1105. 	int i;
    1106. 

  1106. 	for (i=0; i < fastkeys.size(); i++)
    1107. 

  1107. 	{
    1108. 

  1108. 		mg_printf(conn, "<tr><td>%s</td><td><input type=\"checkbox\" name=\"show_%d\">Show</input></td><td>Key: <input type=\"text\" name=\"key_%d\" maxlength=\"1\" size=\"1\" onkeypress=\"var unicode=event.charCode? event.charCode : -event.keyCode;document.config_buttons.keycode_%d.value=unicode; document.config_buttons.key_%d.value=String.fromCharCode(document.config_buttons.keycode_%d.value)\"/></td><td>Keycode: <input type=\"text\" name=\"keycode_%d\" maxlength=\"8\" size=\"8\" onkeyup=\"document.config_buttons.key_%d.value=String.fromCharCode(document.config_buttons.keycode_%d.value)\"/></td></tr>\n",fastkeys[i]->name,i+1,i+1,i+1,i+1,i+1,i+1,i+1,i+1);
    1109. 

  1109. 	}
    1110. 

  1110. 	mg_printf(conn,"</table></form>\n<script type=\"text/javascript\" language=\"javascript\">");
    1111. 

  1111. 

  1112. 	for (i=0; i < fastkeys.size(); i++)
    1113. 

  1113. 	{
    1114. 

  1114. 		mg_printf(conn,"document.config_buttons.key_%d.value=String.fromCharCode(%d);document.config_buttons.keycode_%d.value='%d';document.config_buttons.show_%d",i+1,fastkeys[i]->ajax,i+1,fastkeys[i]->ajax,i+1);
    1115. 

  1115. 		if (fastkeys[i]->show)
    1116. 

  1116. 			mg_printf(conn,".checked='checked';\n");
    1117. 

  1117. 		else
    1118. 

  1118. 			mg_printf(conn,".checked='';\n");
    1119. 

  1119. 	}
    1120. 

  1120. 	mg_printf(conn,"</script></body></html>");
    1121. 

  1121. 

  1122. 	delete[] filebuffer;
    1123. 

  1123. }
    1124. 

  1124. static void
    1125. 

  1125. config_keys(struct mg_connection *conn,
    1126. 

  1126.                 const struct mg_request_info *ri, void *data)
    1127. 

  1127. {
    1128. 

  1128. 	FILE* f = fo("config_keys.html","rb");
    1129. 

  1129. 	fseek (f , 0 , SEEK_END);
    1130. 

  1130. 	printf("file fseeked\n");
    1131. 

  1131. 	int lSize = ftell (f);
    1132. 

  1132. 	printf("file ftold, size=%d\n",lSize);
    1133. 

  1133. 	rewind (f);
    1134. 

  1134. 	printf("file rewinded\n");
    1135. 

  1135. 	char* filebuffer = new char[lSize+1];
    1136. 

  1136. 	fread(filebuffer,1,lSize,f);
    1137. 

  1137. 	printf("file read\n");
    1138. 

  1138. 	filebuffer[lSize] = 0;
    1139. 

  1139. 	mg_write(conn,filebuffer,lSize);
    1140. 

  1140. 	printf("file sent\n");
    1141. 

  1141. 	fclose(f);
    1142. 

  1142. 	printf("file closed\n");
    1143. 

  1143. 	mg_printf(conn,"<table border=\"1\">\n");
    1144. 

  1144. 	int i;
    1145. 

  1145. 	for (i=0; i < 106; i++)
    1146. 

  1146. 	{
    1147. 

  1147. 		mg_printf(conn,"<tr><td>Char: <input type=\"text\" name=\"key_%d\" maxlength=\"1\" size=\"1\" onkeypress=\"var unicode=event.charCode? event.charCode : event.keyCode;document.config_keys.keycode_%d.value=unicode; document.config_keys.key_%d.value=String.fromCharCode(document.config_keys.keycode_%d.value)\"/></td><td>Keycode: <input type=\"text\" name=\"keycode_%d\" maxlength=\"8\" size=\"8\" onkeyup=\"document.config_keys.key_%d.value=String.fromCharCode(document.config_keys.keycode_%d.value)\"/></td><td> converts to </td><td>Char: <input type=\"text\" name=\"tokey_%d\" maxlength=\"1\" size=\"1\" onkeypress=\"var unicode=event.charCode? event.charCode : event.keyCode;document.config_keys.tokeycode_%d.value=unicode; document.config_keys.tokey_%d.value=String.fromCharCode(document.config_keys.tokeycode_%d.value)\"/></td><td>Keycode: <input type=\"text\" name=\"tokeycode_%d\" maxlength=\"8\" size=\"8\" onkeyup=\"document.config_keys.tokey_%d.value=String.fromCharCode(document.config_keys.tokeycode_%d.value)\"/></td><td><input type=\"checkbox\" name=\"sms_%d\">works in SMS mode</input></td></tr>\n",i+1,i+1,i+1,i+1,i+1,i+1,i+1,i+1,i+1,i+1,i+1,i+1,i+1,i+1,i+1);
    1148. 

  1148. 	}
    1149. 

  1149. 	mg_printf(conn,"</table></form>\n<script type=\"text/javascript\" language=\"javascript\">\n");
    1150. 

  1150. 

  1151. 	for (i=0; i < speckeys.size(); i++)
    1152. 

  1152. 	{
    1153. 

  1153. 		mg_printf(conn,"document.config_keys.key_%d.value=String.fromCharCode(%d);document.config_keys.keycode_%d.value='%d';document.config_keys.tokey_%d.value=String.fromCharCode(%d);document.config_keys.tokeycode_%d.value='%d';document.config_keys.sms_%d",i+1,speckeys[i]->ajax,i+1,speckeys[i]->ajax,i+1,speckeys[i]->disp,i+1,speckeys[i]->disp,i+1);
    1154. 

  1154. 		if (speckeys[i]->sms)
    1155. 

  1155. 			mg_printf(conn,".checked='checked';\n");
    1156. 

  1156. 		else
    1157. 

  1157. 			mg_printf(conn,".checked='';\n");
    1158. 

  1158. 	}
    1159. 

  1159. 	mg_printf(conn,"</script></body></html>");
    1160. 

  1160. 

  1161. 	delete[] filebuffer;
    1162. 

  1162. }
    1163. 

  1163. static void
    1164. 

  1164. config(struct mg_connection *conn,
    1165. 

  1165.                 const struct mg_request_info *ri, void *data)
    1166. 

  1166. {
    1167. 

  1167.         int n = ri->post_data_len;
    1168. 

  1168. 	int i = 0;
    1169. 

  1169. 	char name[256];
    1170. 

  1170. 	char pass[256];
    1171. 

  1171. 	bool changed = false;
    1172. 

  1172. 	int j = 0;
    1173. 

  1173. 	while(i < n)
    1174. 

  1174. 	{
    1175. 

  1175. 		printf("%s\n",ri->post_data);
    1176. 

  1176. 		if (!memcmp(ri->post_data+i, "username",8))
    1177. 

  1177. 		{	
    1178. 

  1178. 			i+=9;
    1179. 

  1179. 			j = 0;
    1180. 

  1180. 			while(i<n && ri->post_data[i] != '&' && j<255)
    1181. 

  1181. 				name[j++] = ri->post_data[i++];		
    1182. 

  1182. 			name[j] = 0; i++;
    1183. 

  1183. 		}
    1184. 

  1184. 		else if (!memcmp(ri->post_data+i, "password",8))
    1185. 

  1185. 		{
    1186. 

  1186. 			i+=9;
    1187. 

  1187. 			int k = 0;
    1188. 

  1188. 			while(i<n && ri->post_data[i] != '&' && k<255)
    1189. 

  1189. 				pass[k++] = ri->post_data[i++];		
    1190. 

  1190. 			pass[k] = 0; i++;
    1191. 

  1191. 			if (j && k)
    1192. 

  1192. 			{
    1193. 

  1193. 				mg_modify_passwords_file(ctx, (dir+passfile).c_str(), name, pass);
    1194. 

  1194. 				changed = true;
    1195. 

  1195. 			}
    1196. 

  1196. 		}
    1197. 

  1197. 		else if (!memcmp(ri->post_data+i, "remove",6))
    1198. 

  1198. 		{
    1199. 

  1199. 			i=n;
    1200. 

  1200. 			if (j)
    1201. 

  1201. 			{
    1202. 

  1202. 				mg_modify_passwords_file(ctx, (dir+passfile).c_str(), name, "");
    1203. 

  1203. 				changed = true;
    1204. 

  1204. 			}
    1205. 

  1205. 		}
    1206. 

  1206. 		else
    1207. 

  1207. 			i++;
    1208. 

  1208. 	}
    1209. 

  1209. 	if (changed)
    1210. 

  1210. 	{
    1211. 

  1211. 		mg_printf(conn,"HTTP/1.1 200 OK\r\nContent-Type: text/html; charset=utf-8\r\n\r\n<html><head><meta http-equiv=\"refresh\" content=\"0;url=/config\"></head><body>redirecting</body></html>");
    1212. 

  1212. 		return;
    1213. 

  1213. 	}
    1214. 

  1214. 	send_ok(conn);
    1215. 

  1215. 	mg_printf(conn,"<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01//EN\" \"http://www.w3.org/TR/html4/strict.dtd\">\n<html>\n<head>\n<meta http-equiv=\"Content-Type\" content=\"text/html; charset=utf-8\"><style>.menu a{color: #000000; font-size: 18px; text-decoration: none; padding-right: 20px; padding-left: 20px;} </style>\n<title>WebKey for Android</title>\n</head>\n");
    1216. 

  1216. 	mg_printf(conn,"<body><div class=\"menu\" style=\"background-color: #eeaa44; padding-top: 8px; padding-bottom: 8px; text-align: center;\"><a href=\"/\">phone</a> <a href=\"/config_buttons.html\">configure buttons</a> <a href=\"/config_keys.html\">configure keys</a><a href=\"/config\">users</a> <a href=\"/sdcard\">sdcard</a><a href=\"/help.html\">help</a></div>Users (empty passwords are not allowed):");
    1217. 

  1217. 	char line[256]; char domain[256];
    1218. 

  1218. 	FILE* fp = fo(passfile.c_str(),"r");
    1219. 

  1219. 	while (fgets(line, sizeof(line), fp) != NULL) 
    1220. 

  1220. 	{
    1221. 

  1221. 		if (sscanf(line, "%[^:]:%[^:]:%s", name, domain, pass) != 3)
    1222. 

  1222. 			continue;
    1223. 

  1223. 		mg_printf(conn,"<form name=\"%s_form\" method=\"post\">username: <input type=\"text\" readonly=\"readonly\" value=\"%s\" name=\"username\"> password: <input type=\"password\" name=\"password\"></input><input type=\"submit\" value=\"Change password\"></input><input name=\"remove\" type=\"submit\" value=\"Remove\"></input>",name,name,name);
    1224. 

  1224. 		if (!strcmp(name,"admin"))
    1225. 

  1225. 			mg_printf(conn,"This password will change on every restart\n");
    1226. 

  1226. 		mg_printf(conn,"</form>\n");
    1227. 

  1227. 	}
    1228. 

  1228. 	mg_printf(conn,"<form name=\"newuser\" method=\"post\">New user:<input type=\"text\" name=\"username\"> password: <input type=\"password\" name=\"password\"></input><input type=\"submit\" value=\"Create\"></input></form>\n");
    1229. 

  1229. 	fclose(fp);
    1230. 

  1230. 	mg_printf(conn,"</body></html>");
    1231. 

  1231. }
    1232. 

  1232. static void
    1233. 

  1233. screenshot(struct mg_connection *conn,
    1234. 

  1234.                 const struct mg_request_info *ri, void *data)
    1235. 

  1235. {
    1236. 

  1236. 	int orient = 0;
    1237. 

  1237. 	if (ri->uri[16] == 'h') // horizontal
    1238. 

  1238. 		orient = 1;
    1239. 

  1239. 	int lowres = 0;
    1240. 

  1240. 	if (ri->uri[17] == 'l') // low res
    1241. 

  1241. 		lowres = 1;
    1242. 

  1242. 	if (!pict)
    1243. 

  1243. 		init_fb();
    1244. 

  1244. 	update_image(orient,lowres);
    1245. 

  1245. 	send_ok(conn);
    1246. 

  1246. 	FILE* f = fo("tmp.png","rb");
    1247. 

  1247. 	fseek (f , 0 , SEEK_END);
    1248. 

  1248. 	int lSize = ftell (f);
    1249. 

  1249. 	rewind (f);
    1250. 

  1250. 	char* filebuffer = new char[lSize+1];
    1251. 

  1251. 	if(!filebuffer)
    1252. 

  1252. 	{
    1253. 

  1253. 		error("not enough memory for loading tmp.png\n");
    1254. 

  1254. 	}
    1255. 

  1255. 	fread(filebuffer,1,lSize,f);
    1256. 

  1256. 	filebuffer[lSize] = 0;
    1257. 

  1257. 	printf("sent bytes = %d\n",mg_write(conn,filebuffer,lSize));
    1258. 

  1258. 	fclose(f);
    1259. 

  1259. 	delete[] filebuffer;
    1260. 

  1260. 

  1261. }
    1262. 

  1262. static void
    1263. 

  1263. stop(struct mg_connection *conn,
    1264. 

  1264.                 const struct mg_request_info *ri, void *data)
    1265. 

  1265. {
    1266. 

  1266. 	send_ok(conn);
    1267. 

  1267. 	if (ri->remote_ip==2130706433) //localhost
    1268. 

  1268. 	{
    1269. 

  1269. 		printf("Stopping server...\n");
    1270. 

  1270. 		exit_flag = 2;
    1271. 

  1271. 		mg_printf(conn,"Goodbye.\n");
    1272. 

  1272. 	}
    1273. 

  1273. }
    1274. 

  1274. static void
    1275. 

  1275. run(struct mg_connection *conn,
    1276. 

  1276.                 const struct mg_request_info *ri, void *data)
    1277. 

  1277. {
    1278. 

  1278. 	send_ok(conn);
    1279. 

  1279. 	int n = 4;
    1280. 

  1280. 	std::string call = "";
    1281. 

  1281.         while (ri->uri[++n])
    1282. 

  1282. 	{
    1283. 

  1283. 		int k = getnum(ri->uri+n);
    1284. 

  1284. 		while(ri->uri[n] && ri->uri[n] != '_') n++;
    1285. 

  1285. 		if (k<=0 || 255<k)
    1286. 

  1286. 			continue;
    1287. 

  1287. 		call += (char)k;
    1288. 

  1288. 	}
    1289. 

  1289. 	call += " 2>&1";
    1290. 

  1290. 	FILE* in;
    1291. 

  1291. 	printf("%s\n",call.c_str());
    1292. 

  1292. 	if ((in = popen(call.c_str(),"r")) == NULL)
    1293. 

  1293. 		return;
    1294. 

  1294. 	char buff[256];
    1295. 

  1295. 	bool empty = true;
    1296. 

  1296. 	while (fgets(buff, sizeof(buff), in) != NULL)
    1297. 

  1297. 	{
    1298. 

  1298. 		mg_printf(conn, "%s",buff);
    1299. 

  1299. 		empty = false;
    1300. 

  1300. 	}
    1301. 

  1301. 	if (empty)
    1302. 

  1302. 		mg_printf(conn,"</pre>empty<pre>");
    1303. 

  1303. 	pclose(in);
    1304. 

  1304. }
    1305. 

  1305. static void
    1306. 

  1306. intent(struct mg_connection *conn,
    1307. 

  1307.                 const struct mg_request_info *ri, void *data)
    1308. 

  1308. {
    1309. 

  1309. 	send_ok(conn);
    1310. 

  1310. 	int n = 7;
    1311. 

  1311. 	std::string call = "/system/bin/am start ";
    1312. 

  1312.         while (ri->uri[++n])
    1313. 

  1313. 	{
    1314. 

  1314. 		int k = getnum(ri->uri+n);
    1315. 

  1315. 		while(ri->uri[n] && ri->uri[n] != '_') n++;
    1316. 

  1316. 		if (k<=0 || 255<k)
    1317. 

  1317. 			continue;
    1318. 

  1318. 		char ch = (char)k;
    1319. 

  1319. 		if ((ch >= 'a' && ch <= 'z') ||
    1320. 

  1320. 			(ch >= 'A' && ch <= 'Z') || ch == ' ')
    1321. 

  1321. 			call += ch;
    1322. 

  1322. 		else
    1323. 

  1323. 		{
    1324. 

  1324. 			call += '\\';
    1325. 

  1325. 			call += ch;
    1326. 

  1326. 		}
    1327. 

  1327. 	}
    1328. 

  1328. 	printf("%s\n",ri->uri+8);
    1329. 

  1329. 	printf("%s\n",call.c_str());
    1330. 

  1330. 		
    1331. 

  1331. 	system(call.c_str());
    1332. 

  1332. }
    1333. 

  1333. static void
    1334. 

  1334. password(struct mg_connection *conn,
    1335. 

  1335.                 const struct mg_request_info *ri, void *data)
    1336. 

  1336. {
    1337. 

  1337. 	send_ok(conn);
    1338. 

  1338. 	if (ri->remote_ip==2130706433) //localhost
    1339. 

  1339. 	{
    1340. 

  1340. 		mg_printf(conn,admin_password.c_str());
    1341. 

  1341. 	}
    1342. 

  1342. }
    1343. 

  1343. int main(int argc, char **argv)
    1344. 

  1344. {
    1345. 

  1345. 

  1346. 	int port;
    1347. 

  1347. 	if (argc == 2)
    1348. 

  1348. 		port = strtol (argv[1], 0, 10);
    1349. 

  1349. 	else
    1350. 

  1350. 		port = 80;
    1351. 

  1351. 	if (port <= 0)
    1352. 

  1352. 		error("Invalid port\n");
    1353. 

  1353. 	int i; 
    1354. 

  1354. 	for (i = strlen(argv[0])-1; i>=0; i--)
    1355. 

  1355. 		if (argv[0][i] == '/')
    1356. 

  1356. 		{
    1357. 

  1357. 			argv[0][i+1]=0;
    1358. 

  1358. 			break;
    1359. 

  1359. 		}
    1360. 

  1360. 	dir = argv[0];
    1361. 

  1361. 	dirdepth = -1;
    1362. 

  1362. 	for (i = 0; i < strlen(argv[0]); i++)
    1363. 

  1363. 		if (argv[0][i] == '/')
    1364. 

  1364. 			dirdepth++;
    1365. 

  1365. 	printf("%d\n",dirdepth);
    1366. 

  1366.         if ((fbfd = open(FB_DEVICE, O_RDONLY)) == -1)
    1367. 

  1367.         {
    1368. 

  1368.                 error("open framebuffer\n");
    1369. 

  1369.         }
    1370. 

  1370. 

  1371.         if (ioctl(fbfd, FBIOGET_VSCREENINFO, &scrinfo) != 0)
    1372. 

  1372.         {
    1373. 

  1373.                 error("error reading screeninfo\n");
    1374. 

  1374.         }
    1375. 

  1375. 

  1376. 	char buffer[8192];
    1377. 

  1377.         (void) signal(SIGCHLD, signal_handler);
    1378. 

  1378.         (void) signal(SIGTERM, signal_handler);
    1379. 

  1379.         (void) signal(SIGINT, signal_handler);
    1380. 

  1380.         if ((ctx = mg_start()) == NULL) {
    1381. 

  1381.                 error("Cannot initialize Mongoose context");
    1382. 

  1382.         }
    1383. 

  1383. 	
    1384. 

  1384. 	itoa(buffer,port);
    1385. 

  1385.         if (mg_set_option(ctx, "ports", buffer) != 1)
    1386. 

  1386.                 error("Error in configurate port.\n");
    1387. 

  1387. 	mg_set_option(ctx, "aliases", "/sdcard=/sdcard");
    1388. 

  1388. 	passfile = "passwords.txt";
    1389. 

  1389.         mg_set_option(ctx, "auth_realm", "webkey");
    1390. 

  1390. 	
    1391. 

  1391. 	admin_password = "";
    1392. 

  1392. 	struct timeval tv;
    1393. 

  1393. 	gettimeofday(&tv,0);
    1394. 

  1394. 	srand ( time(NULL)+tv.tv_usec );
    1395. 

  1395. 	for (i = 0; i < 8; i++)
    1396. 

  1396. 	{
    1397. 

  1397. 		char c[2]; c[1] = 0; c[0] = (char)(rand()%26+97);
    1398. 

  1398. 		admin_password += c;
    1399. 

  1399. 	}
    1400. 

  1400. 	
    1401. 

  1401. 	mg_modify_passwords_file(ctx, (dir+passfile).c_str(), "admin", admin_password.c_str());
    1402. 

  1402.         mg_set_uri_callback(ctx, "/", &index, NULL);
    1403. 

  1403.         mg_set_uri_callback(ctx, "/key*", &key, NULL);
    1404. 

  1404.         mg_set_uri_callback(ctx, "/oldkey*", &key, NULL);
    1405. 

  1405.         mg_set_uri_callback(ctx, "/touch*", &touch, NULL);
    1406. 

  1406.         mg_set_uri_callback(ctx, "/savebuttons", &savebuttons, NULL);
    1407. 

  1407.         mg_set_uri_callback(ctx, "/savekeys", &savekeys, NULL);
    1408. 

  1408.         mg_set_uri_callback(ctx, "/button*", &button, NULL);
    1409. 

  1409.         mg_set_uri_callback(ctx, "/config_buttons.html", &config_buttons, NULL);
    1410. 

  1410.         mg_set_uri_callback(ctx, "/config_keys.html", &config_keys, NULL);
    1411. 

  1411.         mg_set_uri_callback(ctx, "/screenshot.png*", &screenshot, NULL);
    1412. 

  1412.         mg_set_uri_callback(ctx, "/intent_*", &intent, NULL);
    1413. 

  1413.         mg_set_uri_callback(ctx, "/run_*", &run, NULL);
    1414. 

  1414.         mg_set_uri_callback(ctx, "/stop", &stop, NULL);
    1415. 

  1415.         mg_set_uri_callback(ctx, "/password", &password, NULL);
    1416. 

  1416.         mg_set_uri_callback(ctx, "/config", &config, NULL);
    1417. 

  1417.         mg_set_uri_callback(ctx, "/help.png", &helppng, NULL);
    1418. 

  1418.         mg_set_uri_callback(ctx, "/help.html", &helphtml, NULL);
    1419. 

  1419. 	mg_set_option(ctx, "protect", (std::string("/password=,/stop=,/=")+dir+passfile).c_str());
    1420. 

  1420. //	mg_set_option(ctx, "protect", (std::string("/password=,/stop=,/config=")+dir+passfile).c_str());
    1421. 

  1421. 	mg_set_option(ctx, "root","none");
    1422. 

  1422. 

  1423. 

  1424.         printf("WebKey %s started on port(s) [%s], serving directory [%s]\n",
    1425. 

  1425.             mg_version(),
    1426. 

  1426.             mg_get_option(ctx, "ports"),
    1427. 

  1427.             mg_get_option(ctx, "root"));
    1428. 

  1428. 

  1429. 	printf("starting uinput...\n");
    1430. 

  1430. 	init_uinput();
    1431. 

  1431. 	printf("starting touch...\n");
    1432. 

  1432. 	init_touch();
    1433. 

  1433.         fflush(stdout);
    1434. 

  1434.         while (exit_flag == 0)
    1435. 

  1435.                 sleep(1);
    1436. 

  1436. 

  1437.         (void) printf("Exiting on signal %d, "
    1438. 

  1438.             "waiting for all threads to finish...", exit_flag);
    1439. 

  1439.         fflush(stdout);
    1440. 

  1440.         mg_stop(ctx);
    1441. 

  1441.         (void) printf("%s", " done.\n");
    1442. 

  1442. 

  1443. 	clear();
    1444. 

  1444.         return (EXIT_SUCCESS);
    1445. 

  1445. 

  1446.   return 0;
    1447. 

  1447. }
    1448. 

  1448.