Ignore:
Timestamp:
Apr 29, 2017, 4:33:37 PM (7 years ago)
Author:
coas-nagasima
Message:

ファイルを追加、更新。

Location:
EcnlProtoTool/trunk/ntshell
Files:
57 added
14 edited

Legend:

Unmodified
Added
Removed

  • EcnlProtoTool/trunk/ntshell/fatfs/ccsbcs.c

    r278 r279  
    266266
    267267
    268 #if !_TBLDEF || !_USE_LFN
     268#if _CODE_PAGE != 65001 && (!_TBLDEF || !_USE_LFN)
    269269#error This file is not needed at current configuration. Remove from the project.
    270270#endif
    … …  
    272272
    273273
    274 
     274#if _CODE_PAGE != 65001
    275275WCHAR ff_convert (      /* Converted character, Returns zero on error */
    276276        WCHAR   chr,    /* Character code to be converted */
    … …  
    298298        return c;
    299299}
    300 
     300#endif
    301301
    302302

  • EcnlProtoTool/trunk/ntshell/fatfs/diskio.c

    r278 r279  
    1515#define MAX_DRIVES      1       /* Max number of physical drives to be used */
    1616
    17 unsigned char RamDisk[SZ_RAMDISK * 1024];
     17#define RamDisk _binary____webserver_httpd_fs_bin_start
     18extern unsigned char RamDisk[];
    1819
    1920typedef struct {

  • EcnlProtoTool/trunk/ntshell/fatfs/ff.c

    r278 r279  
    314314#endif
    315315#define _DF1S   0
     316
     317#elif _CODE_PAGE == 65001 /* UTF-8 */
     318#if _LFN_UNICODE
     319#error Cannot use LFN_UNICODE feature without valid code page.
     320#endif
     321#define _DF1S   0
     322
     323void Utf16_to_Utf8(unsigned char *ret_code, int *ret_size, UINT chr)
     324{
     325        ret_code[0] = ret_code[1] = ret_code[2] = ret_code[3] = 0;
     326
     327        if (chr <= 0x7f) {  // ASCII互換
     328                ret_code[0] = chr;
     329                *ret_size = 1;
     330                return;
     331        }
     332
     333        if (chr <= 0x7ff) {
     334                ret_code[1] = (0x80 | (chr & 0x3f));
     335                ret_code[0] = (0xc0 | (chr >> 6));
     336                *ret_size = 2;
     337                return;
     338        }
     339
     340        if (chr <= 0xffff) {
     341                ret_code[2] = (0x80 | (chr & 0x3f));
     342                ret_code[1] = (0x80 | ((chr >> 6) & 0x3f));
     343                ret_code[0] = (0xe0 | ((chr >> 12) & 0x0f));
     344                *ret_size = 3;
     345                return;
     346        }
     347
     348        if (chr <= 0x1fffff) {
     349                ret_code[3] = (0x80 | (chr & 0x3f));
     350                ret_code[2] = (0x80 | ((chr >> 6) & 0x3f));
     351                ret_code[1] = (0x80 | ((chr >> 12) & 0x3f));
     352                ret_code[0] = (0xf0 | ((chr >> 18) & 0x07));
     353                *ret_size = 4;
     354                return;
     355        }
     356
     357        if (chr <= 0x3ffffff) {
     358                ret_code[4] = (0x80 | (chr & 0x3f));
     359                ret_code[3] = (0x80 | ((chr >> 6) & 0x3f));
     360                ret_code[2] = (0x80 | ((chr >> 12) & 0x3f));
     361                ret_code[1] = (0x80 | ((chr >> 18) & 0x3f));
     362                ret_code[0] = (0xf8 | ((chr >> 24) & 0x03));
     363                *ret_size = 5;
     364                return;
     365        }
     366
     367        ret_code[5] = (0x80 | (chr & 0x3f));
     368        ret_code[4] = (0x80 | ((chr >> 6) & 0x3f));
     369        ret_code[3] = (0x80 | ((chr >> 12) & 0x3f));
     370        ret_code[2] = (0x80 | ((chr >> 18) & 0x3f));
     371        ret_code[1] = (0x80 | ((chr >> 24) & 0x3f));
     372        ret_code[0] = (0xfc | ((chr >> 30) & 0x01));
     373        *ret_size = 6;
     374        return;
     375}
     376
     377//2バイトのUTF-16コードが得られる
     378WCHAR Utf8_to_Utf16(const char *src, int *code_size)
     379{
     380        int i;
     381        unsigned int uc = 0;
     382        unsigned char len = 0;
     383
     384        len = 0;
     385        if ((src[0] & 0x80) == 0) { uc = src[0] & 0x7F; len = 0; }
     386        else if ((src[0] & 0xE0) == 0xC0) { uc = src[0] & 0x1F; len = 1; }
     387        else if ((src[0] & 0xF0) == 0xE0) { uc = src[0] & 0x0F; len = 2; }
     388        else if ((src[0] & 0xF8) == 0xF0) { uc = src[0] & 0x07; len = 3; }
     389        else if ((src[0] & 0xFC) == 0xF8) { uc = src[0] & 0x03; len = 4; }
     390        else if ((src[0] & 0xFE) == 0xFC) { uc = src[0] & 0x01; len = 5; }
     391
     392        i = 1;
     393        while ((i <= len) && ((src[i] & 0xC0) == 0x80)) {
     394                uc = (uc << 6) | (src[i] & 0x3F);
     395                i++;
     396        }
     397
     398        //消費文字数設定
     399        *code_size = i;
     400
     401        //現状、2バイト限定
     402        return uc;
     403}
    316404
    317405#else
    … …  
    17121800        WCHAR w, *lfn;
    17131801#endif
     1802#if _CODE_PAGE == 65001
     1803        unsigned char utf8_code[6];
     1804        int code_size;
     1805#endif
    17141806
    17151807        p = fno->fname;
    … …  
    17481840                        while ((w = *lfn++) != 0) {             /* Get an LFN character */
    17491841#if !_LFN_UNICODE
     1842#if _CODE_PAGE == 65001
     1843                                Utf16_to_Utf8(utf8_code, &code_size, w);
     1844                                for (int j = 0; j < code_size - 1; j++) {
     1845                                        p[i++] = utf8_code[j];
     1846                                }
     1847                                w = utf8_code[code_size - 1];
     1848#else
    17501849                                w = ff_convert(w, 0);           /* Unicode -> OEM */
    17511850                                if (!w) { i = 0; break; }       /* No LFN if it could not be converted */
    … …  
    17531852                                        p[i++] = (TCHAR)(w >> 8);
    17541853#endif
     1854#endif
    17551855                                if (i >= fno->lfsize - 1) { i = 0; break; }     /* No LFN if buffer overflow */
    17561856                                p[i++] = (TCHAR)w;
    … …  
    17781878
    17791879#if !_LFN_UNICODE
     1880#if _CODE_PAGE == 65001
     1881        int code_size;
     1882        chr = Utf8_to_Utf16(*ptr, &code_size);
     1883        (*ptr) += code_size;
     1884#else
    17801885        chr = (BYTE)*(*ptr)++;                                  /* Get a byte */
    17811886        if (IsLower(chr)) chr -= 0x20;                  /* To upper ASCII char */
    17821887        if (IsDBCS1(chr) && IsDBCS2(**ptr))             /* Get DBC 2nd byte if needed */
    17831888                chr = chr << 8 | (BYTE)*(*ptr)++;
     1889#endif
    17841890#ifdef _EXCVT
    17851891        if (chr >= 0x80) chr = ExCvt[chr - 0x80];       /* To upper SBCS extended char */
    … …  
    18511957        UINT i, ni, si, di;
    18521958        const TCHAR *p;
    1853 
     1959#if _CODE_PAGE == 65001
     1960        char utf8_code[6];
     1961        int code_size;
     1962#endif
    18541963        /* Create LFN in Unicode */
    18551964        for (p = *path; *p == '/' || *p == '\\'; p++) ; /* Strip duplicated separator */
    … …  
    18621971                        return FR_INVALID_NAME;
    18631972#if !_LFN_UNICODE
     1973#if _CODE_PAGE == 65001
     1974                w = Utf8_to_Utf16(&p[si - 1], &code_size);
     1975                si += code_size - 1;
     1976#else
    18641977                w &= 0xFF;
    18651978                if (IsDBCS1(w)) {                               /* Check if it is a DBC 1st byte (always false on SBCS cfg) */
    … …  
    18711984                w = ff_convert(w, 1);                   /* Convert ANSI/OEM to Unicode */
    18721985                if (!w) return FR_INVALID_NAME; /* Reject invalid code */
     1986#endif
    18731987#endif
    18741988                if (w < 0x80 && chk_chr("\"*:<>\?|\x7F", w)) /* Reject illegal characters for LFN */
    … …  
    19252039                        if (w) w = ExCvt[w - 0x80];     /* Convert extended character to upper (SBCS) */
    19262040#else
     2041#if _CODE_PAGE == 65001
     2042                        Utf16_to_Utf8(utf8_code, &code_size, ff_wtoupper(w));
     2043#else
    19272044                        w = ff_convert(ff_wtoupper(w), 0);      /* Upper converted Unicode -> OEM code */
    19282045#endif
     2046#endif
    19292047                        cf |= NS_LFN;                           /* Force create LFN entry */
    19302048                }
    1931 
     2049#if _CODE_PAGE == 65001
     2050                else
     2051                        code_size = 1;
     2052#endif
     2053
     2054#if _CODE_PAGE == 65001
     2055                if (code_size > 1) {            /* Is this DBC? (always false at SBCS cfg) */
     2056                        if (i >= ni - 1) {
     2057                                cf |= NS_LOSS | NS_LFN; i = ni; continue;
     2058                        }
     2059                        for (int j = 0; j < code_size; j++) {
     2060                                dp->fn[i++] = (BYTE)utf8_code[j];
     2061                        }
     2062                }
     2063                else {                                          /* SBC */
     2064                        if (!w || chk_chr("+,;=[]", w)) {       /* Replace illegal characters for SFN */
     2065                                w = '_'; cf |= NS_LOSS | NS_LFN;/* Lossy conversion */
     2066                        }
     2067                        else {
     2068                                if (IsUpper(w)) {               /* ASCII large capital */
     2069                                        b |= 2;
     2070                                }
     2071                                else {
     2072                                        if (IsLower(w)) {       /* ASCII small capital */
     2073                                                b |= 1; w -= 0x20;
     2074                                        }
     2075                                }
     2076                        }
     2077                        dp->fn[i++] = (BYTE)w;
     2078                }
     2079#else
    19322080                if (_DF1S && w >= 0x100) {              /* Is this DBC? (always false at SBCS cfg) */
    19332081                        if (i >= ni - 1) {
    … …  
    19492097                }
    19502098                dp->fn[i++] = (BYTE)w;
     2099#endif
    19512100        }
    19522101
    … …  
    31783327}
    31793328
    3180 
     3329FRESULT f_seek(FIL* fp, DWORD ofs, BYTE mode)
     3330{
     3331  switch (mode) {
     3332  case F_SEEK_SET:
     3333    return f_lseek((fp), ofs);
     3334  case F_SEEK_CUR:
     3335    return f_lseek((fp), (fp)->fptr + ofs);
     3336  case F_SEEK_END:
     3337    return f_lseek((fp), (fp)->fsize - ofs);
     3338  default:
     3339    return FR_INVALID_PARAMETER;
     3340  }
     3341}
    31813342
    31823343#if _FS_MINIMIZE <= 1
    … …  
    37193880        DWORD dw;
    37203881        DEFINE_NAMEBUF;
     3882        TCHAR *temp_new_path = 0;
    37213883
    37223884
    … …  
    37423904                                else
    37433905                                        res = FR_INVALID_DRIVE;
    3744                                 if (res == FR_OK) res = FR_EXIST;               /* The new object name is already existing */
     3906                                if (res == FR_OK) {
     3907                                        res = FR_EXIST;         /* The new object name is already existing */
     3908                                        dir = djn.dir;
     3909                                        if (dir[DIR_Attr] & AM_DIR) {   /* The new object is a directory */
     3910                                                temp_new_path = (TCHAR *)ff_memalloc((_MAX_LFN + 1) * sizeof(WCHAR));
     3911                                                snprintf(temp_new_path, _MAX_LFN, "%s/%s", path_new, basename((char *)path_old));
     3912                                                res = follow_path(&djn, temp_new_path);
     3913                                        }
     3914                                }
    37453915                                if (res == FR_NO_FILE) {                                /* It is a valid path and no name collision */
    37463916                                        res = dir_register(&djn);                       /* Register the new entry */
    … …  
    37773947        }
    37783948
     3949        if (temp_new_path != 0) ff_memfree(temp_new_path);
     3950
    37793951        LEAVE_FF(djo.fs, res);
    37803952}
    … …  
    39124084        WCHAR w;
    39134085        DWORD tm;
    3914 
     4086#if _CODE_PAGE == 65001
     4087        int code_size;
     4088        char utf8_code[6];
     4089#endif
    39154090
    39164091        /* Get logical drive number */
    … …  
    39254100                i = j = 0;
    39264101                do {
     4102#if _CODE_PAGE == 65001
     4103                        w = ff_wtoupper(Utf8_to_Utf16(&label[i], &code_size));
     4104                        i += code_size;
     4105                        Utf16_to_Utf8(utf8_code, &code_size, w);
     4106                        if (!w || chk_chr("\"*+,.:;<=>\?[]|\x7F", w) || j >= sizeof(vn) - code_size) /* Reject invalid characters for volume label */
     4107                                LEAVE_FF(dj.fs, FR_INVALID_NAME);
     4108                        for (int k = 0; k < code_size; k++)
     4109                                vn[j++] = utf8_code[k];
     4110#else
    39274111#if _USE_LFN && _LFN_UNICODE
    39284112                        w = ff_convert(ff_wtoupper(label[i++]), 0);
    … …  
    39464130                        if (w >= 0x100) vn[j++] = (BYTE)(w >> 8);
    39474131                        vn[j++] = (BYTE)w;
     4132#endif
    39484133                } while (i < sl);
    39494134                while (j < 11) vn[j++] = ' ';   /* Fill remaining name field */

  • EcnlProtoTool/trunk/ntshell/fatfs/ff.h

    r278 r279  
    143143/* Directory object structure (DIR) */
    144144
    145 typedef struct {
     145typedef struct __dirstream {
    146146        FATFS*  fs;                             /* Pointer to the owner file system object (**do not change order**) */
    147147        WORD    id;                             /* Owner file system mount ID (**do not change order**) */
    … …  
    162162        const TCHAR*    pat;    /* Pointer to the name matching pattern */
    163163#endif
     164        struct dirent *dirent;
    164165} DIR;
    165166
    … …  
    252253#define f_rewind(fp) f_lseek((fp), 0)
    253254#define f_rewinddir(dp) f_readdir((dp), 0)
    254 #define f_flush(fp)
     255#define f_flush(fp) (FR_OK)
    255256
    256257#define F_SEEK_SET 1
    257258#define F_SEEK_CUR 2
    258259#define F_SEEK_END 3
    259 static FRESULT f_seek(FIL* fp, DWORD ofs, BYTE mode)
    260 {
    261   switch (mode) {
    262   case F_SEEK_SET:
    263     return f_lseek((fp), ofs);
    264   case F_SEEK_CUR:
    265     return f_lseek((fp), (fp)->fptr + ofs);
    266   case F_SEEK_END:
    267     return f_lseek((fp), (fp)->fsize - ofs);
    268   default:
    269     return FR_INVALID_PARAMETER;
    270   }
    271 }
     260FRESULT f_seek(FIL* fp, DWORD ofs, BYTE mode);
    272261
    273262#ifndef EOF

  • EcnlProtoTool/trunk/ntshell/fatfs/ffarch.c

    r278 r279  
    5656#include <kernel.h>
    5757#include <stdlib.h>
    58 #include <errno.h>
    59 #include <sys/types.h>
    6058#include <string.h>
    6159#include "t_stdlib.h"
     60#include "syssvc/serial.h"
    6261#include "syssvc/syslog.h"
    6362#include "kernel_cfg.h"
    … …  
    6564#include "sdfs.h"
    6665#include "ff.h"
     66#include "tlsf.h"
     67#include "ntstdio.h"
     68
     69#define SIO_PORTID 1
     70extern ntstdio_t ntstdio;
     71
     72static tlsf_t sys_tlsf;
     73static pool_t sys_pool;
     74
     75uint32_t  __HeapBase;
     76uint32_t  __HeapLimit;
     77FATFS RomDisk;
    6778
    6879gpio_t ins;
    … …  
    7081#define WP() false
    7182
    72 extern FATFS RomDisk;
    73 extern unsigned char RamDisk[SZ_RAMDISK * 1024];
    74 
     83typedef struct SD {
     84        DSTATUS dst;
     85        BYTE type;
     86        FATFS FatFs;
     87} SD;
     88SD Sd;
     89
     90void sys_init(void);
    7591bool_t romdisk_init();
     92bool_t SD_begin();
    7693
    7794int mruby_arduino_init()
    7895{
    7996        int result = -1;
     97
     98        sys_init();
    8099
    81100        /* SD_CD */
    … …  
    85104        sdfs_init(&sdfs, P8_5, P8_6, P8_3, P8_4, "sd");
    86105
    87         SD_begin();
    88 
    89         FIL fd;
    90         UINT rlen = 0;
    91         memset(&fd, 0, sizeof(fd));
    92         if (f_open(&fd, "1:/httpd-fs.bin", FA_OPEN_EXISTING | FA_READ) == FR_OK) {
    93                 f_read(&fd, RamDisk, SZ_RAMDISK * 1024, &rlen);
    94                 f_close(&fd);
    95                 if (romdisk_init())
    96                         result = 0;
    97         }
    98 
     106        result = SD_begin() ? 0 : -1;
    99107        if (result == 0) {
    100                 syslog(LOG_NOTICE, "ramdisk ok!");
     108                ntstdio_printf(&ntstdio, "SD card (1:) OK!\n");
    101109        }
    102110        else {
    103                 syslog(LOG_NOTICE, "ramdisk ng!");
    104         }
    105 
    106         arduino_init();
     111                ntstdio_printf(&ntstdio, "SD card (1:) NG!\n");
     112        }
     113        sta_cyc(SDFS_CYC);
     114
     115        if (romdisk_init())
     116                result = 0;
     117
     118        if (result == 0) {
     119                ntstdio_printf(&ntstdio, "ROM disk (0:) OK!\n");
     120        }
     121        else {
     122                ntstdio_printf(&ntstdio, "ROM disk (0:) NG!\n");
     123        }
     124
     125        /* uploadディレクトリを作成しておく */
     126        f_mkdir("1:/upload");
     127
     128        serial_ctl_por(SIO_PORTID, IOCTL_FCSND | IOCTL_FCRCV);
    107129
    108130        return result;
     131}
     132
     133void sys_init(void)
     134{
     135        sys_tlsf = tlsf_create(&__HeapBase);
     136        if (sys_tlsf == NULL)
     137                return;
     138
     139        sys_pool = tlsf_add_pool(sys_tlsf, ((uint8_t *)&__HeapBase) + tlsf_size(), ((size_t)&__HeapLimit - (size_t)&__HeapBase) - tlsf_size());
     140}
     141
     142void sys_fini(void)
     143{
     144        tlsf_destroy(sys_tlsf);
     145}
     146
     147void *sys_malloc(size_t size)
     148{
     149        return tlsf_malloc(sys_tlsf, size);
     150}
     151
     152void *sys_calloc(size_t size, size_t count)
     153{
     154        void *result = tlsf_malloc(sys_tlsf, count * size);
     155        memset(result, 0, count * size);
     156        return result;
     157}
     158
     159void *sys_realloc(void *ptr, size_t size)
     160{
     161        return tlsf_realloc(sys_tlsf, ptr, size);
     162}
     163
     164void sys_free(void *ptr)
     165{
     166        tlsf_free(sys_tlsf, ptr);
    109167}
    110168
    … …  
    122180
    123181        if ((res = f_mount(&RomDisk, "0:", 1)) != FR_OK) {
     182                return false;
     183        }
     184
     185        return true;
     186}
     187
     188bool_t SD_begin()
     189{
     190        DSTATUS dst;
     191        FRESULT res;
     192        BYTE pdrv = 1, type;
     193
     194        if (Sd.FatFs.fs_type != 0)
     195                return true;
     196
     197        if ((dst = disk_initialize(pdrv)) != RES_OK) {
     198                return false;
     199        }
     200
     201        if ((dst = disk_ioctl(pdrv, MMC_GET_TYPE, &type)) != RES_OK) {
     202                Sd.dst = dst;
     203                Sd.type = 0;
     204        }
     205        else {
     206                Sd.dst = RES_OK;
     207                Sd.type = type;
     208        }
     209
     210        if ((res = f_mount(&Sd.FatFs, "1:", 1)) != FR_OK) {
    124211                return false;
    125212        }
    … …  
    207294}
    208295
    209 static int lock[TNUM_TSKID];
    210 static int stack_pos[TNUM_TSKID];
    211 
    212 void __malloc_lock(struct _reent *a)
    213 {
    214         ID tskid;
     296int ff_cre_syncobj(BYTE vol, _SYNC_t* sobj)
     297{
     298        return 1;
     299}
     300
     301int ff_req_grant(_SYNC_t sobj)
     302{
    215303        ER ret;
    216         int count, sp;
    217 
    218         ret = get_tid(&tskid);
    219         if (ret != E_OK) {
    220                 /*syslog(LOG_DEBUG, "get_tid %s", itron_strerror(ret));*/
    221                 Asm("bkpt #0");
    222         }
    223 
    224         Asm("mov %0, sp" : "=r"(sp) :);
    225         if ((stack_pos[tskid - 1] == 0) || (stack_pos[tskid - 1] < sp))
    226                 stack_pos[tskid - 1] = sp;
    227 
    228         count = ++lock[tskid - 1];
    229         if (count != 1)
    230                 return;
    231 
    232         ret = wai_sem(SEM_MALLOC);
    233         if (ret != E_OK) {
    234                 /*syslog(LOG_DEBUG, "wai_sem %s", itron_strerror(ret));*/
    235                 Asm("bkpt #0");
    236         }
    237 }
    238 
    239 void __malloc_unlock(struct _reent *a)
    240 {
    241         ID tskid;
    242         ER ret;
    243         int count;
    244 
    245         ret = get_tid(&tskid);
    246         if (ret != E_OK) {
    247                 /*syslog(LOG_DEBUG, "get_tid %s", itron_strerror(ret));*/
    248                 Asm("bkpt #0");
    249         }
    250 
    251         count = --lock[tskid - 1];
    252         if(count != 0)
    253                 return;
    254 
    255         ret = sig_sem(SEM_MALLOC);
    256         if (ret != E_OK) {
    257                 /*syslog(LOG_DEBUG, "sig_sem %s", itron_strerror(ret));*/
    258                 Asm("bkpt #0");
    259         }
    260 }
    261 
    262 // Provide implementation of _sbrk (low-level dynamic memory allocation
    263 // routine) for GCC_ARM which compares new heap pointer with MSP instead of
    264 // SP.  This make it compatible with RTX RTOS thread stacks.
    265 
    266 // Linker defined symbol used by _sbrk to indicate where heap should start.
    267 int __end__;
    268 uint32_t  __HeapLimit;
    269 
    270 // Turn off the errno macro and use actual global variable instead.
    271 #undef errno
    272 int errno;
    273 
    274 static unsigned char* heap = (unsigned char*)&__end__;
    275 
    276 // Dynamic memory allocation related syscall.
    277 caddr_t _sbrk(int incr) {
    278         unsigned char*        prev_heap = heap;
    279         unsigned char*        new_heap = heap + incr;
    280 
    281         if (new_heap >= (unsigned char*)&__HeapLimit) {     /* __HeapLimit is end of heap section */
    282                 errno = ENOMEM;
    283                 return (caddr_t)-1;
    284         }
    285 
    286         heap = new_heap;
    287         return (caddr_t) prev_heap;
    288 }
    289 
    290 void reset_heap()
    291 {
    292         // .data
    293         extern uint8_t __malloc_av_[0x408];
    294         extern uint8_t __malloc_sbrk_base[0x4];
    295         extern uint8_t __malloc_trim_threshold[0x4];
    296         // .bss
    297         extern uint8_t __malloc_top_pad[0x4];
    298         extern uint8_t __malloc_current_mallinfo[0x28];
    299         extern uint8_t __malloc_max_sbrked_mem[0x4];
    300         extern uint8_t __malloc_max_total_mem[0x4];
    301         //
    302         extern void *__etext;
    303         extern void *__data_start__;
    304 
    305         int offset = (int)&__etext - (int)&__data_start__;
    306 
    307         __malloc_lock(_REENT);
    308 
    309         memcpy(__malloc_av_, &__malloc_av_[offset], sizeof(__malloc_av_));
    310         memcpy(__malloc_sbrk_base, &__malloc_sbrk_base[offset], sizeof(__malloc_sbrk_base));
    311         memcpy(__malloc_trim_threshold, &__malloc_trim_threshold[offset], sizeof(__malloc_trim_threshold));
    312 
    313         memset(__malloc_top_pad, 0, sizeof(__malloc_top_pad));
    314         memset(__malloc_current_mallinfo, 0, sizeof(__malloc_current_mallinfo));
    315         memset(__malloc_max_sbrked_mem, 0, sizeof(__malloc_max_sbrked_mem));
    316         memset(__malloc_max_total_mem, 0, sizeof(__malloc_max_total_mem));
    317 
    318         heap = (unsigned char*)&__end__;
    319 
    320         __malloc_unlock(_REENT);
    321 }
    322 
    323 void exit(int return_code) {
    324         Asm("bkpt #0");
    325         reset_heap();
    326         ext_tsk();
    327         for(;;);
    328 }
     304        ret = wai_sem(SEM_FILESYSTEM);
     305        return ret == E_OK;
     306}
     307
     308void ff_rel_grant(_SYNC_t sobj)
     309{
     310        sig_sem(SEM_FILESYSTEM);
     311}
     312
     313int ff_del_syncobj(_SYNC_t sobj)
     314{
     315        return 1;
     316}
     317
     318void* ff_memalloc (UINT msize)
     319{
     320        return sys_malloc(msize);
     321}
     322
     323void ff_memfree (void* mblock)
     324{
     325        sys_free(mblock);
     326}

  • EcnlProtoTool/trunk/ntshell/fatfs/ffarch.cfg

    r278 r279  
    5151 */
    5252
    53 #include "mruby_arduino.h"
     53#include "ffarch.h"
    5454
    55 CRE_CYC(SDFS_CYC, { TA_NULL, { TNFY_HANDLER, 0, sdfs_cychdr }, 1000, 0 });
     55CRE_CYC(SDFS_CYC, { TA_NULL, { TNFY_HANDLER, 0, sdfs_cychdr }, 1000000, 0 });
    5656
    5757CRE_SEM(SEM_MALLOC, { TA_TPRI, 1, 1 });

  • EcnlProtoTool/trunk/ntshell/fatfs/ffarch.h

    r278 r279  
    5454
    5555int mruby_arduino_init();
    56 void reset_heap();
    5756void sdfs_cychdr(intptr_t exinf);
    5857

  • EcnlProtoTool/trunk/ntshell/fatfs/ffconf.h

    r278 r279  
    6262/---------------------------------------------------------------------------*/
    6363
    64 #define _CODE_PAGE 437
     64#define _CODE_PAGE 65001
    6565/* This option specifies the OEM code page to be used on the target system.
    6666/  Incorrect setting of the code page can cause a file open failure.
    … …  
    9191
    9292
    93 #define _USE_LFN        1
     93#define _USE_LFN        3
    9494#define _MAX_LFN        255
    9595/* The _USE_LFN option switches the LFN feature.
    … …  
    227227
    228228
    229 #define _FS_REENTRANT   0
     229#define _FS_REENTRANT   1
    230230#define _FS_TIMEOUT             1000
    231 #define _SYNC_t                 HANDLE
     231#define _SYNC_t                 unsigned int
    232232/* The _FS_REENTRANT option switches the re-entrancy (thread safe) of the FatFs
    233233/  module itself. Note that regardless of this option, file access to different

  • EcnlProtoTool/trunk/ntshell/webserver/httpd-fs.c

    r270 r279  
    6060#include "kernel_cfg.h"
    6161#include "syssvc/syslog.h"
    62 #include "arduino.h"
     62#include "ntstdio.h"
    6363
    6464#ifndef _MSC_VER
    … …  
    9696                        fn = fno.fname;
    9797                        if (fno.fattrib & AM_DIR) {
    98                                 sprintf(&path[i], "0:/%s", fn);
     98                                ntstdio_sprintf(&path[i], "0:/%s", fn);
    9999                                res = scan_files(path, size);
    100100                                if (res != FR_OK) break;
    … …  
    112112/*-----------------------------------------------------------------------------------*/
    113113int
    114 httpd_fs_open_ul(char *name, int len, struct httpd_fs_file *file)
     114httpd_fs_open(char *name, int len, struct httpd_fs_file *file)
    115115{
    116116        FRESULT res;
    … …  
    157157}
    158158
    159 int
    160 httpd_fs_open(char *name, int len, struct httpd_fs_file *file)
    161 {
    162         int result;
    163 
    164         wai_sem(SEM_FILESYSTEM);
    165 
    166         result = httpd_fs_open_ul(name, len, file);
    167 
    168         sig_sem(SEM_FILESYSTEM);
    169 
    170         return result;
    171 }
    172 /*-----------------------------------------------------------------------------------*/
    173 int
    174 httpd_fs_create_ul(char *name, struct httpd_fs_file *file)
     159/*-----------------------------------------------------------------------------------*/
     160int
     161httpd_fs_create(char *name, struct httpd_fs_file *file)
    175162{
    176163        FRESULT res;
    … …  
    196183}
    197184
    198 int
    199 httpd_fs_create(char *name, struct httpd_fs_file *file)
    200 {
    201         int result;
    202 
    203         wai_sem(SEM_FILESYSTEM);
    204 
    205         result = httpd_fs_create_ul(name, file);
    206 
    207         sig_sem(SEM_FILESYSTEM);
    208 
    209         return result;
    210 }
    211 /*-----------------------------------------------------------------------------------*/
    212 int
    213 httpd_fs_read_ul(struct httpd_fs_file *file, void *dst, int len)
     185/*-----------------------------------------------------------------------------------*/
     186int
     187httpd_fs_read(struct httpd_fs_file *file, void *dst, int len)
    214188{
    215189        FRESULT ret;
    … …  
    236210}
    237211
    238 int
    239 httpd_fs_read(struct httpd_fs_file *file, void *dst, int len)
    240 {
    241         int result;
    242 
    243         wai_sem(SEM_FILESYSTEM);
    244 
    245         result = httpd_fs_read_ul(file, dst, len);
    246 
    247         sig_sem(SEM_FILESYSTEM);
    248 
    249         return result;
    250 }
    251 /*-----------------------------------------------------------------------------------*/
    252 int
    253 httpd_fs_write_ul(struct httpd_fs_file *file, const void *src, int len)
     212/*-----------------------------------------------------------------------------------*/
     213int
     214httpd_fs_write(struct httpd_fs_file *file, const void *src, int len)
    254215{
    255216        FRESULT ret;
    … …  
    279240}
    280241
    281 int
    282 httpd_fs_write(struct httpd_fs_file *file, const void *src, int len)
    283 {
    284         int result;
    285 
    286         wai_sem(SEM_FILESYSTEM);
    287 
    288         result = httpd_fs_write_ul(file, src, len);
    289 
    290         sig_sem(SEM_FILESYSTEM);
    291 
    292         return result;
    293 }
    294 /*-----------------------------------------------------------------------------------*/
    295 int httpd_fs_close_ul(struct httpd_fs_file *file)
     242/*-----------------------------------------------------------------------------------*/
     243int httpd_fs_close(struct httpd_fs_file *file)
    296244{
    297245        FRESULT ret;
    … …  
    307255        return 1;
    308256}
    309 
    310 int httpd_fs_close(struct httpd_fs_file *file)
    311 {
    312         int result;
    313 
    314         wai_sem(SEM_FILESYSTEM);
    315 
    316         result = httpd_fs_close_ul(file);
    317 
    318         sig_sem(SEM_FILESYSTEM);
    319 
    320         return result;
    321 }

  • EcnlProtoTool/trunk/ntshell/webserver/httpd-fs.h

    r270 r279  
    44 *  Copyright (C) 2017 Cores Co., Ltd. Japan
    55 *
    6  *  ã‹L’˜ìŒ ŽÒ‚́CˆÈ‰º‚Ì(1)`(4)‚ÌðŒ‚ð–ž‚½‚·ê‡‚ÉŒÀ‚èC–{ƒ\ƒtƒgƒEƒF
    7  *  ƒAi–{ƒ\ƒtƒgƒEƒFƒA‚ð‰ü•Ï‚µ‚½‚à‚Ì‚ðŠÜ‚ށDˆÈ‰º“¯‚¶j‚ðŽg—pE•¡»E‰ü
    8  *  •ÏEÄ”z•ziˆÈ‰ºC—˜—p‚ƌĂԁj‚·‚邱‚Ƃ𖳏ž‚Å‹–‘ø‚·‚éD
    9  *  (1) –{ƒ\ƒtƒgƒEƒFƒA‚ðƒ\[ƒXƒR[ƒh‚ÌŒ`‚Å—˜—p‚·‚éê‡‚ɂ́Cã‹L‚Ì’˜ì
    10  *      Œ •\Ž¦C‚±‚Ì—˜—pðŒ‚¨‚æ‚щº‹L‚Ì–³•ÛØ‹K’肪C‚»‚Ì‚Ü‚Ü‚ÌŒ`‚Ń\[
    11  *      ƒXƒR[ƒh’†‚ÉŠÜ‚Ü‚ê‚Ä‚¢‚邱‚ƁD
    12  *  (2) –{ƒ\ƒtƒgƒEƒFƒA‚ðCƒ‰ƒCƒuƒ‰ƒŠŒ`Ž®‚ȂǁC‘¼‚̃\ƒtƒgƒEƒFƒAŠJ”­‚ÉŽg
    13  *      —p‚Å‚«‚éŒ`‚ōĔz•z‚·‚éê‡‚ɂ́CÄ”z•z‚É”º‚¤ƒhƒLƒ
    14 ƒƒ“ƒgi—˜—p
    15  *      ŽÒƒ}ƒjƒ
    16 ƒAƒ‹‚Ȃǁj‚ɁCã‹L‚Ì’˜ìŒ •\Ž¦C‚±‚Ì—˜—pðŒ‚¨‚æ‚щº‹L
    17  *      ‚Ì–³•ÛØ‹K’è‚ðŒfÚ‚·‚邱‚ƁD
    18  *  (3) –{ƒ\ƒtƒgƒEƒFƒA‚ðC‹@Ší‚É‘g‚ݍž‚ނȂǁC‘¼‚̃\ƒtƒgƒEƒFƒAŠJ”­‚ÉŽg
    19  *      —p‚Å‚«‚È‚¢Œ`‚ōĔz•z‚·‚éê‡‚ɂ́CŽŸ‚Ì‚¢‚¸‚ê‚©‚ÌðŒ‚ð–ž‚½‚·‚±
    20  *      ‚ƁD
    21  *    (a) Ä”z•z‚É”º‚¤ƒhƒLƒ
    22 ƒƒ“ƒgi—˜—pŽÒƒ}ƒjƒ
    23 ƒAƒ‹‚Ȃǁj‚ɁCã‹L‚Ì’˜
    24  *        ìŒ •\Ž¦C‚±‚Ì—˜—pðŒ‚¨‚æ‚щº‹L‚Ì–³•ÛØ‹K’è‚ðŒfÚ‚·‚邱‚ƁD
    25  *    (b) Ä”z•z‚ÌŒ`‘Ô‚ðC•Ê‚É’è‚ß‚é•û–@‚É‚æ‚Á‚āCTOPPERSƒvƒƒWƒFƒNƒg‚É
    26  *        •ñ‚·‚邱‚ƁD
    27  *  (4) –{ƒ\ƒtƒgƒEƒFƒA‚Ì—˜—p‚É‚æ‚è’¼Ú“I‚Ü‚½‚͊ԐړI‚ɐ¶‚¶‚é‚¢‚©‚Ȃ鑹
    28  *      ŠQ‚©‚ç‚àCã‹L’˜ìŒ ŽÒ‚¨‚æ‚ÑTOPPERSƒvƒƒWƒFƒNƒg‚ð–Ɛӂ·‚邱‚ƁD
    29  *      ‚Ü‚½C–{ƒ\ƒtƒgƒEƒFƒA‚̃†[ƒU‚Ü‚½‚̓Gƒ“ƒhƒ†[ƒU‚©‚ç‚Ì‚¢‚©‚Ȃ闝
    30  *      —R‚ÉŠî‚­¿‹‚©‚ç‚àCã‹L’˜ìŒ ŽÒ‚¨‚æ‚ÑTOPPERSƒvƒƒWƒFƒNƒg‚ð
    31  *      –Ɛӂ·‚邱‚ƁD
     6 *  上記著作権è€
     7は，以下の(1)～(4)の条件を満たす場合に限り，本ソフトウェ
     8 *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
     9 *  変・再é
     10å¸ƒï¼ˆä»¥ä¸‹ï¼Œåˆ©ç”¨ã¨å‘¼ã¶ï¼‰ã™ã‚‹ã“とを無償で許諾する．
     11 *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
     12 *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
     13 *      スコード中に含まれていること．
     14 *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
     15 *      用できる形で再é
     16å¸ƒã™ã‚‹å ´åˆã«ã¯ï¼Œå†é
     17å¸ƒã«ä¼´ã†ãƒ‰ã‚­ãƒ¥ãƒ¡ãƒ³ãƒˆï¼ˆåˆ©ç”¨
     18 *      è€
     19マニュアルなど）に，上記の著作権表示，この利用条件および下記
     20 *      の無保証規定を掲載すること．
     21 *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
     22 *      用できない形で再é
     23å¸ƒã™ã‚‹å ´åˆã«ã¯ï¼Œæ¬¡ã®ã„ずれかの条件を満たすこ
     24 *      と．
     25 *    (a) 再é
     26å¸ƒã«ä¼´ã†ãƒ‰ã‚­ãƒ¥ãƒ¡ãƒ³ãƒˆï¼ˆåˆ©ç”¨è€
     27マニュアルなど）に，上記の著
     28 *        作権表示，この利用条件および下記の無保証規定を掲載すること．
     29 *    (b) 再é
     30å¸ƒã®å½¢æ
     31‹ã‚’，別に定める方法によって，TOPPERSプロジェクトに
     32 *        報告すること．
     33 *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
     34 *      害からも，上記著作権è€
     35およびTOPPERSプロジェクトをå
     36è²¬ã™ã‚‹ã“と．
     37 *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
     38 *      由に基づく請求からも，上記著作権è€
     39およびTOPPERSプロジェクトを
     40 *      å
     41è²¬ã™ã‚‹ã“と．
    3242 *
    33  *  –{ƒ\ƒtƒgƒEƒFƒA‚́C–³•ÛØ‚Å’ñ‹Ÿ‚³‚ê‚Ä‚¢‚é‚à‚Ì‚Å‚ ‚éDã‹L’˜ìŒ ŽÒ‚¨
    34  *  ‚æ‚ÑTOPPERSƒvƒƒWƒFƒNƒg‚́C–{ƒ\ƒtƒgƒEƒFƒA‚ÉŠÖ‚µ‚āC“Á’è‚ÌŽg—p–Ú“I
    35  *  ‚ɑ΂·‚é“K‡«‚àŠÜ‚߂āC‚¢‚©‚È‚é•ÛØ‚às‚í‚È‚¢D‚Ü‚½C–{ƒ\ƒtƒgƒEƒF
    36  *  ƒA‚Ì—˜—p‚É‚æ‚è’¼Ú“I‚Ü‚½‚͊ԐړI‚ɐ¶‚¶‚½‚¢‚©‚Ȃ鑹ŠQ‚ÉŠÖ‚µ‚Ä‚àC‚»
    37  *  ‚̐ӔC‚𕉂í‚È‚¢D
     43 *  本ソフトウェアは，無保証で提供されているものである．上記著作権è€
     44お
     45 *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
     46 *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
     47 *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
     48 *  の責任を負わない．
    3849 *
    3950 *  @(#) $Id$

  • EcnlProtoTool/trunk/ntshell/webserver/httpd.c

    r270 r279  
    5454#include <string.h>
    5555#include <stdlib.h>
     56#include "kernel_cfg.h"
     57#include "tinet_cfg.h"
    5658#include "syssvc/syslog.h"
    5759#include "http-strings.h"
    5860#include "netinet/in.h"
    59 #include "arduino.h"
     61#include "netinet/in_var.h"
     62#include "httpd.h"
     63#include "httpd-fs.h"
     64#include "http-strings.h"
     65#include "base64.h"
     66#include "sha1.h"
     67#include "ntstdio.h"
    6068
    6169#define TRUE 1
    6270#define FALSE 0
     71
     72extern ntstdio_t ntstdio;
     73SYSTIM httpd_time;
     74struct httpd_state *uploding;
     75extern char command[256];
     76
     77extern int execute_command(int wait);
     78
     79/*  TCP 送受信ウィンドバッファ  */
     80uint8_t tcp_swbuf1[TCP_SWBUF_SIZE];
     81uint8_t tcp_rwbuf1[TCP_RWBUF_SIZE];
     82uint8_t tcp_swbuf2[TCP_SWBUF_SIZE];
     83uint8_t tcp_rwbuf2[TCP_RWBUF_SIZE];
     84
     85#define ISO_nl      0x0a
     86#define ISO_space   0x20
     87#define ISO_bang    0x21
     88#define ISO_percent 0x25
     89#define ISO_period  0x2e
     90#define ISO_slash   0x2f
     91#define ISO_colon   0x3a
     92
     93struct httpd_state httpd_state[2] = {
     94        { HTTPD1_TASK, TCP_CEPID1 },
     95        { HTTPD2_TASK, TCP_CEPID2 },
     96};
    6397
    6498#ifndef _MSC_VER
    … …  
    147181        return ncpy;
    148182}
    149 
    150 extern struct httpd_state *uploding;
    151183
    152184int websvr_message_begin(http_parser *p)
    … …  
    306338ˆã¯SDカード
    307339                        s->filename[0] = '1';
    308                         syslog(LOG_NOTICE, "create:    %s.%d %s", s->addr, ((T_IPV4EP *)s->dst)->portno, s->filename);
     340                        ntstdio_printf(&ntstdio, "create:    %s.%d %s\n", s->addr, ((T_IPV4EP *)s->dst)->portno, s->filename);
    309341                        if (!httpd_fs_create(s->filename, &s->file)) {
    310342                                goto error;
    … …  
    314346                }
    315347                else if (strcmp(s->filename, uploding->filename) == 0) {
    316                         syslog(LOG_NOTICE, "collision: %s.%d %s", s->addr, ((T_IPV4EP *)s->dst)->portno, s->filename);
     348                        ntstdio_printf(&ntstdio, "collision: %s.%d %s\n", s->addr, ((T_IPV4EP *)s->dst)->portno, s->filename);
    317349                        goto error;
    318350                }
    … …  
    359391
    360392        if (s->message.body_is_final) {
    361                 syslog(LOG_NOTICE, "close:     %s.%d %s", s->addr, ((T_IPV4EP *)s->dst)->portno, s->filename);
     393                ntstdio_printf(&ntstdio, "close:     %s.%d %s\n", s->addr, ((T_IPV4EP *)s->dst)->portno, s->filename);
    362394                httpd_fs_close(&s->file);
    363395                memset(&s->file, 0, sizeof(s->file));
    364396
    365                 strcpy_s(RubyFilename, sizeof(RubyFilename), s->filename);
     397                strcpy_s(command, sizeof(command), "mruby -b ");
     398                strcat_s(command, sizeof(command), s->filename);
    366399                s->reset = 1;
    367400
    … …  
    413446        websvr_message_complete,
    414447};
     448
     449/*
     450 *  ネットワーク層の選択
     451 */
     452
     453#ifdef SUPPORT_INET6
     454
     455#define TCP_ACP_CEP(c,r,d,t)    tcp6_acp_cep(c,r,d,t)
     456#define IP2STR(s,a)             ipv62str(s,a)
     457
     458#else   /* of #ifdef SUPPORT_INET6 */
     459
     460#ifdef SUPPORT_INET4
     461
     462#define TCP_ACP_CEP(c,r,d,t)    tcp_acp_cep(c,r,d,t)
     463#define IP2STR(s,a)             ip2str(s,a)
     464
     465#endif  /* of #ifdef SUPPORT_INET4 */
     466
     467#endif  /* of #ifdef SUPPORT_INET6 */
     468
     469struct httpd_state *get_httpd(ID cepid)
     470{
     471        for (int i = 0; i < 2; i++) {
     472                if (httpd_state[i].cepid != cepid)
     473                        continue;
     474
     475                return &httpd_state[i];
     476        }
     477        return NULL;
     478}
     479
     480struct websocket *websocket_getws(ID wbsid)
     481{
     482        for (int i = 0; i < 2; i++) {
     483                if (httpd_state[i].websocket.wbsid != wbsid)
     484                        continue;
     485
     486                return &httpd_state[i].websocket;
     487        }
     488        return NULL;
     489}
     490
     491void send_file(struct httpd_state *s)
     492{
     493        char *buf;
     494        int len, slen;
     495
     496        while (s->file.len > 0) {
     497                slen = tcp_get_buf(s->cepid, (void **)&buf, TMO_FEVR);
     498                if (slen < 0) {
     499                        syslog(LOG_ERROR, "send_file#tcp_get_buf(%s.%d) => %d", s->addr, ((T_IPV4EP *)s->dst)->portno, slen);
     500                        s->state = STATE_CLOSING;
     501                        break;
     502                }
     503                if (slen == 0)
     504                        return;
     505
     506                len = s->file.len;
     507                if (len > slen)
     508                        len = slen;
     509
     510                len = httpd_fs_read(&s->file, buf, len);
     511                if (len <= 0) {
     512                        syslog(LOG_ERROR, "send_file#httpd_fs_read(%s.%d) => %d", s->addr, ((T_IPV4EP *)s->dst)->portno, len);
     513                        break;
     514                }
     515
     516                s->file.len -= len;
     517                s->file.pos += len;
     518
     519                if ((slen = tcp_snd_buf(s->cepid, len)) != E_OK) {
     520                        syslog(LOG_ERROR, "send_file#tcp_snd_buf(%s.%d) => %d", s->addr, ((T_IPV4EP *)s->dst)->portno, slen);
     521                        s->state = STATE_CLOSING;
     522                        break;
     523                }
     524        }
     525
     526        ntstdio_printf(&ntstdio, "close:     %s.%d %s\n", s->addr, ((T_IPV4EP *)s->dst)->portno, s->filename);
     527        httpd_fs_close(&s->file);
     528        s->file.len = 0;
     529        s->file.pos = 0;
     530
     531        s->out.state = OUT_STATE_SEND_END;
     532}
     533
     534void send_data(struct httpd_state *s)
     535{
     536        char *buf;
     537        int len, slen;
     538
     539        while (s->response_len > 0) {
     540                slen = tcp_get_buf(s->cepid, (void **)&buf, TMO_FEVR);
     541                if (slen < 0) {
     542                        syslog(LOG_ERROR, "send_data#tcp_get_buf(%s.%d) => %d", s->addr, ((T_IPV4EP *)s->dst)->portno, slen);
     543                        s->state = STATE_CLOSING;
     544                        break;
     545                }
     546                if (slen == 0)
     547                        return;
     548
     549                len = s->response_len;
     550                if (len > slen)
     551                        len = slen;
     552
     553                memcpy(buf, &s->response_body[s->response_pos], len);
     554
     555                s->response_len -= len;
     556                s->response_pos += len;
     557
     558                if ((slen = tcp_snd_buf(s->cepid, len)) != E_OK) {
     559                        syslog(LOG_ERROR, "send_data#tcp_snd_buf(%s.%d) => %d", s->addr, ((T_IPV4EP *)s->dst)->portno, slen);
     560                        s->state = STATE_CLOSING;
     561                        break;
     562                }
     563        }
     564
     565        s->response_body = NULL;
     566        s->response_len = 0;
     567        s->response_pos = 0;
     568
     569        s->out.state = OUT_STATE_SEND_END;
     570}
     571
     572void send_headers(struct httpd_state *s, const char *statushdr)
     573{
     574        int len;
     575        char *ptr;
     576
     577        len = strlen(statushdr);
     578        tcp_snd_dat(s->cepid, (void *)statushdr, len, TMO_FEVR);
     579
     580        if ((s->filename[0] == '0') && (s->file.len > 0)) {
     581                len = sizeof(http_content_encoding_gzip) - 1;
     582                tcp_snd_dat(s->cepid, (void *)http_content_encoding_gzip, len, TMO_FEVR);
     583        }
     584
     585        if (s->file.redirect) {
     586                len = sizeof(http_location) - 1;
     587                tcp_snd_dat(s->cepid, (void *)http_location, len, TMO_FEVR);
     588                if (s->filename[0] == '1') {
     589                        len = 2;
     590                        tcp_snd_dat(s->cepid, "/~", len, TMO_FEVR);
     591                }
     592                len = strlen(s->filename);
     593                tcp_snd_dat(s->cepid, s->filename, len, TMO_FEVR);
     594                if (s->query != NULL) {
     595                        tcp_snd_dat(s->cepid, "?", 1, TMO_FEVR);
     596                        len = strlen(s->query);
     597                        tcp_snd_dat(s->cepid, s->query, len, TMO_FEVR);
     598                }
     599                len = 2;
     600                tcp_snd_dat(s->cepid, "\r", len, TMO_FEVR);
     601        }
     602
     603        ptr = strrchr(s->filename, ISO_period);
     604        if (ptr == NULL) {
     605                len = sizeof(http_content_type_binary) - 1;
     606                tcp_snd_dat(s->cepid, (void *)http_content_type_binary, len, TMO_FEVR);
     607        }
     608        else if (strncmp(http_html, ptr, sizeof(http_html) - 1) == 0 ||
     609                strncmp(http_htm, ptr, sizeof(http_htm) - 1) == 0) {
     610                len = sizeof(http_content_type_html) - 1;
     611                tcp_snd_dat(s->cepid, (void *)http_content_type_html, len, TMO_FEVR);
     612        }
     613        else if (strncmp(http_css, ptr, sizeof(http_css) - 1) == 0) {
     614                len = sizeof(http_content_type_css) - 1;
     615                tcp_snd_dat(s->cepid, (void *)http_content_type_css, len, TMO_FEVR);
     616        }
     617        else if (strncmp(http_js, ptr, sizeof(http_js) - 1) == 0) {
     618                len = sizeof(http_content_type_js) - 1;
     619                tcp_snd_dat(s->cepid, (void *)http_content_type_js, len, TMO_FEVR);
     620        }
     621        else if (strncmp(http_json, ptr, sizeof(http_json) - 1) == 0) {
     622                len = sizeof(http_content_type_json) - 1;
     623                tcp_snd_dat(s->cepid, (void *)http_content_type_json, len, TMO_FEVR);
     624        }
     625        else if (strncmp(http_png, ptr, sizeof(http_png) - 1) == 0) {
     626                len = sizeof(http_content_type_png) - 1;
     627                tcp_snd_dat(s->cepid, (void *)http_content_type_png, len, TMO_FEVR);
     628        }
     629        else if (strncmp(http_gif, ptr, sizeof(http_gif) - 1) == 0) {
     630                len = sizeof(http_content_type_gif) - 1;
     631                tcp_snd_dat(s->cepid, (void *)http_content_type_gif, len, TMO_FEVR);
     632        }
     633        else if (strncmp(http_jpg, ptr, sizeof(http_jpg) - 1) == 0) {
     634                len = sizeof(http_content_type_jpg) - 1;
     635                tcp_snd_dat(s->cepid, (void *)http_content_type_jpg, len, TMO_FEVR);
     636        }
     637        else if (strncmp(http_svg, ptr, sizeof(http_svg) - 1) == 0) {
     638                len = sizeof(http_content_type_svg) - 1;
     639                tcp_snd_dat(s->cepid, (void *)http_content_type_svg, len, TMO_FEVR);
     640        }
     641        else if (strncmp(http_text, ptr, sizeof(http_text) - 1) == 0) {
     642                len = sizeof(http_content_type_text) - 1;
     643                tcp_snd_dat(s->cepid, (void *)http_content_type_text, len, TMO_FEVR);
     644        }
     645        else if (strncmp(http_eot, ptr, sizeof(http_eot) - 1) == 0) {
     646                len = sizeof(http_content_type_eot) - 1;
     647                tcp_snd_dat(s->cepid, (void *)http_content_type_eot, len, TMO_FEVR);
     648        }
     649        else if (strncmp(http_ttf, ptr, sizeof(http_ttf) - 1) == 0) {
     650                len = sizeof(http_content_type_ttf) - 1;
     651                tcp_snd_dat(s->cepid, (void *)http_content_type_ttf, len, TMO_FEVR);
     652        }
     653        else if (strncmp(http_woff, ptr, sizeof(http_woff) - 1) == 0) {
     654                len = sizeof(http_content_type_woff) - 1;
     655                tcp_snd_dat(s->cepid, (void *)http_content_type_woff, len, TMO_FEVR);
     656        }
     657        else if (strncmp(http_woff2, ptr, sizeof(http_woff2) - 1) == 0) {
     658                len = sizeof(http_content_type_woff2) - 1;
     659                tcp_snd_dat(s->cepid, (void *)http_content_type_woff2, len, TMO_FEVR);
     660        }
     661        else if (strncmp(http_ico, ptr, sizeof(http_ico) - 1) == 0) {
     662                len = sizeof(http_content_type_ico) - 1;
     663                tcp_snd_dat(s->cepid, (void *)http_content_type_ico, len, TMO_FEVR);
     664        }
     665        else {
     666                len = sizeof(http_content_type_plain) - 1;
     667                tcp_snd_dat(s->cepid, (void *)http_content_type_plain, len, TMO_FEVR);
     668        }
     669
     670        if (s->file.len > 0) {
     671                len = sizeof(http_content_length) - 1;
     672                tcp_snd_dat(s->cepid, (void *)http_content_length, len, TMO_FEVR);
     673                ntstdio_snprintf(s->temp, sizeof(s->temp), "%d\r\n", s->file.len);
     674                tcp_snd_dat(s->cepid, (void *)s->temp, strlen(s->temp), TMO_FEVR);
     675        }
     676
     677        if (s->message.should_keep_alive && s->reset == 0) {
     678                len = sizeof(http_connection_keep_alive) - 1;
     679                tcp_snd_dat(s->cepid, (void *)http_connection_keep_alive, len, TMO_FEVR);
     680        }
     681        else {
     682                len = sizeof(http_connection_close) - 1;
     683                tcp_snd_dat(s->cepid, (void *)http_connection_close, len, TMO_FEVR);
     684        }
     685
     686        tcp_snd_dat(s->cepid, (void *)http_crnl, 2, TMO_FEVR);
     687
     688        if (s->filename != NULL) {
     689                s->out.state = OUT_STATE_SEND_FILE;
     690        }
     691        else {
     692                s->out.state = OUT_STATE_SEND_DATA;
     693        }
     694}
     695
     696void handle_output(struct httpd_state *s)
     697{
     698        s->out.wait = false;
     699
     700        switch (s->out.state) {
     701        case OUT_STATE_WAIT_REQUEST:
     702                s->out.wait = true;
     703                break;
     704        case OUT_STATE_OPEN_GET_FILE:
     705                ntstdio_printf(&ntstdio, "open:      %s.%d %s\n", s->addr, ((T_IPV4EP *)s->dst)->portno, s->filename);
     706                if (!httpd_fs_open(s->filename, sizeof(s->message.request_url), &s->file)) {
     707                        s->filename = NULL;
     708                        s->response_body = http_content_404;
     709                        s->response_pos = 0;
     710                        s->response_len = sizeof(http_content_403) - 1;
     711                        s->out.statushdr = http_header_404;
     712                }
     713                else {
     714                        s->out.statushdr = s->file.redirect ? http_header_301 : http_header_200;
     715                }
     716                s->out.state = OUT_STATE_SEND_HEADER;
     717                break;
     718        case OUT_STATE_WAIT_POST_BODY:
     719                s->out.wait = true;
     720                break;
     721        case OUT_STATE_BODY_RECEIVED:
     722                s->out.statushdr = http_header_200;
     723                s->out.state = OUT_STATE_SEND_HEADER;
     724                break;
     725        case OUT_STATE_SEND_HEADER:
     726                send_headers(s, s->out.statushdr);
     727                break;
     728        case OUT_STATE_SEND_FILE:
     729                send_file(s);
     730                break;
     731        case OUT_STATE_SEND_DATA:
     732                send_data(s);
     733                break;
     734        case OUT_STATE_SEND_END:
     735                s->out.wait = true;
     736                if (s->message.should_keep_alive && s->reset == 0) {
     737                        s->out.state = OUT_STATE_WAIT_REQUEST;
     738                }
     739                else {
     740                        s->state = STATE_CLOSING;
     741                }
     742                break;
     743        }
     744}
     745
     746void send_ws_headers(struct httpd_state *s, const char *statushdr)
     747{
     748        int len;
     749
     750        len = strlen(statushdr);
     751        tcp_snd_dat(s->cepid, (void *)statushdr, len, TMO_FEVR);
     752
     753        len = sizeof(http_upgrade) - 1;
     754        tcp_snd_dat(s->cepid, (void *)http_upgrade, len, TMO_FEVR);
     755        len = strlen(s->message.upgrade);
     756        tcp_snd_dat(s->cepid, s->message.upgrade, len, TMO_FEVR);
     757        len = sizeof(http_crnl) - 1;
     758        tcp_snd_dat(s->cepid, (void *)http_crnl, len, TMO_FEVR);
     759
     760        len = sizeof(http_connection) - 1;
     761        tcp_snd_dat(s->cepid, (void *)http_connection, len, TMO_FEVR);
     762        len = strlen(s->message.connection);
     763        tcp_snd_dat(s->cepid, s->message.connection, len, TMO_FEVR);
     764        len = sizeof(http_crnl) - 1;
     765        tcp_snd_dat(s->cepid, (void *)http_crnl, len, TMO_FEVR);
     766
     767        len = sizeof(http_sec_websocket_accept) - 1;
     768        tcp_snd_dat(s->cepid, (void *)http_sec_websocket_accept, len, TMO_FEVR);
     769        len = strlen(s->message.response_key);
     770        tcp_snd_dat(s->cepid, s->message.response_key, len, TMO_FEVR);
     771        len = sizeof(http_crnl) - 1;
     772        tcp_snd_dat(s->cepid, (void *)http_crnl, len, TMO_FEVR);
     773
     774        len = sizeof(http_sec_websocket_protocol) - 1;
     775        tcp_snd_dat(s->cepid, (void *)http_sec_websocket_protocol, len, TMO_FEVR);
     776        len = strlen(s->message.sec_websocket_protocol);
     777        tcp_snd_dat(s->cepid, s->message.sec_websocket_protocol, len, TMO_FEVR);
     778        len = sizeof(http_crnl) - 1;
     779        tcp_snd_dat(s->cepid, (void *)http_crnl, len, TMO_FEVR);
     780
     781        len = sizeof(http_crnl) - 1;
     782        tcp_snd_dat(s->cepid, (void *)http_crnl, len, TMO_FEVR);
     783}
     784
     785void send_ws_data(struct httpd_state *s)
     786{
     787        char *buf;
     788        int slen;
     789
     790        slen = tcp_get_buf(s->cepid, (void **)&buf, TMO_FEVR);
     791        if (slen < 0) {
     792                syslog(LOG_ERROR, "send_ws_data#tcp_get_buf(%s.%d) => %d", s->addr, ((T_IPV4EP *)s->dst)->portno, slen);
     793                return;
     794        }
     795
     796        websocket_output(&s->websocket, buf, slen);
     797}
     798
     799void handle_ws_output(struct httpd_state *s)
     800{
     801        char shaHash[20];
     802        SHA_CTX sha1;
     803        int len;
     804
     805        strlncat(s->message.response_key, sizeof(s->message.response_key),
     806                s->message.sec_websocket_key, sizeof(s->message.sec_websocket_key));
     807        len = strlncat(s->message.response_key, sizeof(s->message.response_key),
     808                http_websocket_guid, sizeof(http_websocket_guid));
     809        memset(shaHash, 0, sizeof(shaHash));
     810        SHA1_Init(&sha1);
     811        SHA1_Update(&sha1, (sha1_byte *)s->message.response_key, len);
     812        SHA1_Final((sha1_byte *)shaHash, &sha1);
     813        base64_encode((unsigned char *)s->message.response_key,
     814                sizeof(s->message.response_key), (unsigned char *)shaHash, sizeof(shaHash));
     815
     816        send_ws_headers(s, http_header_101);
     817
     818        s->message.response_key[0] = '\0';
     819
     820        do {
     821                while (!websocket_newdata(&s->websocket))
     822                        slp_tsk();
     823
     824                send_ws_data(s);
     825        } while ((s->state == STATE_CONNECTED) && (!s->close_req));
     826        s->state = STATE_DISCONNECTED;
     827        websocket_destroy(&s->websocket);
     828        s->close_req = 0;
     829
     830        s->state = STATE_CLOSING;
     831}
     832
     833void handle_input(struct httpd_state *s)
     834{
     835        size_t done;
     836        int len;
     837
     838        s->in.wait = false;
     839
     840        switch (s->in.state) {
     841        case IN_STATE_START:
     842                http_parser_init(&s->parser, HTTP_REQUEST);
     843                s->in.state = IN_STATE_REQUEST;
     844                break;
     845        case IN_STATE_REQUEST:
     846        case IN_STATE_RESPONSE:
     847        case IN_STATE_UPLOAD:
     848                if ((len = tcp_rcv_buf(s->cepid, (void **)&s->in.data, TMO_POL)) <= 0) {
     849                        if ((len == E_TMOUT) || (len == 0)) {
     850                                // 3秒はå¾
     851つ
     852                                //if (httpd_time - s->in.timer < 30000000) {
     853                                        s->in.wait = true;
     854                                        break;
     855                                //}
     856                        }
     857                        syslog(LOG_ERROR, "handle_input#tcp_rcv_buf#%d(%s.%d) => %d", s->in.state, s->addr, ((T_IPV4EP *)s->dst)->portno, len);
     858                        uploding = NULL;
     859                        s->state = STATE_CLOSING;
     860                        return;
     861                }
     862                done = http_parser_execute(&s->parser, &websvr_settings, s->in.data, len);
     863                tcp_rel_buf(s->cepid, done);
     864                if (s->parser.http_errno != HPE_OK) {
     865                        syslog(LOG_ERROR, "http_parser error %s.%d => %d", s->addr, ((T_IPV4EP *)s->dst)->portno, s->parser.http_errno);
     866                        uploding = NULL;
     867                        s->state = STATE_CLOSING;
     868                        return;
     869                }
     870
     871                s->parse_pos = done;
     872                s->parse_len = len - done;
     873                break;
     874        case IN_STATE_UPLOAD_WAIT:
     875                if (uploding != NULL) {
     876                        s->in.wait = true;
     877                }
     878                else {
     879                        uploding = s;
     880                        s->in.state = IN_STATE_UPLOAD;
     881                }
     882                break;
     883        case IN_STATE_WEBSOCKET:
     884                if (s->parse_len <= 0) {
     885                        if ((len = tcp_rcv_buf(s->cepid, (void **)&s->in.data, TMO_POL)) <= 0) {
     886                                if ((len == E_TMOUT) || (len == 0)) {
     887                                        s->in.wait = true;
     888                                        break;
     889                                }
     890                                syslog(LOG_ERROR, "handle_input#tcp_rcv_buf#%d(%s.%d) => %d", s->in.state, s->addr, ((T_IPV4EP *)s->dst)->portno, len);
     891                                s->state = STATE_CLOSING;
     892                                break;
     893                        }
     894
     895                        s->parse_pos = 0;
     896                        s->parse_len = len;
     897                }
     898                else
     899                        len = s->parse_len;
     900                done = websocket_input(&s->websocket, (void *)s->in.data, s->parse_len);
     901                tcp_rel_buf(s->cepid, done);
     902                if ((done != 0) || (s->websocket.rstate.opecode == connection_close)) {
     903                        s->close_req = 1;
     904                        s->state = STATE_CLOSING;
     905                        break;
     906                }
     907                s->parse_pos = done;
     908                s->parse_len -= done;
     909                break;
     910        case IN_STATE_END:
     911                s->in.wait = true;
     912                break;
     913        default:
     914                s->state = STATE_CLOSING;
     915                break;
     916        }
     917}
     918
     919/*
     920 *  ノンブロッキングコールのコールバック関数
     921 */
     922ER
     923callback_nblk_tcp(ID cepid, FN fncd, void *p_parblk)
     924{
     925        struct httpd_state *s = get_httpd(cepid);
     926
     927        if (s == NULL)
     928                ntstdio_printf(&ntstdio, "callback_nblk_tcp(%d, %d)\n", fncd, cepid);
     929        else
     930                ntstdio_printf(&ntstdio, "callback_nblk_tcp(%d, %s.%d)\n", fncd, s->addr, ((T_IPV4EP *)s->dst)->portno);
     931
     932        return E_PAR;
     933}
     934
     935/*
     936 * HTTPサーバータスク
     937 */
     938void httpd_task(intptr_t exinf)
     939{
     940        ER ret, ret2;
     941        struct httpd_state *s = &httpd_state[exinf];
     942
     943        for (;;) {
     944                ret2 = get_tim(&httpd_time);
     945                if (ret2 != E_OK) {
     946                        syslog(LOG_ERROR, "get_tim");
     947                        return;
     948                }
     949
     950                switch (s->state) {
     951                case STATE_DISCONNECTED:
     952                        memset(&s->dst, 0, sizeof(s->dst));
     953                        if ((ret = TCP_ACP_CEP(s->cepid, TCP_REPID, (T_IPV4EP *)s->dst, TMO_FEVR)) != E_OK) {
     954                                syslog(LOG_ERROR, "tcp_acp_cep(%d) => %d", s->cepid, ret);
     955                                tslp_tsk(100);  // TODO
     956                                s->state = STATE_CLOSING;
     957                                break;
     958                        }
     959                        IP2STR(s->addr, &((T_IPV4EP *)s->dst)->ipaddr);
     960                        ntstdio_printf(&ntstdio, "connected: %s.%d\n", s->addr, ((T_IPV4EP *)s->dst)->portno);
     961                        memset(&s->in, 0, sizeof(s->in));
     962                        memset(&s->out, 0, sizeof(s->out));
     963                        s->in.timer = httpd_time;
     964                        s->state = STATE_CONNECTED;
     965                        break;
     966                case STATE_CONNECTED:
     967                        handle_input(s);
     968                        handle_output(s);
     969                        break;
     970                case STATE_WEBSOCKET:
     971                        handle_input(s);
     972                        handle_ws_output(s);
     973                        break;
     974                case STATE_CLOSING:
     975                        ntstdio_printf(&ntstdio, "close:     %s.%d\n", s->addr, ((T_IPV4EP *)s->dst)->portno);
     976                        tcp_sht_cep(s->cepid);
     977                        tcp_cls_cep(s->cepid, TMO_FEVR);
     978
     979                        if (s->reset) {
     980                                s->reset = 0;
     981                                s->state = STATE_RESET;
     982                        }
     983                        else {
     984                                s->state = STATE_DISCONNECTED;
     985                        }
     986                        break;
     987                case STATE_RESET:
     988                        execute_command(0);
     989                        s->state = STATE_DISCONNECTED;
     990                        break;
     991                }
     992
     993                if (s->in.wait && s->out.wait) {
     994                        tslp_tsk(100);
     995                }
     996        }
     997}

  • EcnlProtoTool/trunk/ntshell/webserver/httpd.h

    r270 r279  
    44 *  Copyright (C) 2017 Cores Co., Ltd. Japan
    55 *
    6  *  ã‹L’˜ìŒ ŽÒ‚́CˆÈ‰º‚Ì(1)`(4)‚ÌðŒ‚ð–ž‚½‚·ê‡‚ÉŒÀ‚èC–{ƒ\ƒtƒgƒEƒF
    7  *  ƒAi–{ƒ\ƒtƒgƒEƒFƒA‚ð‰ü•Ï‚µ‚½‚à‚Ì‚ðŠÜ‚ށDˆÈ‰º“¯‚¶j‚ðŽg—pE•¡»E‰ü
    8  *  •ÏEÄ”z•ziˆÈ‰ºC—˜—p‚ƌĂԁj‚·‚邱‚Ƃ𖳏ž‚Å‹–‘ø‚·‚éD
    9  *  (1) –{ƒ\ƒtƒgƒEƒFƒA‚ðƒ\[ƒXƒR[ƒh‚ÌŒ`‚Å—˜—p‚·‚éê‡‚ɂ́Cã‹L‚Ì’˜ì
    10  *      Œ •\Ž¦C‚±‚Ì—˜—pðŒ‚¨‚æ‚щº‹L‚Ì–³•ÛØ‹K’肪C‚»‚Ì‚Ü‚Ü‚ÌŒ`‚Ń\[
    11  *      ƒXƒR[ƒh’†‚ÉŠÜ‚Ü‚ê‚Ä‚¢‚邱‚ƁD
    12  *  (2) –{ƒ\ƒtƒgƒEƒFƒA‚ðCƒ‰ƒCƒuƒ‰ƒŠŒ`Ž®‚ȂǁC‘¼‚̃\ƒtƒgƒEƒFƒAŠJ”­‚ÉŽg
    13  *      —p‚Å‚«‚éŒ`‚ōĔz•z‚·‚éê‡‚ɂ́CÄ”z•z‚É”º‚¤ƒhƒLƒ
    14 ƒƒ“ƒgi—˜—p
    15  *      ŽÒƒ}ƒjƒ
    16 ƒAƒ‹‚Ȃǁj‚ɁCã‹L‚Ì’˜ìŒ •\Ž¦C‚±‚Ì—˜—pðŒ‚¨‚æ‚щº‹L
    17  *      ‚Ì–³•ÛØ‹K’è‚ðŒfÚ‚·‚邱‚ƁD
    18  *  (3) –{ƒ\ƒtƒgƒEƒFƒA‚ðC‹@Ší‚É‘g‚ݍž‚ނȂǁC‘¼‚̃\ƒtƒgƒEƒFƒAŠJ”­‚ÉŽg
    19  *      —p‚Å‚«‚È‚¢Œ`‚ōĔz•z‚·‚éê‡‚ɂ́CŽŸ‚Ì‚¢‚¸‚ê‚©‚ÌðŒ‚ð–ž‚½‚·‚±
    20  *      ‚ƁD
    21  *    (a) Ä”z•z‚É”º‚¤ƒhƒLƒ
    22 ƒƒ“ƒgi—˜—pŽÒƒ}ƒjƒ
    23 ƒAƒ‹‚Ȃǁj‚ɁCã‹L‚Ì’˜
    24  *        ìŒ •\Ž¦C‚±‚Ì—˜—pðŒ‚¨‚æ‚щº‹L‚Ì–³•ÛØ‹K’è‚ðŒfÚ‚·‚邱‚ƁD
    25  *    (b) Ä”z•z‚ÌŒ`‘Ô‚ðC•Ê‚É’è‚ß‚é•û–@‚É‚æ‚Á‚āCTOPPERSƒvƒƒWƒFƒNƒg‚É
    26  *        •ñ‚·‚邱‚ƁD
    27  *  (4) –{ƒ\ƒtƒgƒEƒFƒA‚Ì—˜—p‚É‚æ‚è’¼Ú“I‚Ü‚½‚͊ԐړI‚ɐ¶‚¶‚é‚¢‚©‚Ȃ鑹
    28  *      ŠQ‚©‚ç‚àCã‹L’˜ìŒ ŽÒ‚¨‚æ‚ÑTOPPERSƒvƒƒWƒFƒNƒg‚ð–Ɛӂ·‚邱‚ƁD
    29  *      ‚Ü‚½C–{ƒ\ƒtƒgƒEƒFƒA‚̃†[ƒU‚Ü‚½‚̓Gƒ“ƒhƒ†[ƒU‚©‚ç‚Ì‚¢‚©‚Ȃ闝
    30  *      —R‚ÉŠî‚­¿‹‚©‚ç‚àCã‹L’˜ìŒ ŽÒ‚¨‚æ‚ÑTOPPERSƒvƒƒWƒFƒNƒg‚ð
    31  *      –Ɛӂ·‚邱‚ƁD
    32  *
    33  *  –{ƒ\ƒtƒgƒEƒFƒA‚́C–³•ÛØ‚Å’ñ‹Ÿ‚³‚ê‚Ä‚¢‚é‚à‚Ì‚Å‚ ‚éDã‹L’˜ìŒ ŽÒ‚¨
    34  *  ‚æ‚ÑTOPPERSƒvƒƒWƒFƒNƒg‚́C–{ƒ\ƒtƒgƒEƒFƒA‚ÉŠÖ‚µ‚āC“Á’è‚ÌŽg—p–Ú“I
    35  *  ‚ɑ΂·‚é“K‡«‚àŠÜ‚߂āC‚¢‚©‚È‚é•ÛØ‚às‚í‚È‚¢D‚Ü‚½C–{ƒ\ƒtƒgƒEƒF
    36  *  ƒA‚Ì—˜—p‚É‚æ‚è’¼Ú“I‚Ü‚½‚͊ԐړI‚ɐ¶‚¶‚½‚¢‚©‚Ȃ鑹ŠQ‚ÉŠÖ‚µ‚Ä‚àC‚»
    37  *  ‚̐ӔC‚𕉂í‚È‚¢D
     6 *  上記著作権è€
     7は，以下の(1)～(4)の条件を満たす場合に限り，本ソフトウェ
     8 *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
     9 *  変・再é
     10å¸ƒï¼ˆä»¥ä¸‹ï¼Œåˆ©ç”¨ã¨å‘¼ã¶ï¼‰ã™ã‚‹ã“とを無償で許諾する．
     11 *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
     12 *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
     13 *      スコード中に含まれていること．
     14 *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
     15 *      用できる形で再é
     16å¸ƒã™ã‚‹å ´åˆã«ã¯ï¼Œå†é
     17å¸ƒã«ä¼´ã†ãƒ‰ã‚­ãƒ¥ãƒ¡ãƒ³ãƒˆï¼ˆåˆ©ç”¨
     18 *      è€
     19マニュアルなど）に，上記の著作権表示，この利用条件および下記
     20 *      の無保証規定を掲載すること．
     21 *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
     22 *      用できない形で再é
     23å¸ƒã™ã‚‹å ´åˆã«ã¯ï¼Œæ¬¡ã®ã„ずれかの条件を満たすこ
     24 *      と．
     25 *    (a) 再é
     26å¸ƒã«ä¼´ã†ãƒ‰ã‚­ãƒ¥ãƒ¡ãƒ³ãƒˆï¼ˆåˆ©ç”¨è€
     27マニュアルなど）に，上記の著
     28 *        作権表示，この利用条件および下記の無保証規定を掲載すること．
     29 *    (b) 再é
     30å¸ƒã®å½¢æ
     31‹ã‚’，別に定める方法によって，TOPPERSプロジェクトに
     32 *        報告すること．
     33 *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
     34 *      害からも，上記著作権è€
     35およびTOPPERSプロジェクトをå
     36è²¬ã™ã‚‹ã“と．
     37 *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
     38 *      由に基づく請求からも，上記著作権è€
     39およびTOPPERSプロジェクトを
     40 *      å
     41è²¬ã™ã‚‹ã“と．
     42 *
     43 *  本ソフトウェアは，無保証で提供されているものである．上記著作権è€
     44お
     45 *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
     46 *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
     47 *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
     48 *  の責任を負わない．
    3849 *
    3950 *  @(#) $Id$
    … …  
    4354#define __HTTPD_H__
    4455
     56/*
     57 *  ターゲット依存の定義
     58 */
     59#include <kernel.h>
    4560#include "httpd-fs.h"
    4661#include "http_parser.h"
    4762#include "websocket.h"
     63
     64/*
     65 *  各タスクの優å
     66ˆåº¦ã®å®šç¾©
     67 */
     68
     69#define HTTPD_PRIORITY  5               /* HTTPサーバータスクの優å
     70ˆåº¦ */
     71
     72#define HTTPD_STACK_SIZE                1024    /* HTTPサーバータスクのスタック領域のサイズ */
     73
     74 /*  TCP 送受信ウィンドバッファサイズ  */
     75
     76#define TCP_SWBUF_SIZE  512
     77#define TCP_RWBUF_SIZE  512
     78
     79/*
     80 *  関数のプロトタイプ宣言
     81 */
     82#ifndef TOPPERS_MACRO_ONLY
     83
     84 /*  TCP 送受信ウィンドバッファ  */
     85
     86extern uint8_t tcp_swbuf1[];
     87extern uint8_t tcp_rwbuf1[];
     88extern uint8_t tcp_swbuf2[];
     89extern uint8_t tcp_rwbuf2[];
     90
     91/* HTTPサーバータスク */
     92extern void httpd_task(intptr_t exinf);
    4893
    4994#define MAX_ELEMENT_SIZE 256
    … …  
    81126
    82127typedef enum httpd_state_t {
    83         STATE_DISCONNECTED,             /* Ø’f’† */
    84         STATE_CONNECTED,                /* Ú‘±’† */
    85         STATE_WEBSOCKET,                /* WebSocket’ʐM’† */
    86         STATE_CLOSING,                  /* Ø’fˆ—’† */
    87         STATE_RESET,                    /* mruby‹N“®‚Ì‚½‚߂̃ŠƒZƒbƒg */
     128        STATE_DISCONNECTED,             /* 切断中 */
     129        STATE_CONNECTED,                /* 接続中 */
     130        STATE_WEBSOCKET,                /* WebSocket通信中 */
     131        STATE_CLOSING,                  /* 切断処理中 */
     132        STATE_RESET,                    /* mruby起動のためのリセット */
    88133} httpd_state_t;
    89134
    … …  
    155200#define get_context(p) (struct httpd_state *)((intptr_t)p - (intptr_t)&((struct httpd_state *)0)->parser)
    156201
     202/*
     203 * ノンブロッキングコールのコールバック関数
     204 */
     205extern ER callback_nblk_tcp(ID cepid, FN fncd, void *p_parblk);
     206
     207#endif /* TOPPERS_MACRO_ONLY */
     208
    157209#endif /* __HTTPD_H__ */

  • EcnlProtoTool/trunk/ntshell/webserver/websocket.c

    r270 r279  
    5757#include "syssvc/syslog.h"
    5858
    59 static ECN_FBS_ID cur_out_msg;
     59static WS_FBS_ID cur_out_msg;
    6060
    6161void websocket_init(struct websocket *ws, ID wbsid)
    … …  
    6969        if ((cur_out_msg.ptr != NULL) && (((ID *)cur_out_msg.ptr->_gap)[0] == ws->wbsid))
    7070        {
    71                 _ecn_fbs_del(cur_out_msg);
     71                _ws_fbs_del(cur_out_msg);
    7272                memset(&cur_out_msg, 0, sizeof(cur_out_msg));
    7373        }
    7474
    7575        if (ws->cur_in_msg.ptr != NULL) {
    76                 _ecn_fbs_del(ws->cur_in_msg);
     76                _ws_fbs_del(ws->cur_in_msg);
    7777                memset(&ws->cur_in_msg, 0, sizeof(ws->cur_in_msg));
    7878        }
    … …  
    136136                        }
    137137                        else {
    138                                 _ecn_fbs_cre(1, &ws->cur_in_msg);
     138                                _ws_fbs_cre(1, &ws->cur_in_msg);
    139139                                s->state++;
    140140                        }
    … …  
    143143                default:
    144144                        if(ws->cur_in_msg.ptr != NULL)
    145                                 _ecn_fbs_poke(ws->cur_in_msg, s->data_pos, *pos ^ s->masking_key[s->data_pos % 4]);
     145                                _ws_fbs_poke(ws->cur_in_msg, s->data_pos, *pos ^ s->masking_key[s->data_pos % 4]);
    146146
    147147                        s->data_pos++;
    … …  
    152152                                if (ws->cur_in_msg.ptr != NULL) {
    153153                                        ((ID *)ws->cur_in_msg.ptr->_gap)[0] = ws->wbsid;
    154                                         ret = psnd_dtq(ecn_api_mailboxid, (intptr_t)ws->cur_in_msg.ptr);
     154                                        ret = psnd_dtq(ws_api_mailboxid, (intptr_t)ws->cur_in_msg.ptr);
    155155                                        if (ret != E_OK) {
    156                                                 syslog(LOG_WARNING, "websocket_input() : psnd_dtq(%d) result = %d", ecn_api_mailboxid, ret);
    157                                                 _ecn_fbs_del(ws->cur_in_msg);
     156                                                syslog(LOG_WARNING, "websocket_input() : psnd_dtq(%d) result = %d", ws_api_mailboxid, ret);
     157                                                _ws_fbs_del(ws->cur_in_msg);
    158158                                        }
    159159                                }
    … …  
    172172        struct websocket *mws;
    173173        ER ret;
    174         ECN_FBS_ID data;
     174        WS_FBS_ID data;
    175175        ID wbsid;
    176176
    … …  
    196196                        break;
    197197
    198                 _ecn_fbs_del(cur_out_msg);
     198                _ws_fbs_del(cur_out_msg);
    199199        }
    200200
    … …  
    217217                                return (intptr_t)pos - (intptr_t)data;
    218218
    219                         s->payload_len = _ecn_fbs_get_datalen(cur_out_msg);
     219                        s->payload_len = _ws_fbs_get_datalen(cur_out_msg);
    220220                        if(s->payload_len == 0){
    221221                                goto next;
    … …  
    281281                // Payload buffer
    282282                default:
    283                         *pos = _ecn_fbs_peek(cur_out_msg, s->data_pos) ^ s->masking_key[s->data_pos % 4];
     283                        *pos = _ws_fbs_peek(cur_out_msg, s->data_pos) ^ s->masking_key[s->data_pos % 4];
    284284
    285285                        s->data_pos++;
    … …  
    289289                        break;
    290290                next:
    291                         _ecn_fbs_del(cur_out_msg);
     291                        _ws_fbs_del(cur_out_msg);
    292292                        memset(&cur_out_msg, 0, sizeof(cur_out_msg));
    293293                        s->state = 0;

  • EcnlProtoTool/trunk/ntshell/webserver/websocket.h

    r270 r279  
    5858#include "t_stddef.h"
    5959
    60 #define NUM_ECHONET_MEMPOOL_BLOCK (60)          /* 電文用メモリブロックの数 */
    61 #define ECHONET_MEMPOOL_BLOCK_SIZE (256)        /* 電文用メモリブロックのサイズ */
     60#define NUM_WEBSOCKET_MBXID     2
    6261
    63 /* T_EDATA管理領域サイズ */
    64 #define DEF_ECN_EDT_HDR_LEN (sizeof(intptr_t))
     62#ifndef TOPPERS_MACRO_ONLY
     63#include "websocket_fbs.h"
    6564
    66 /* 管理領域サイズ(64byte - sizeof(T_MSG)) */
    67 /* #define DEF_ECN_FBS_LIB_HDR_LEN ((ECHONET_MEMPOOL_BLOCK_SIZE + sizeof(int) - 1)>> 2) // */
    68 #define DEF_ECN_FBS_LIB_HDR_LEN (64 - DEF_ECN_EDT_HDR_LEN)
    69 
    70 /* 管理領域を含むブロックに保持するデータサイズ */
    71 #define DEF_ECN_FBS_FST_DAT_LEN (64)
    72 
    73 /* リンクポインタé
    74 åˆ—のサイズ(byte) */
    75 #define DEF_ECN_FBS_LNK_LEN (ECHONET_MEMPOOL_BLOCK_SIZE - DEF_ECN_EDT_HDR_LEN - DEF_ECN_FBS_LIB_HDR_LEN - DEF_ECN_FBS_FST_DAT_LEN)
    76 
    77 /* 固定長バッファ最大サイズ */
    78 #define DEF_ECN_FBS_BUF_MAXLEN ((DEF_ECN_FBS_LNK_LEN / sizeof(void *)) * ECHONET_MEMPOOL_BLOCK_SIZE + DEF_ECN_FBS_FST_DAT_LEN)
    79 
    80 /* 子要素バッファのサイズ */
    81 #define DEF_ECN_FBS_SUB_BUF_LEN ECHONET_MEMPOOL_BLOCK_SIZE
    82 
    83 /* リンクポインタé
    84 åˆ—に列挙される、子要素バッファ */
    85 typedef struct {
    86         uint8_t payload[ECHONET_MEMPOOL_BLOCK_SIZE];
    87 } T_ECN_SUB_BLK;
    88 
    89 /* リンクポインタé
    90 åˆ— */
    91 typedef union {
    92         T_ECN_SUB_BLK   *p_sub[DEF_ECN_FBS_LNK_LEN / sizeof(T_ECN_SUB_BLK *)];
    93         uint8_t                 bin[DEF_ECN_FBS_LNK_LEN];
    94 } T_ECN_FBS_LNK;
    95 
    96 /* 管理領域(64byte - sizeof(T_MSG)) */
    97 typedef struct {
    98         uint16_t        length;                 /* メッセージ長 */
    99         uint16_t        type;                   /* メッセージタイプ */
    100         union {
    101                 ID mbxid;                               /* 送信å
    102 ƒãƒ¡ãƒ¼ãƒ«ãƒœãƒƒã‚¯ã‚¹ID（å†
    103 éƒ¨ãƒ¡ãƒƒã‚»ãƒ¼ã‚¸ï¼‰ */
    104         }sender;
    105         union {
    106                 ID mbxid;                               /* 送信å
    107 ˆãƒ¡ãƒ¼ãƒ«ãƒœãƒƒã‚¯ã‚¹ID（å†
    108 éƒ¨ãƒ¡ãƒƒã‚»ãƒ¼ã‚¸ï¼‰ */
    109         }target;
    110         union {
    111                 ID mbxid;                               /* 返信å
    112 ˆãƒ¡ãƒ¼ãƒ«ãƒœãƒƒã‚¯ã‚¹ID（å†
    113 éƒ¨ãƒ¡ãƒƒã‚»ãƒ¼ã‚¸ï¼‰ */
    114         }reply;
    115 
    116         int                     rd;                             /*      読み取りヘッドæƒ
    117 å ±     */
    118         int                     wr;                             /*      書き込みヘッドæƒ
    119 å ±     */
    120 } T_ECN_FBS_HDR;
    121 
    122 /* 管理領域を含むブロックの構造 */
    123 typedef struct {
    124         uint8_t _msg[DEF_ECN_EDT_HDR_LEN];      /* T_MSG */
    125         T_ECN_FBS_HDR   hdr;    /*      管理領域  64byte  - sizeof(T_MSG)   */
    126         uint8_t                 _gap[DEF_ECN_FBS_LIB_HDR_LEN - sizeof(T_ECN_FBS_HDR)];
    127         T_ECN_FBS_LNK   lnk;    /*      リンクポインタé
    128 åˆ—    128byte                 */
    129         uint8_t                 payload[DEF_ECN_FBS_FST_DAT_LEN];
    130 } T_ECN_FST_BLK;
    131 
    132 /* FBS-ID */
    133 typedef struct ecn_fbs_id_strc {
    134         T_ECN_FST_BLK   *ptr;
    135 } ECN_FBS_ID;
    136 
    137 ER _ecn_fbs_cre(size_t fa_req_size, ECN_FBS_ID *fp_id);
    138 ER _ecn_fbs_del(ECN_FBS_ID fa_id);
    139 size_t _ecn_fbs_get_datalen(ECN_FBS_ID fa_id);
    140 int _ecn_fbs_peek(ECN_FBS_ID fa_id, size_t fa_seek);
    141 ER _ecn_fbs_poke(ECN_FBS_ID fa_id, size_t fa_seek, int fa_val);
    142 
    143 extern ID ecn_api_mailboxid;
    144 extern ID WEBSOCKET_MBXID;
     65extern ID ws_api_mailboxid;
    14566
    14667typedef struct ws_state
    … …  
    16889        ws_state_t wstate;
    16990        ws_state_t rstate;
    170         ECN_FBS_ID cur_in_msg;
     91        WS_FBS_ID cur_in_msg;
    17192};
    17293
    … …  
    179100int websocket_output(struct websocket *ws, void *data, int len);
    180101
     102#endif /* TOPPERS_MACRO_ONLY */
     103
    181104#endif  /* WEBSOCKET_H */
Note: See TracChangeset for help on using the changeset viewer.