Changeset 279 for EcnlProtoTool/trunk/prototool/src/main.c
- Timestamp:
- Apr 29, 2017, 4:33:37 PM (7 years ago)
- File:
-
- 1 edited
Legend:
- Unmodified
- Added
- Removed
-
EcnlProtoTool/trunk/prototool/src/main.c
r270 r279 1 1 /* 2 2 * TOPPERS ECHONET Lite Communication Middleware 3 * 4 * Copyright (C) 2014-201 7Cores Co., Ltd. Japan5 * 3 * 4 * Copyright (C) 2014-2016 Cores Co., Ltd. Japan 5 * 6 6 * ä¸è¨èä½æ¨©è 7 7 ã¯ï¼ä»¥ä¸ã®(1)ï½(4)ã®æ¡ä»¶ãæºããå ´åã«éãï¼æ¬ã½ããã¦ã§ … … 40 40 * å 41 41 責ãããã¨ï¼ 42 * 42 * 43 43 * æ¬ã½ããã¦ã§ã¢ã¯ï¼ç¡ä¿è¨¼ã§æä¾ããã¦ãããã®ã§ããï¼ä¸è¨èä½æ¨©è 44 44 ã … … 47 47 * ã¢ã®å©ç¨ã«ããç´æ¥çã¾ãã¯éæ¥çã«çãããããªãæ害ã«é¢ãã¦ãï¼ã 48 48 * ã®è²¬ä»»ãè² ããªãï¼ 49 * 49 * 50 50 * @(#) $Id$ 51 51 */ 52 52 53 /* 54 * ãµã³ãã«ããã°ã©ã (1)ã®æ¬ä½ 55 */ 56 57 #include <kernel.h> 58 #include <t_syslog.h> 59 #include <t_stdlib.h> 60 #include <sil.h> 61 #include <stdlib.h> 53 /* 54 * ãµã³ãã«ããã°ã©ã (1)ã®æ¬ä½ 55 */ 56 57 #include <sys/types.h> 58 #include <sys/socket.h> 59 #include <sys/un.h> 60 #include <netinet/in.h> 61 #include <netinet/tcp.h> 62 #include <arpa/inet.h> 63 #include <fcntl.h> 64 #include <netdb.h> 65 #include <unistd.h> 66 #include <setjmp.h> 67 #include <signal.h> 68 #include <time.h> 69 #include <sys/time.h> 70 #include <sys/unistd.h> 71 #include <errno.h> 72 62 73 #include <string.h> 63 #include "syssvc/serial.h"64 #include "syssvc/syslog.h"65 #include "kernel_cfg.h"66 #include "main.h"67 #include "rza1.h"68 74 #include <mruby.h> 69 75 #include <mruby/compile.h> … … 74 80 #include <mruby/dump.h> 75 81 #include <mruby/string.h> 76 #include <tinet_config.h> 77 #include <netinet/in.h> 78 #include <netinet/in_itron.h> 79 #include <tinet_nic_defs.h> 80 #include <tinet_cfg.h> 81 #include <netinet/in_var.h> 82 #include <net/ethernet.h> 83 #include <net/if6_var.h> 84 #include <net/net.h> 85 #include <net/if_var.h> 86 #include <netinet/udp_var.h> 87 #include <ethernet_api.h> 88 #include "../webserver/httpd.h" 89 #include "../webserver/httpd-fs.h" 90 #include "../webserver/http-strings.h" 91 #include "../webserver/base64.h" 92 #include "../webserver/sha1.h" 93 #include "mruby_arduino.h" 94 #include "gpio_api.h" 95 #include "arduino.h" 96 #include "ff.h" 97 98 #ifndef _MSC_VER 99 void strcpy_s(char *dst, int size, const char *src); 100 void strcat_s(char *dst, int size, const char *src); 101 #endif 102 103 uint8_t mac_addr[6] = {0x00, 0x30, 0x13, 0x06, 0x62, 0xC0}; 104 105 SYSTIM main_time; 106 struct httpd_state *uploding; 107 108 static void netif_link_callback(T_IFNET *ether); 109 static void execute_ruby(); 110 111 /* TCP éåä¿¡ã¦ã£ã³ããããã¡ */ 112 uint8_t tcp_swbuf1[TCP_SWBUF_SIZE]; 113 uint8_t tcp_rwbuf1[TCP_RWBUF_SIZE]; 114 uint8_t tcp_swbuf2[TCP_SWBUF_SIZE]; 115 uint8_t tcp_rwbuf2[TCP_RWBUF_SIZE]; 116 117 #define ISO_nl 0x0a 118 #define ISO_space 0x20 119 #define ISO_bang 0x21 120 #define ISO_percent 0x25 121 #define ISO_period 0x2e 122 #define ISO_slash 0x2f 123 #define ISO_colon 0x3a 124 125 ID ecn_api_mailboxid; 126 ID WEBSOCKET_MBXID; 127 128 struct httpd_state httpd_state[2] = { 129 {MAIN1_TASK, TCP_CEPID1}, 130 {MAIN2_TASK, TCP_CEPID2}, 131 }; 132 133 /* 134 * ãããã¯ã¼ã¯å±¤ã®é¸æ 135 */ 136 137 #ifdef SUPPORT_INET6 138 139 #define TCP_ACP_CEP(c,r,d,t) tcp6_acp_cep(c,r,d,t) 140 #define IP2STR(s,a) ipv62str(s,a) 141 142 #else /* of #ifdef SUPPORT_INET6 */ 143 144 #ifdef SUPPORT_INET4 145 146 #define TCP_ACP_CEP(c,r,d,t) tcp_acp_cep(c,r,d,t) 147 #define IP2STR(s,a) ip2str(s,a) 148 149 #endif /* of #ifdef SUPPORT_INET4 */ 150 151 #endif /* of #ifdef SUPPORT_INET6 */ 152 153 struct httpd_state *get_httpd(ID cepid) 154 { 155 for (int i = 0; i < 2; i++) { 156 if (httpd_state[i].cepid != cepid) 157 continue; 158 159 return &httpd_state[i]; 160 } 161 return NULL; 162 } 163 164 struct websocket *websocket_getws(ID wbsid) 165 { 166 for (int i = 0; i < 2; i++) { 167 if (httpd_state[i].websocket.wbsid != wbsid) 168 continue; 169 170 return &httpd_state[i].websocket; 171 } 172 return NULL; 173 } 174 175 void send_file(struct httpd_state *s) 176 { 177 char *buf; 178 int len, slen; 179 180 while (s->file.len > 0) { 181 slen = tcp_get_buf(s->cepid, (void **)&buf, TMO_FEVR); 182 if (slen < 0) { 183 syslog(LOG_ERROR, "send_file#tcp_get_buf(%s.%d) => %d", s->addr, ((T_IPV4EP *)s->dst)->portno, slen); 184 s->state = STATE_CLOSING; 185 break; 186 } 187 if (slen == 0) 188 return; 189 190 len = s->file.len; 191 if (len > slen) 192 len = slen; 193 194 len = httpd_fs_read(&s->file, buf, len); 195 if (len <= 0) { 196 syslog(LOG_ERROR, "send_file#httpd_fs_read(%s.%d) => %d", s->addr, ((T_IPV4EP *)s->dst)->portno, len); 197 break; 198 } 199 200 s->file.len -= len; 201 s->file.pos += len; 202 203 if ((slen = tcp_snd_buf(s->cepid, len)) != E_OK) { 204 syslog(LOG_ERROR, "send_file#tcp_snd_buf(%s.%d) => %d", s->addr, ((T_IPV4EP *)s->dst)->portno, slen); 205 s->state = STATE_CLOSING; 206 break; 207 } 208 } 209 210 syslog(LOG_NOTICE, "close: %s.%d %s", s->addr, ((T_IPV4EP *)s->dst)->portno, s->filename); 211 httpd_fs_close(&s->file); 212 s->file.len = 0; 213 s->file.pos = 0; 214 215 s->out.state = OUT_STATE_SEND_END; 216 } 217 218 void send_data(struct httpd_state *s) 219 { 220 char *buf; 221 int len, slen; 222 223 while (s->response_len > 0) { 224 slen = tcp_get_buf(s->cepid, (void **)&buf, TMO_FEVR); 225 if (slen < 0) { 226 syslog(LOG_ERROR, "send_data#tcp_get_buf(%s.%d) => %d", s->addr, ((T_IPV4EP *)s->dst)->portno, slen); 227 s->state = STATE_CLOSING; 228 break; 229 } 230 if (slen == 0) 231 return; 232 233 len = s->response_len; 234 if (len > slen) 235 len = slen; 236 237 memcpy(buf, &s->response_body[s->response_pos], len); 238 239 s->response_len -= len; 240 s->response_pos += len; 241 242 if ((slen = tcp_snd_buf(s->cepid, len)) != E_OK) { 243 syslog(LOG_ERROR, "send_data#tcp_snd_buf(%s.%d) => %d", s->addr, ((T_IPV4EP *)s->dst)->portno, slen); 244 s->state = STATE_CLOSING; 245 break; 246 } 247 } 248 249 s->response_body = NULL; 250 s->response_len = 0; 251 s->response_pos = 0; 252 253 s->out.state = OUT_STATE_SEND_END; 254 } 255 256 void send_headers(struct httpd_state *s, const char *statushdr) 257 { 258 int len; 259 char *ptr; 260 261 len = strlen(statushdr); 262 tcp_snd_dat(s->cepid, (void *)statushdr, len, TMO_FEVR); 263 264 if ((s->filename[0] == '0') && (s->file.len > 0)) { 265 len = sizeof(http_content_encoding_gzip) - 1; 266 tcp_snd_dat(s->cepid, (void *)http_content_encoding_gzip, len, TMO_FEVR); 267 } 268 269 if (s->file.redirect) { 270 len = sizeof(http_location) - 1; 271 tcp_snd_dat(s->cepid, (void *)http_location, len, TMO_FEVR); 272 if (s->filename[0] == '1') { 273 len = 2; 274 tcp_snd_dat(s->cepid, "/~", len, TMO_FEVR); 275 } 276 len = strlen(s->filename); 277 tcp_snd_dat(s->cepid, s->filename, len, TMO_FEVR); 278 if (s->query != NULL) { 279 tcp_snd_dat(s->cepid, "?", 1, TMO_FEVR); 280 len = strlen(s->query); 281 tcp_snd_dat(s->cepid, s->query, len, TMO_FEVR); 282 } 283 len = 2; 284 tcp_snd_dat(s->cepid, "\r", len, TMO_FEVR); 285 } 286 287 ptr = strrchr(s->filename, ISO_period); 288 if (ptr == NULL) { 289 len = sizeof(http_content_type_binary) - 1; 290 tcp_snd_dat(s->cepid, (void *)http_content_type_binary, len, TMO_FEVR); 291 } 292 else if (strncmp(http_html, ptr, sizeof(http_html) - 1) == 0 || 293 strncmp(http_htm, ptr, sizeof(http_htm) - 1) == 0) { 294 len = sizeof(http_content_type_html) - 1; 295 tcp_snd_dat(s->cepid, (void *)http_content_type_html, len, TMO_FEVR); 296 } 297 else if (strncmp(http_css, ptr, sizeof(http_css) - 1) == 0) { 298 len = sizeof(http_content_type_css) - 1; 299 tcp_snd_dat(s->cepid, (void *)http_content_type_css, len, TMO_FEVR); 300 } 301 else if (strncmp(http_js, ptr, sizeof(http_js) - 1) == 0) { 302 len = sizeof(http_content_type_js) - 1; 303 tcp_snd_dat(s->cepid, (void *)http_content_type_js, len, TMO_FEVR); 304 } 305 else if (strncmp(http_json, ptr, sizeof(http_json) - 1) == 0) { 306 len = sizeof(http_content_type_json) - 1; 307 tcp_snd_dat(s->cepid, (void *)http_content_type_json, len, TMO_FEVR); 308 } 309 else if (strncmp(http_png, ptr, sizeof(http_png) - 1) == 0) { 310 len = sizeof(http_content_type_png) - 1; 311 tcp_snd_dat(s->cepid, (void *)http_content_type_png, len, TMO_FEVR); 312 } 313 else if (strncmp(http_gif, ptr, sizeof(http_gif) - 1) == 0) { 314 len = sizeof(http_content_type_gif) - 1; 315 tcp_snd_dat(s->cepid, (void *)http_content_type_gif, len, TMO_FEVR); 316 } 317 else if (strncmp(http_jpg, ptr, sizeof(http_jpg) - 1) == 0) { 318 len = sizeof(http_content_type_jpg) - 1; 319 tcp_snd_dat(s->cepid, (void *)http_content_type_jpg, len, TMO_FEVR); 320 } 321 else if (strncmp(http_svg, ptr, sizeof(http_svg) - 1) == 0) { 322 len = sizeof(http_content_type_svg) - 1; 323 tcp_snd_dat(s->cepid, (void *)http_content_type_svg, len, TMO_FEVR); 324 } 325 else if (strncmp(http_text, ptr, sizeof(http_text) - 1) == 0) { 326 len = sizeof(http_content_type_text) - 1; 327 tcp_snd_dat(s->cepid, (void *)http_content_type_text, len, TMO_FEVR); 328 } 329 else if (strncmp(http_eot, ptr, sizeof(http_eot) - 1) == 0) { 330 len = sizeof(http_content_type_eot) - 1; 331 tcp_snd_dat(s->cepid, (void *)http_content_type_eot, len, TMO_FEVR); 332 } 333 else if (strncmp(http_ttf, ptr, sizeof(http_ttf) - 1) == 0) { 334 len = sizeof(http_content_type_ttf) - 1; 335 tcp_snd_dat(s->cepid, (void *)http_content_type_ttf, len, TMO_FEVR); 336 } 337 else if (strncmp(http_woff, ptr, sizeof(http_woff) - 1) == 0) { 338 len = sizeof(http_content_type_woff) - 1; 339 tcp_snd_dat(s->cepid, (void *)http_content_type_woff, len, TMO_FEVR); 340 } 341 else if (strncmp(http_woff2, ptr, sizeof(http_woff2) - 1) == 0) { 342 len = sizeof(http_content_type_woff2) - 1; 343 tcp_snd_dat(s->cepid, (void *)http_content_type_woff2, len, TMO_FEVR); 344 } 345 else if (strncmp(http_ico, ptr, sizeof(http_ico) - 1) == 0) { 346 len = sizeof(http_content_type_ico) - 1; 347 tcp_snd_dat(s->cepid, (void *)http_content_type_ico, len, TMO_FEVR); 348 } 349 else { 350 len = sizeof(http_content_type_plain) - 1; 351 tcp_snd_dat(s->cepid, (void *)http_content_type_plain, len, TMO_FEVR); 352 } 353 354 if (s->file.len > 0) { 355 len = sizeof(http_content_length) - 1; 356 tcp_snd_dat(s->cepid, (void *)http_content_length, len, TMO_FEVR); 357 sprintf(s->temp, "%d\r\n", s->file.len); 358 tcp_snd_dat(s->cepid, (void *)s->temp, strlen(s->temp), TMO_FEVR); 359 } 360 361 if (s->message.should_keep_alive && s->reset == 0) { 362 len = sizeof(http_connection_keep_alive) - 1; 363 tcp_snd_dat(s->cepid, (void *)http_connection_keep_alive, len, TMO_FEVR); 364 } 365 else { 366 len = sizeof(http_connection_close) - 1; 367 tcp_snd_dat(s->cepid, (void *)http_connection_close, len, TMO_FEVR); 368 } 369 370 tcp_snd_dat(s->cepid, (void *)http_crnl, 2, TMO_FEVR); 371 372 if (s->filename != NULL) { 373 s->out.state = OUT_STATE_SEND_FILE; 374 } 375 else { 376 s->out.state = OUT_STATE_SEND_DATA; 377 } 378 } 379 380 void handle_output(struct httpd_state *s) 381 { 382 s->out.wait = false; 383 384 switch (s->out.state) { 385 case OUT_STATE_WAIT_REQUEST: 386 s->out.wait = true; 387 break; 388 case OUT_STATE_OPEN_GET_FILE: 389 syslog(LOG_NOTICE, "open: %s.%d %s", s->addr, ((T_IPV4EP *)s->dst)->portno, s->filename); 390 if (!httpd_fs_open(s->filename, sizeof(s->message.request_url), &s->file)) { 391 s->filename = NULL; 392 s->response_body = http_content_404; 393 s->response_pos = 0; 394 s->response_len = sizeof(http_content_403) - 1; 395 s->out.statushdr = http_header_404; 396 } 397 else { 398 s->out.statushdr = s->file.redirect ? http_header_301 : http_header_200; 399 } 400 s->out.state = OUT_STATE_SEND_HEADER; 401 break; 402 case OUT_STATE_WAIT_POST_BODY: 403 s->out.wait = true; 404 break; 405 case OUT_STATE_BODY_RECEIVED: 406 s->out.statushdr = http_header_200; 407 s->out.state = OUT_STATE_SEND_HEADER; 408 break; 409 case OUT_STATE_SEND_HEADER: 410 send_headers(s, s->out.statushdr); 411 break; 412 case OUT_STATE_SEND_FILE: 413 send_file(s); 414 break; 415 case OUT_STATE_SEND_DATA: 416 send_data(s); 417 break; 418 case OUT_STATE_SEND_END: 419 s->out.wait = true; 420 if (s->message.should_keep_alive && s->reset == 0) { 421 s->out.state = OUT_STATE_WAIT_REQUEST; 422 } 423 else { 424 s->state = STATE_CLOSING; 425 } 426 break; 427 } 428 } 429 430 void send_ws_headers(struct httpd_state *s, const char *statushdr) 431 { 432 int len; 433 434 len = strlen(statushdr); 435 tcp_snd_dat(s->cepid, (void *)statushdr, len, TMO_FEVR); 436 437 len = sizeof(http_upgrade) - 1; 438 tcp_snd_dat(s->cepid, (void *)http_upgrade, len, TMO_FEVR); 439 len = strlen(s->message.upgrade); 440 tcp_snd_dat(s->cepid, s->message.upgrade, len, TMO_FEVR); 441 len = sizeof(http_crnl) - 1; 442 tcp_snd_dat(s->cepid, (void *)http_crnl, len, TMO_FEVR); 443 444 len = sizeof(http_connection) - 1; 445 tcp_snd_dat(s->cepid, (void *)http_connection, len, TMO_FEVR); 446 len = strlen(s->message.connection); 447 tcp_snd_dat(s->cepid, s->message.connection, len, TMO_FEVR); 448 len = sizeof(http_crnl) - 1; 449 tcp_snd_dat(s->cepid, (void *)http_crnl, len, TMO_FEVR); 450 451 len = sizeof(http_sec_websocket_accept) - 1; 452 tcp_snd_dat(s->cepid, (void *)http_sec_websocket_accept, len, TMO_FEVR); 453 len = strlen(s->message.response_key); 454 tcp_snd_dat(s->cepid, s->message.response_key, len, TMO_FEVR); 455 len = sizeof(http_crnl) - 1; 456 tcp_snd_dat(s->cepid, (void *)http_crnl, len, TMO_FEVR); 457 458 len = sizeof(http_sec_websocket_protocol) - 1; 459 tcp_snd_dat(s->cepid, (void *)http_sec_websocket_protocol, len, TMO_FEVR); 460 len = strlen(s->message.sec_websocket_protocol); 461 tcp_snd_dat(s->cepid, s->message.sec_websocket_protocol, len, TMO_FEVR); 462 len = sizeof(http_crnl) - 1; 463 tcp_snd_dat(s->cepid, (void *)http_crnl, len, TMO_FEVR); 464 465 len = sizeof(http_crnl) - 1; 466 tcp_snd_dat(s->cepid, (void *)http_crnl, len, TMO_FEVR); 467 } 468 469 void send_ws_data(struct httpd_state *s) 470 { 471 char *buf; 472 int slen; 473 474 slen = tcp_get_buf(s->cepid, (void **)&buf, TMO_FEVR); 475 if (slen < 0) { 476 syslog(LOG_ERROR, "send_ws_data#tcp_get_buf(%s.%d) => %d", s->addr, ((T_IPV4EP *)s->dst)->portno, slen); 477 return; 478 } 479 480 websocket_output(&s->websocket, buf, slen); 481 } 482 483 void handle_ws_output(struct httpd_state *s) 484 { 485 char shaHash[20]; 486 SHA_CTX sha1; 487 int len; 488 489 strlncat(s->message.response_key, sizeof(s->message.response_key), 490 s->message.sec_websocket_key, sizeof(s->message.sec_websocket_key)); 491 len = strlncat(s->message.response_key, sizeof(s->message.response_key), 492 http_websocket_guid, sizeof(http_websocket_guid)); 493 memset(shaHash, 0, sizeof(shaHash)); 494 SHA1_Init(&sha1); 495 SHA1_Update(&sha1, (sha1_byte *)s->message.response_key, len); 496 SHA1_Final((sha1_byte *)shaHash, &sha1); 497 base64_encode((unsigned char *)s->message.response_key, 498 sizeof(s->message.response_key), (unsigned char *)shaHash, sizeof(shaHash)); 499 500 send_ws_headers(s, http_header_101); 501 502 s->message.response_key[0] = '\0'; 503 504 do { 505 while (!websocket_newdata(&s->websocket)) 506 slp_tsk(); 507 508 send_ws_data(s); 509 } while ((s->state == STATE_CONNECTED) && (!s->close_req)); 510 s->state = STATE_DISCONNECTED; 511 websocket_destroy(&s->websocket); 512 s->close_req = 0; 513 514 s->state = STATE_CLOSING; 515 } 516 517 void handle_input(struct httpd_state *s) 518 { 519 size_t done; 520 int len; 521 522 s->in.wait = false; 523 524 switch (s->in.state) { 525 case IN_STATE_START: 526 http_parser_init(&s->parser, HTTP_REQUEST); 527 s->in.state = IN_STATE_REQUEST; 528 break; 529 case IN_STATE_REQUEST: 530 case IN_STATE_RESPONSE: 531 case IN_STATE_UPLOAD: 532 if ((len = tcp_rcv_buf(s->cepid, (void **)&s->in.data, TMO_POL)) <= 0) { 533 if ((len == E_TMOUT) || (len == 0)) { 534 // 3ç§ã¯å¾ 535 㤠536 if (main_time - s->in.timer < 30000000) { 537 s->in.wait = true; 538 break; 539 } 540 } 541 syslog(LOG_ERROR, "handle_input#tcp_rcv_buf#%d(%s.%d) => %d", s->in.state, s->addr, ((T_IPV4EP *)s->dst)->portno, len); 542 uploding = NULL; 543 s->state = STATE_CLOSING; 544 return; 545 } 546 done = http_parser_execute(&s->parser, &websvr_settings, s->in.data, len); 547 tcp_rel_buf(s->cepid, done); 548 if (s->parser.http_errno != HPE_OK) { 549 syslog(LOG_ERROR, "http_parser error %s.%d => %d", s->addr, ((T_IPV4EP *)s->dst)->portno, s->parser.http_errno); 550 uploding = NULL; 551 s->state = STATE_CLOSING; 552 return; 553 } 554 555 s->parse_pos = done; 556 s->parse_len = len - done; 557 break; 558 case IN_STATE_UPLOAD_WAIT: 559 if (uploding != NULL) { 560 s->in.wait = true; 561 } 562 else { 563 uploding = s; 564 s->in.state = IN_STATE_UPLOAD; 565 } 566 break; 567 case IN_STATE_WEBSOCKET: 568 if (s->parse_len <= 0) { 569 if ((len = tcp_rcv_buf(s->cepid, (void **)&s->in.data, TMO_POL)) <= 0) { 570 if ((len == E_TMOUT) || (len == 0)) { 571 s->in.wait = true; 572 break; 573 } 574 syslog(LOG_ERROR, "handle_input#tcp_rcv_buf#%d(%s.%d) => %d", s->in.state, s->addr, ((T_IPV4EP *)s->dst)->portno, len); 575 s->state = STATE_CLOSING; 576 break; 577 } 578 579 s->parse_pos = 0; 580 s->parse_len = len; 581 } 582 else 583 len = s->parse_len; 584 done = websocket_input(&s->websocket, (void *)s->in.data, s->parse_len); 585 tcp_rel_buf(s->cepid, done); 586 if ((done != 0) || (s->websocket.rstate.opecode == connection_close)) { 587 s->close_req = 1; 588 s->state = STATE_CLOSING; 589 break; 590 } 591 s->parse_pos = done; 592 s->parse_len -= done; 593 break; 594 case IN_STATE_END: 595 s->in.wait = true; 596 break; 597 default: 598 s->state = STATE_CLOSING; 599 break; 600 } 601 } 602 603 /* 604 * ãã³ããããã³ã°ã³ã¼ã«ã®ã³ã¼ã«ããã¯é¢æ° 605 */ 606 ER 607 callback_nblk_tcp(ID cepid, FN fncd, void *p_parblk) 608 { 609 struct httpd_state *s = get_httpd(cepid); 610 611 if (s == NULL) 612 syslog(LOG_NOTICE, "callback_nblk_tcp(%d, %d)", fncd, cepid); 613 else 614 syslog(LOG_NOTICE, "callback_nblk_tcp(%d, %s.%d)", fncd, s->addr, ((T_IPV4EP *)s->dst)->portno); 615 616 return E_PAR; 617 } 618 619 /* 620 * ã¡ã¤ã³ã¿ã¹ã¯ 621 */ 622 void main_task(intptr_t exinf) 623 { 624 ER ret, ret2; 625 struct httpd_state *s = &httpd_state[exinf]; 626 627 if (exinf == 0) { 628 gpio_t led_blue, led_green, led_red, sw; 629 gpio_init_out(&led_blue, LED_BLUE); 630 gpio_init_out(&led_green, LED_GREEN); 631 gpio_init_out(&led_red, LED_RED); 632 gpio_init_in(&sw, USER_BUTTON0); 633 634 bool_t exec = gpio_read(&sw) == 1; 635 636 gpio_write(&led_blue, 1); 637 gpio_write(&led_green, exec ? 1 : 0); 638 gpio_write(&led_red, 0); 639 640 /* åæå */ 641 if (mruby_arduino_init() == 0) { 642 gpio_write(&led_blue, 0); 643 } 644 else { 645 gpio_write(&led_blue, 0); 646 gpio_write(&led_red, 1); 647 } 648 649 gpio_write(&led_green, 0); 650 651 /* TINETãèµ·åããã¾ã§å¾ 652 㤠*/ 653 ether_set_link_callback(netif_link_callback); 654 655 act_tsk(MAIN2_TASK); 656 657 if (exec) { 658 strcpy_s(RubyFilename, sizeof(RubyFilename), "1:/upload/main.mrb"); 659 660 execute_ruby(); 661 } 662 } 663 664 for (;;) { 665 ret2 = get_tim(&main_time); 666 if (ret2 != E_OK) { 667 syslog(LOG_ERROR, "get_tim"); 668 return; 669 } 670 671 switch (s->state) { 672 case STATE_DISCONNECTED: 673 memset(&s->dst, 0, sizeof(s->dst)); 674 if ((ret = TCP_ACP_CEP(s->cepid, TCP_REPID, (T_IPV4EP *)s->dst, TMO_FEVR)) != E_OK) { 675 syslog(LOG_ERROR, "tcp_acp_cep(%d) => %d", s->cepid, ret); 676 tslp_tsk(100000); // TODO 677 s->state = STATE_CLOSING; 678 break; 679 } 680 IP2STR(s->addr, &((T_IPV4EP *)s->dst)->ipaddr); 681 syslog(LOG_NOTICE, "connected: %s.%d", s->addr, ((T_IPV4EP *)s->dst)->portno); 682 memset(&s->in, 0, sizeof(s->in)); 683 memset(&s->out, 0, sizeof(s->out)); 684 s->in.timer = main_time; 685 s->state = STATE_CONNECTED; 686 break; 687 case STATE_CONNECTED: 688 handle_input(s); 689 handle_output(s); 690 break; 691 case STATE_WEBSOCKET: 692 handle_input(s); 693 handle_ws_output(s); 694 break; 695 case STATE_CLOSING: 696 syslog(LOG_NOTICE, "close: %s.%d", s->addr, ((T_IPV4EP *)s->dst)->portno); 697 tcp_sht_cep(s->cepid); 698 tcp_cls_cep(s->cepid, TMO_FEVR); 699 700 if (s->reset) { 701 s->reset = 0; 702 s->state = STATE_RESET; 703 } 704 else{ 705 s->state = STATE_DISCONNECTED; 706 } 707 break; 708 case STATE_RESET: 709 execute_ruby(); 710 s->state = STATE_DISCONNECTED; 711 break; 712 } 713 714 if (s->in.wait && s->out.wait) { 715 tslp_tsk(100000); 716 } 717 } 718 } 719 720 struct udp_msg { 721 T_IPV4EP dst; 82 #include <usrcmd.h> 83 84 #define ETHER_MAX_LEN 1518 85 #define IF_FLAG_UP 1 86 #define IF_FLAG_LINK_UP 2 87 #define MAKE_IPV4_ADDR(a,b,c,d) htonl(((uint32_t)(a)<<24)|((uint32_t)(b)<<16)|((uint32_t)(c)<<8)|(d)) 88 89 struct udp_msg 90 { 91 struct sockaddr_in dst; 722 92 int len; 723 93 uint8_t buffer[ETHER_MAX_LEN]; 724 94 }; 725 95 726 SYSTIM mruby_time; 96 typedef struct 97 { 98 cmd_table_t *table; 99 cmd_table_t *count; 100 } cmd_table_info_t; 101 102 extern int mrbc_main(int argc, char **argv); 103 extern int mrdb_main(int argc, char **argv); 104 extern int mruby_main(int argc, char **argv); 105 extern int mirb_main(int argc, char **argv); 106 extern int tcc_main(int argc, char **argv); 107 extern int vi_main(int argc, char **argv); 108 extern int onitest_main(int argc, char **argv); 109 extern int tcp_echo_main(int argc, char **argv); 110 extern int echo_client_main(int argc, char **argv); 111 extern int mrdb_break(void); 112 113 static const cmd_table_t cmdlist[] = { 114 {"mrbc", "mruby compiler executable", mrbc_main}, 115 {"mrdb","mruby debugger command", mrdb_main}, 116 {"mruby","mruby command", mruby_main}, 117 {"mirb", "Embeddable Interactive Ruby Shell", mirb_main}, 118 {"tcc", "Tiny C compiler", tcc_main}, 119 {"vi", "Text editor", vi_main}, 120 {"cd", "change directory", usrcmd_cd }, 121 {"ls", "list files", usrcmd_ls }, 122 {"cp", "copy file", usrcmd_cp }, 123 {"rm", "remove file", usrcmd_rm }, 124 {"mv", "move file", usrcmd_mv }, 125 {"mkdir", "Make directory", usrcmd_mkdir}, 126 {"hexdump", "Hex dump", usrcmd_hexdump}, 127 {"onitest", "Onigumo Test", onitest_main}, 128 {"tcp_echo", "TCP echo server/client", tcp_echo_main}, 129 {"help", "This is a description text string for help command.", usrcmd_help}, 130 {"info", "This is a description text string for info command.", usrcmd_info}, 131 {"exit", "Exit Natural Tyny Shell", usrcmd_exit}, 132 }; 133 cmd_table_info_t cmd_table_info = { &cmdlist, sizeof(cmdlist) / sizeof(cmdlist[0]) }; 134 135 int echonet = 1; 136 struct timeval main_time; 727 137 struct RClass *_module_target_board; 728 729 extern const uint8_t main_rb_code[]; 730 uint8_t RubyCode[16 * 1024]; 731 732 /* MACã¢ãã¬ã¹ã®è¨å®æã«å¼ã°ãã */ 733 void mbed_mac_address(char *mac) 734 { 735 memcpy(mac, mac_addr, 6); 736 } 737 738 /* 739 * mrubyå®è¡ã¿ã¹ã¯ 740 */ 741 void mruby_task(intptr_t exinf) 742 { 743 ER ret; 138 int sock; 139 140 int main(int argc, char **argv) 141 { 142 if (argc == 0) { 143 return 0; 144 } 145 const cmd_table_t *p = cmd_table_info.table; 146 for (int i = 0; i < cmd_table_info.count; i++) { 147 if (strcmp((const char *)argv[0], p->cmd) == 0) { 148 return p->func(argc, argv); 149 } 150 p++; 151 } 152 printf("Unknown command found.\n"); 153 return 0; 154 } 155 156 int run_mruby_code(int argc, char **argv, const uint8_t *code, const char *cmdline) 157 { 158 mrb_state *mrb; 744 159 struct RProc* n; 745 160 struct mrb_irep *irep; 746 mrb_state *mrb; 747 748 syslog(LOG_NOTICE, "mruby_task"); 161 mrb_value ARGV; 162 mrbc_context *c; 163 mrb_value v; 164 mrb_sym zero_sym; 165 166 echonet = 0; 749 167 750 168 /* mrubyã®åæå */ 751 169 mrb = mrb_open(); 752 170 if (mrb == NULL) 753 abort(); 754 755 ret = get_tim(&mruby_time); 756 if (ret != E_OK) { 757 syslog(LOG_ERROR, "get_tim => %d", ret); 758 return; 759 } 760 761 irep = mrb_read_irep(mrb, RubyCode); 171 return -1; 172 173 int ai = mrb_gc_arena_save(mrb); 174 ARGV = mrb_ary_new_capa(mrb, argc); 175 for (int i = 0; i < argc; i++) { 176 mrb_ary_push(mrb, ARGV, mrb_str_new_cstr(mrb, argv[i])); 177 } 178 mrb_define_global_const(mrb, "ARGV", ARGV); 179 180 c = mrbc_context_new(mrb); 181 c->dump_result = TRUE; 182 183 /* Set $0 */ 184 zero_sym = mrb_intern_lit(mrb, "$0"); 185 mrbc_filename(mrb, c, cmdline); 186 mrb_gv_set(mrb, zero_sym, mrb_str_new_cstr(mrb, cmdline)); 187 188 irep = mrb_read_irep(mrb, code); 762 189 n = mrb_proc_new(mrb, irep); 763 190 mrb_run(mrb, n, mrb_nil_value()); 764 191 192 mrb_gc_arena_restore(mrb, ai); 193 mrbc_context_free(mrb, c); 194 if (mrb->exc) { 195 if (!mrb_undef_p(v)) { 196 mrb_print_error(mrb); 197 } 198 n = -1; 199 } 200 765 201 mrb_close(mrb); 766 } 767 768 static void execute_ruby() 769 { 770 FIL fd; 771 FRESULT res; 772 ER ret; 773 774 syslog(LOG_NOTICE, "execute_ruby"); 775 776 ret = ter_tsk(MRUBY_TASK); 777 if ((ret != E_OK) && (ret != E_OBJ)) { 778 syslog(LOG_ERROR, "ter_tsk => %d", ret); 779 } 780 781 tslp_tsk(100000); 782 783 reset_heap(); 784 785 strcpy_s(ExeFilename, sizeof(ExeFilename), RubyFilename); 786 RubyFilename[0] = '\0'; 787 ExeFilename[sizeof(ExeFilename) - 1] = '\0'; 788 789 if (ExeFilename[0] == '\0') { 202 return 0; 203 } 204 205 int tcp_echo_main(int argc, char **argv) 206 { 207 extern const uint8_t echo_server_code[]; 208 extern const uint8_t echo_client_code[]; 209 210 if (argc >= 2) { 211 if (strcmp(argv[1], "-s") == 0) { 212 return run_mruby_code(argc - 2, &argv[2], echo_server_code, "echo_server"); 213 } 214 else if (strcmp(argv[1], "-c") == 0) { 215 return run_mruby_code(argc - 2, &argv[2], echo_client_code, "echo_client"); 216 } 217 } 218 219 printf("tcp_echo -s port\n"); 220 printf("tcp_echo -c ipaddr port\n"); 221 222 return 0; 223 } 224 225 int usrcmd_help(int argc, char **argv) 226 { 227 const cmd_table_t *p = cmd_table_info.table; 228 for (int i = 0; i < cmd_table_info.count; i++) { 229 printf(p->cmd); 230 printf("\t:"); 231 printf(p->desc); 232 printf("\n"); 233 p++; 234 } 235 return 0; 236 } 237 238 void sigusr1_handler(int sig) 239 { 240 printf("signal called\n"); 241 } 242 243 void mrb_target_board_init() 244 { 245 int ret; 246 struct sockaddr_in ep; 247 struct ip_mreq mreq; 248 249 signal(SIGUSR1, sigusr1_handler); 250 251 sock = socket(AF_INET, SOCK_DGRAM, 0); 252 253 memset(&ep, 0, sizeof(ep)); 254 ep.sin_family = AF_INET; 255 ep.sin_port = htons(3610); 256 ep.sin_addr.s_addr = INADDR_ANY; 257 //ep.sin_addr.s_addr = MAKE_IPV4_ADDR(192,168,137,200); 258 259 ret = bind(sock, &ep, sizeof(ep)); 260 if (ret != 0) { 261 printf("bind %d", ret); 790 262 return; 791 263 } 792 264 793 syslog(LOG_NOTICE, "%s", ExeFilename); 794 795 wai_sem(SEM_FILESYSTEM); 796 797 if ((res = f_open(&fd, ExeFilename, FA_OPEN_EXISTING | FA_READ)) == FR_OK) { 798 if (fd.fsize < sizeof(RubyCode)) { 799 int len = fd.fsize; 800 for (int pos = 0; pos < fd.fsize; pos += len) { 801 if (len > 1024) 802 len = 1024; 803 804 UINT rlen; 805 if ((res = f_read(&fd, &RubyCode[pos], len, &rlen)) != FR_OK) 806 break; 807 808 // ä»ã«ä½¿ã人ã®ããã«è§£æ¾ 809 sig_sem(SEM_FILESYSTEM); 810 wai_sem(SEM_FILESYSTEM); 811 } 812 } 813 f_close(&fd); 814 } 815 816 sig_sem(SEM_FILESYSTEM); 817 818 if (res == FR_OK) { 819 ret = act_tsk(MRUBY_TASK); 820 if (ret != E_OK) { 821 syslog(LOG_ERROR, "act_tsk => %d", ret); 822 } 823 } 824 } 825 826 ER callback_nblk_udp(ID cepid, FN fncd, void *p_parblk) 827 { 828 static struct udp_msg msg_inst[2]; 829 static int msg_no = 0; 830 struct udp_msg *msg = &msg_inst[msg_no]; 831 ER error = E_OK; 832 833 switch (fncd) { 834 case TFN_UDP_CRE_CEP: 835 case TFN_UDP_RCV_DAT: 836 /* ECN_CAP_PUT("[UDP ECHO SRV] callback_nblk_udp() recv: %u", *(int *)p_parblk); */ 837 memset(msg, 0, sizeof(struct udp_msg)); 838 if ((msg->len = udp_rcv_dat(cepid, &msg->dst, msg->buffer, sizeof(msg->buffer), 0)) < 0) { 839 syslog(LOG_WARNING, "[UDP ECHO SRV] recv, error: %s", itron_strerror(msg->len)); 840 return msg->len; 841 } 842 msg_no = (msg_no + 1) % 2; 843 return snd_dtq(MRUBY_DATAQUEUE, (intptr_t)msg); 844 845 case TFN_UDP_SND_DAT: 846 break; 847 default: 848 syslog(LOG_WARNING, "[UDP ECHO SRV] fncd:0x%04X(%s)", -fncd, 849 (fncd == TFN_UDP_CRE_CEP ? "TFN_UDP_CRE_CEP" : 850 (fncd == TFN_UDP_RCV_DAT ? "TFN_UDP_RCV_DAT" : 851 (fncd == TFN_UDP_SND_DAT ? "TFN_UDP_SND_DAT" : "undef")))); 852 853 error = E_PAR; 854 break; 855 } 856 return error; 857 } 858 859 static void netif_link_callback(T_IFNET *ether) 860 { 861 static struct udp_msg msg_inst[2]; 862 static int msg_no = 0; 863 struct udp_msg *msg = &msg_inst[msg_no]; 864 T_RTSK rtsk; 865 ER ret; 866 867 ret = ref_tsk(MRUBY_TASK, &rtsk); 868 if ((ret != E_OK) || (rtsk.tskstat == TTS_DMT)) 265 mreq.imr_interface.s_addr = INADDR_ANY; 266 mreq.imr_multiaddr.s_addr = MAKE_IPV4_ADDR(224, 0, 23, 0); 267 268 ret = setsockopt(sock, IPPROTO_IP, IP_ADD_MEMBERSHIP, (char *)&mreq, sizeof(mreq)); 269 if (ret != 0) { 270 printf("setsockopt %d", ret); 869 271 return; 870 871 memset(msg, 0, sizeof(struct udp_msg)); 872 873 msg->len = 1; 874 msg->buffer[0] = ether->flags; 875 876 msg_no = (msg_no + 1) % 2; 877 snd_dtq(MRUBY_DATAQUEUE, (intptr_t)msg); 272 } 273 274 ret = gettimeofday(&main_time, NULL); 275 if (ret != 0) { 276 printf("gettimeofday"); 277 return; 278 } 279 } 280 281 void mrb_target_board_final() 282 { 283 close(sock); 284 } 285 286 void mrb_target_board_break() 287 { 288 raise(SIGUSR1); 878 289 } 879 290 … … 883 294 static mrb_value mrb_target_board_wait_msg(mrb_state *mrb, mrb_value self) 884 295 { 885 TMO timer; 886 SYSTIM now; 887 ER ret, ret2; 888 struct udp_msg *msg; 296 int tmr; 297 struct timeval timer, *ptimer; 298 struct timeval now, elps; 299 int ret, ret2; 300 struct udp_msg _msg; 301 struct udp_msg *msg = &_msg; 889 302 mrb_value arv[3]; 890 static int first = 1; 891 892 mrb_get_args(mrb, "i", &timer); 893 if (timer != TMO_FEVR) 894 timer *= 1000; 895 896 if (first) { 897 first = 0; 898 syslog(LOG_NOTICE, "wait_msg"); 899 } 303 fd_set readfds, writefds, errorfds; 304 305 mrb_get_args(mrb, "i", &tmr); 306 307 if (tmr < 0) 308 ptimer = NULL; 309 else { 310 timer.tv_sec = tmr / 1000; 311 timer.tv_usec = (tmr % 1000) * 1000; 312 ptimer = &timer; 313 } 314 315 FD_ZERO(&readfds); 316 FD_ZERO(&writefds); 317 FD_ZERO(&errorfds); 318 FD_SET(sock, &readfds); 319 FD_SET(sock, &writefds); 320 FD_SET(sock, &errorfds); 900 321 901 322 /* ã¡ãã»ã¼ã¸å¾ 902 323 ã¡ */ 903 ret = trcv_dtq(MRUBY_DATAQUEUE, (intptr_t *)&msg, timer); 904 if ((ret != E_OK) && (ret != E_TMOUT)) { 905 syslog(LOG_ERROR, "trcv_dtq => %d", ret); 324 memset(msg, 0, sizeof(*msg)); 325 ret = select(sock + 1, &readfds, &writefds, &errorfds, ptimer); 326 if (ret < 0) 327 mrb_raise(mrb, E_RUNTIME_ERROR, "socket select error"); 328 if (FD_ISSET(sock, &readfds)) { 329 int fromlen = sizeof(msg->dst); 330 msg->len = recvfrom(sock, msg->buffer, sizeof(msg->buffer), 0, &msg->dst, &fromlen); 331 if (msg->len < 0) { 332 printf("recvfrom %d", msg->len); 333 return mrb_nil_value(); 334 } 335 } 336 337 ret2 = gettimeofday(&now, NULL); 338 if (ret2 != 0) { 339 printf("gettimeofday"); 906 340 return mrb_nil_value(); 907 341 } 908 342 909 ret2 = get_tim(&now); 910 if (ret2 != E_OK) { 911 syslog(LOG_ERROR, "get_tim => %d", ret); 912 return mrb_nil_value(); 913 } 914 915 arv[0] = mrb_fixnum_value((now - mruby_time) / 1000); 916 mruby_time = now; 343 timersub(&now, &main_time, &elps); 344 arv[0] = mrb_fixnum_value(elps.tv_sec); 345 main_time = now; 917 346 918 347 /* ã¿ã¤ã ã¢ã¦ãã®å ´å */ 919 if (ret == E_TMOUT) {348 if (ret == 0) { 920 349 return mrb_ary_new_from_values(mrb, 1, arv); 921 350 } … … 923 352 /* å 924 353 é¨ã¤ãã³ãã®å ´å */ 925 if (msg->dst. ipaddr == 0) {354 if (msg->dst.sin_addr.s_addr == 0) { 926 355 /* Ethernet Link up */ 927 356 if (msg->buffer[0] & IF_FLAG_LINK_UP) { … … 931 360 else if (msg->buffer[0] & IF_FLAG_UP) { 932 361 arv[1] = mrb_fixnum_value(2); 933 }934 else {935 arv[1] = mrb_fixnum_value(0);936 362 } 937 363 … … 967 393 mrb_value rep; 968 394 mrb_value rdat; 969 T_IPV4EP*ep;970 ER_UINTret;395 struct sockaddr_in *ep; 396 int ret; 971 397 972 398 mrb_get_args(mrb, "SS", &rep, &rdat); 973 399 974 if (RSTRING_LEN(rep) != sizeof( T_IPV4EP)) {400 if (RSTRING_LEN(rep) != sizeof(struct sockaddr_in)) { 975 401 mrb_raise(mrb, E_RUNTIME_ERROR, "snd_msg"); 976 402 return mrb_nil_value(); 977 403 } 978 404 979 ep = ( T_IPV4EP*)RSTRING_PTR(rep);980 981 ret = udp_snd_dat(MRUBY_ECNL_UDP_CEPID, ep, RSTRING_PTR(rdat), RSTRING_LEN(rdat), TMO_FEVR);405 ep = (struct sockaddr_in *)RSTRING_PTR(rep); 406 407 ret = sendto(sock, RSTRING_PTR(rdat), RSTRING_LEN(rdat), 0, (struct sockaddr *)ep, sizeof(*ep)); 982 408 if (ret < 0) { 983 mrb_raise(mrb, E_RUNTIME_ERROR, "s nd_msg");409 mrb_raise(mrb, E_RUNTIME_ERROR, "sendto"); 984 410 return mrb_nil_value(); 985 411 } … … 994 420 { 995 421 mrb_value rep; 996 T_IPV4EP*ep;422 struct sockaddr_in *ep; 997 423 998 424 mrb_get_args(mrb, "S", &rep); 999 425 1000 if (RSTRING_LEN(rep) < sizeof( T_IPV4EP)) {426 if (RSTRING_LEN(rep) < sizeof(struct sockaddr_in)) { 1001 427 mrb_raise(mrb, E_RUNTIME_ERROR, "is_local_addr"); 1002 428 return mrb_nil_value(); 1003 429 } 1004 430 1005 ep = ( T_IPV4EP*)RSTRING_PTR(rep);1006 1007 return (ep-> ipaddr == MAKE_IPV4_ADDR(127, 0, 0, 1)) ? mrb_true_value() : mrb_false_value();431 ep = (struct sockaddr_in *)RSTRING_PTR(rep); 432 433 return (ep->sin_addr.s_addr == MAKE_IPV4_ADDR(127, 0, 0, 1)) ? mrb_true_value() : mrb_false_value(); 1008 434 } 1009 435 … … 1014 440 { 1015 441 mrb_value rep; 1016 T_IPV4EP*ep;442 struct sockaddr_in *ep; 1017 443 1018 444 mrb_get_args(mrb, "S", &rep); 1019 445 1020 if (RSTRING_LEN(rep) < sizeof( T_IPV4EP)) {446 if (RSTRING_LEN(rep) < sizeof(struct sockaddr_in)) { 1021 447 mrb_raise(mrb, E_RUNTIME_ERROR, "is_multicast_addr"); 1022 448 return mrb_nil_value(); 1023 449 } 1024 450 1025 ep = ( T_IPV4EP*)RSTRING_PTR(rep);1026 1027 return (ep-> ipaddr == MAKE_IPV4_ADDR(224, 0, 23, 0)) ? mrb_true_value() : mrb_false_value();451 ep = (struct sockaddr_in *)RSTRING_PTR(rep); 452 453 return (ep->sin_addr.s_addr == MAKE_IPV4_ADDR(224, 0, 23, 0)) ? mrb_true_value() : mrb_false_value(); 1028 454 } 1029 455 … … 1034 460 { 1035 461 mrb_value rep1, rep2; 1036 T_IPV4EP*ep1, *ep2;462 struct sockaddr_in *ep1, *ep2; 1037 463 1038 464 mrb_get_args(mrb, "SS", &rep1, &rep2); 1039 465 1040 if ((RSTRING_LEN(rep1) != sizeof( T_IPV4EP)) || (RSTRING_LEN(rep2) != sizeof(T_IPV4EP))) {466 if ((RSTRING_LEN(rep1) != sizeof(struct sockaddr_in)) || (RSTRING_LEN(rep2) != sizeof(struct sockaddr_in))) { 1041 467 mrb_raise(mrb, E_RUNTIME_ERROR, "equals_addr"); 1042 468 return mrb_nil_value(); 1043 469 } 1044 470 1045 ep1 = ( T_IPV4EP*)RSTRING_PTR(rep1);1046 ep2 = ( T_IPV4EP*)RSTRING_PTR(rep2);1047 1048 return (ep1-> ipaddr == ep2->ipaddr) ? mrb_true_value() : mrb_false_value();471 ep1 = (struct sockaddr_in *)RSTRING_PTR(rep1); 472 ep2 = (struct sockaddr_in *)RSTRING_PTR(rep2); 473 474 return (ep1->sin_addr.s_addr == ep2->sin_addr.s_addr) ? mrb_true_value() : mrb_false_value(); 1049 475 } 1050 476 … … 1054 480 static mrb_value mrb_target_board_get_local_addr(mrb_state *mrb, mrb_value self) 1055 481 { 1056 T_IPV4EPep;482 struct sockaddr_in ep; 1057 483 mrb_value rep; 1058 484 1059 ep.ipaddr = MAKE_IPV4_ADDR(127, 0, 0, 1); 1060 ep.portno = 3610; 485 memset(&ep, 0, sizeof(ep)); 486 ep.sin_family = AF_INET; 487 ep.sin_addr.s_addr = MAKE_IPV4_ADDR(127, 0, 0, 1); 488 ep.sin_port = htons(3610); 1061 489 1062 490 rep = mrb_str_new(mrb, (char *)&ep, sizeof(ep)); … … 1070 498 static mrb_value mrb_target_board_get_multicast_addr(mrb_state *mrb, mrb_value self) 1071 499 { 1072 T_IPV4EPep;500 struct sockaddr_in ep; 1073 501 mrb_value rep; 1074 502 1075 ep.ipaddr = MAKE_IPV4_ADDR(224, 0, 23, 0); 1076 ep.portno = 3610; 503 memset(&ep, 0, sizeof(ep)); 504 ep.sin_family = AF_INET; 505 ep.sin_addr.s_addr = MAKE_IPV4_ADDR(224, 0, 23, 0); 506 ep.sin_port = htons(3610); 1077 507 1078 508 rep = mrb_str_new(mrb, (char *)&ep, sizeof(ep)); … … 1083 513 void mrb_mruby_others_gem_init(mrb_state* mrb) 1084 514 { 515 if (!echonet) 516 return; 517 1085 518 _module_target_board = mrb_define_module(mrb, "TargetBoard"); 1086 1087 // mbed Pin Names1088 mrb_define_const(mrb, _module_target_board, "LED1", mrb_fixnum_value(LED1));1089 mrb_define_const(mrb, _module_target_board, "LED2", mrb_fixnum_value(LED2));1090 mrb_define_const(mrb, _module_target_board, "LED3", mrb_fixnum_value(LED3));1091 mrb_define_const(mrb, _module_target_board, "LED4", mrb_fixnum_value(LED4));1092 1093 mrb_define_const(mrb, _module_target_board, "LED_RED", mrb_fixnum_value(LED_RED));1094 mrb_define_const(mrb, _module_target_board, "LED_GREEN", mrb_fixnum_value(LED_GREEN));1095 mrb_define_const(mrb, _module_target_board, "LED_BLUE", mrb_fixnum_value(LED_BLUE));1096 mrb_define_const(mrb, _module_target_board, "LED_USER", mrb_fixnum_value(LED_USER));1097 1098 mrb_define_const(mrb, _module_target_board, "USBTX", mrb_fixnum_value(USBTX));1099 mrb_define_const(mrb, _module_target_board, "USBRX", mrb_fixnum_value(USBRX));1100 1101 // Arduiono Pin Names1102 mrb_define_const(mrb, _module_target_board, "D0", mrb_fixnum_value(D0));1103 mrb_define_const(mrb, _module_target_board, "D1", mrb_fixnum_value(D1));1104 mrb_define_const(mrb, _module_target_board, "D2", mrb_fixnum_value(D2));1105 mrb_define_const(mrb, _module_target_board, "D3", mrb_fixnum_value(D3));1106 mrb_define_const(mrb, _module_target_board, "D4", mrb_fixnum_value(D4));1107 mrb_define_const(mrb, _module_target_board, "D5", mrb_fixnum_value(D5));1108 mrb_define_const(mrb, _module_target_board, "D6", mrb_fixnum_value(D6));1109 mrb_define_const(mrb, _module_target_board, "D7", mrb_fixnum_value(D7));1110 mrb_define_const(mrb, _module_target_board, "D8", mrb_fixnum_value(D8));1111 mrb_define_const(mrb, _module_target_board, "D9", mrb_fixnum_value(D9));1112 mrb_define_const(mrb, _module_target_board, "D10", mrb_fixnum_value(D10));1113 mrb_define_const(mrb, _module_target_board, "D11", mrb_fixnum_value(D11));1114 mrb_define_const(mrb, _module_target_board, "D12", mrb_fixnum_value(D12));1115 mrb_define_const(mrb, _module_target_board, "D13", mrb_fixnum_value(D13));1116 mrb_define_const(mrb, _module_target_board, "D14", mrb_fixnum_value(D14));1117 mrb_define_const(mrb, _module_target_board, "D15", mrb_fixnum_value(D15));1118 1119 mrb_define_const(mrb, _module_target_board, "A0", mrb_fixnum_value(A0));1120 mrb_define_const(mrb, _module_target_board, "A1", mrb_fixnum_value(A1));1121 mrb_define_const(mrb, _module_target_board, "A2", mrb_fixnum_value(A2));1122 mrb_define_const(mrb, _module_target_board, "A3", mrb_fixnum_value(A3));1123 mrb_define_const(mrb, _module_target_board, "A4", mrb_fixnum_value(A4));1124 mrb_define_const(mrb, _module_target_board, "A5", mrb_fixnum_value(A5));1125 1126 mrb_define_const(mrb, _module_target_board, "I2C_SCL", mrb_fixnum_value(I2C_SCL));1127 mrb_define_const(mrb, _module_target_board, "I2C_SDA", mrb_fixnum_value(I2C_SDA));1128 1129 mrb_define_const(mrb, _module_target_board, "USER_BUTTON0", mrb_fixnum_value(USER_BUTTON0));1130 1131 // Not connected1132 mrb_define_const(mrb, _module_target_board, "NC", mrb_fixnum_value(NC));1133 519 1134 520 mrb_define_class_method(mrb, _module_target_board, "wait_msg", mrb_target_board_wait_msg, MRB_ARGS_REQ(1)); … … 1140 526 mrb_define_class_method(mrb, _module_target_board, "get_local_addr", mrb_target_board_get_local_addr, MRB_ARGS_NONE()); 1141 527 mrb_define_class_method(mrb, _module_target_board, "get_multicast_addr", mrb_target_board_get_multicast_addr, MRB_ARGS_NONE()); 528 529 mrb_target_board_init(); 1142 530 } 1143 531 1144 532 void mrb_mruby_others_gem_final(mrb_state* mrb) 1145 533 { 1146 } 534 if (!echonet) 535 return; 536 537 mrb_target_board_final(); 538 } 539 540 // Provide implementation of _sbrk (low-level dynamic memory allocation 541 // routine) for GCC_ARM which compares new heap pointer with MSP instead of 542 // SP. This make it compatible with RTX RTOS thread stacks. 543 544 // Linker defined symbol used by _sbrk to indicate where heap should start. 545 int _end; 546 uint32_t _stack; 547 548 // Turn off the errno macro and use actual global variable instead. 549 #undef errno 550 int errno; 551 552 static unsigned char* heap = (unsigned char*)&_end; 553 554 // Dynamic memory allocation related syscall. 555 caddr_t _sbrk(int incr) { 556 unsigned char* prev_heap = heap; 557 unsigned char* new_heap = heap + incr; 558 559 if (new_heap >= (unsigned char*)&_stack) { /* _stack is end of heap section */ 560 errno = ENOMEM; 561 return (caddr_t)-1; 562 } 563 564 heap = new_heap; 565 return (caddr_t) prev_heap; 566 } 567 568 char *optarg; 569 int _data, _mdata, _edata; 570 int _bss, _ebss; 571 572 int _PowerON_Reset(int argc, char **argv) 573 { 574 memcpy(&_data, &_mdata, (size_t)&_edata - (size_t)&_data); 575 memset(&_bss, 0, (size_t)&_ebss - (size_t)&_bss); 576 577 optarg = *argv; 578 return main(argc, argv); 579 } 580 581 #define FVECT_SECT __attribute__ ((section (".fvectors"))) 582 const void *HardwareVectors[] FVECT_SECT = { 583 _PowerON_Reset, 584 mrdb_break, 585 }; 586 587 char stack_space[0x100000] __attribute__ ((section (".stack")));
Note:
See TracChangeset
for help on using the changeset viewer.