Changeset 375 for asp3_tinet_ecnl_arm


Ignore:
Timestamp:
Apr 6, 2019, 1:14:59 PM (4 years ago)
Author:
coas-nagasima
Message:

IPv6のソケット処理を追加（動作未確認）

Location:
asp3_tinet_ecnl_arm/trunk/ntshell/src
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • asp3_tinet_ecnl_arm/trunk/ntshell/src/socket_stub.c

    r374 r375  
    6767#include "kernel_cfg.h"
    6868
    69 #ifdef _DEBUG
    70 static const char THIS_FILE[] = __FILE__;
     69#define SOCKET_TIMEOUT 2000000
     70
     71#define tcp6_cre_cep tcp_cre_cep
     72#define tcp6_del_cep tcp_del_cep
     73#define tcp6_del_rep tcp_del_rep
     74#define tcp6_sht_cep tcp_sht_cep
     75#define tcp6_cls_cep tcp_cls_cep
     76#define tcp6_snd_oob tcp_snd_oob
     77#define tcp6_snd_dat tcp_snd_dat
     78#define tcp6_rcv_oob tcp_rcv_oob
     79#define tcp6_rcv_buf tcp_rcv_buf
     80#define tcp6_rel_buf tcp_rel_buf
     81#define tcp6_get_opt tcp_get_opt
     82#define tcp6_set_opt tcp_set_opt
     83
     84#define udp6_del_cep udp_del_cep
     85#define udp6_get_opt udp_get_opt
     86#define udp6_set_opt udp_set_opt
     87
     88#ifndef SUPPORT_INET6
     89
     90ER      tcp6_cre_rep (ID repid, T_TCP6_CREP *pk_crep) { return E_SYS; }
     91ER      tcp6_acp_cep (ID cepid, ID repid, T_IPV6EP *p_dstaddr, TMO tmout) { return E_SYS; }
     92ER      tcp6_con_cep (ID cepid, T_IPV6EP *p_myaddr, T_IPV6EP *p_dstaddr, TMO tmout) { return E_SYS; }
     93
     94ER      udp6_cre_cep (ID cepid, T_UDP6_CCEP *pk_ccep) { return E_SYS; }
     95ER_UINT udp6_snd_dat (ID cepid, T_IPV6EP *p_dstaddr, void *data, int_t len, TMO tmout) { return E_SYS; }
     96ER_UINT udp6_rcv_dat (ID cepid, T_IPV6EP *p_dstaddr, void *data, int_t len, TMO tmout) { return E_SYS; }
     97
     98const T_IN6_ADDR *in6_get_ifaddr (int_t index) { return NULL; }
     99
    71100#endif
    72101
    73 #define SOCKET_TIMEOUT 2000000
     102ER socket_tcp_callback(ID cepid, FN fncd, void *p_parblk);
     103ER socket_tcp6_callback(ID cepid, FN fncd, void *p_parblk);
     104ER socket_udp_callback(ID cepid, FN fncd, void *p_parblk);
     105ER socket_udp6_callback(ID cepid, FN fncd, void *p_parblk);
    74106
    75107static int tcp_fd_close(struct SHELL_FILE *fp);
    … …  
    110142#define tcp_cepid_table_count (sizeof(tcp_cepid_table) / sizeof(tcp_cepid_table[0]))
    111143
     144#ifdef SUPPORT_INET6
     145
     146id_table_t tcp6_repid_table[] = {
     147        {0, USR_TCP6_REP1}, {0, USR_TCP6_REP2}, {0, USR_TCP6_REP3}, {0, USR_TCP6_REP4}
     148};
     149#define tcp6_repid_table_count (sizeof(tcp6_repid_table) / sizeof(tcp6_repid_table[0]))
     150
     151id_table_t tcp6_cepid_table[] = {
     152        {0, USR_TCP6_CEP1}, {0, USR_TCP6_CEP2}, {0, USR_TCP6_CEP3}, {0, USR_TCP6_CEP4},
     153#ifndef TOPPERS_GRSAKURA
     154        {0, USR_TCP6_CEP5}, {0, USR_TCP6_CEP6}, {0, USR_TCP6_CEP7}, {0, USR_TCP6_CEP8}
     155#endif
     156};
     157#define tcp6_cepid_table_count (sizeof(tcp6_cepid_table) / sizeof(tcp6_cepid_table[0]))
     158
     159#else
     160
     161#define tcp6_repid_table NULL
     162#define tcp6_repid_table_count 0
     163
     164#define tcp6_cepid_table NULL
     165#define tcp6_cepid_table_count 0
     166
     167#endif
     168
    112169id_table_t udp_cepid_table[] = {
    113170        {0, USR_UDP_CEP1}, {0, USR_UDP_CEP2}, {0, USR_UDP_CEP3}, {0, USR_UDP_CEP4}
    114171};
    115172#define udp_cepid_table_count (sizeof(udp_cepid_table) / sizeof(udp_cepid_table[0]))
     173
     174#ifdef SUPPORT_INET6
     175
     176id_table_t udp6_cepid_table[] = {
     177        {0, USR_UDP6_CEP1}, {0, USR_UDP6_CEP2}, {0, USR_UDP6_CEP3}, {0, USR_UDP6_CEP4}
     178};
     179#define udp6_cepid_table_count (sizeof(udp6_cepid_table) / sizeof(udp6_cepid_table[0]))
     180
     181#else
     182
     183#define udp6_cepid_table NULL
     184#define udp6_cepid_table_count 0
     185
     186#endif
    116187
    117188ID new_id(id_table_t *table, int count)
    … …  
    252323                        return -EINVAL;
    253324                }
    254                 memcpy(&socket->laddr4, addr, len);
    255                 break;
    256         }
     325                struct sockaddr_in6 *addr_in6 = (struct sockaddr_in6 *)addr;
     326                memcpy(&socket->laddr6, addr, len);
     327                switch (socket->type) {
     328                case SOCK_STREAM: {
     329                        ID cepid = new_id(tcp6_cepid_table, tcp6_cepid_table_count);
     330                        if (cepid < 0)
     331                                return -ENOMEM;
     332
     333                        socket->buf_size = 512 + 512;
     334                        socket->buf = malloc(socket->buf_size);
     335#ifdef _DEBUG
     336                        memset(socket->buf, 0, socket->buf_size);
     337#endif
     338                        T_TCP6_CCEP ccep = { 0, socket->buf, 512, &socket->buf[512], 512, (FP)socket_tcp6_callback };
     339                        ret = tcp6_cre_cep(cepid, &ccep);
     340                        if (ret != E_OK) {
     341                                delete_id(tcp6_cepid_table, tcp6_cepid_table_count, cepid);
     342                                return -ENOMEM;
     343                        }
     344                        fp->handle = cepid;
     345                        socket->cepid = cepid;
     346                        break;
     347                }
     348                case SOCK_DGRAM: {
     349                        ID cepid = new_id(udp_cepid_table, udp_cepid_table_count);
     350                        if (cepid < 0)
     351                                return -ENOMEM;
     352
     353                        T_UDP6_CCEP ccep = { 0, {ntohl(addr_in6->sin6_addr.__in6_union.__s6_addr), ntohs(addr_in6->sin6_port)}, (FP)socket_udp6_callback };
     354                        ret = udp6_cre_cep(cepid, &ccep);
     355                        if (ret != E_OK) {
     356                                delete_id(udp_cepid_table, udp_cepid_table_count, cepid);
     357                                return -ENOMEM;
     358                        }
     359                        fp->handle = cepid;
     360                        socket->cepid = cepid;
     361                        break;
     362                }
     363                default:
     364                        return -ENOPROTOOPT;
     365                }
     366                break;
     367        }
     368        default:
     369                return -ENOPROTOOPT;
    257370        }
    258371
    … …  
    289402        }
    290403        case AF_INET6: {
    291                 break;
    292         }
     404                ID repid = new_id(tcp6_repid_table, tcp6_repid_table_count);
     405                if (repid < 0)
     406                        return -ENOMEM;
     407
     408                struct sockaddr_in6 *laddr = &socket->laddr6;
     409                T_TCP6_CREP crep = { 0, {ntohl(laddr->sin6_addr.__in6_union.__s6_addr), ntohs(laddr->sin6_port)} };
     410                ret = tcp6_cre_rep(repid, &crep);
     411                if (ret != E_OK) {
     412                        delete_id(tcp6_repid_table, tcp6_repid_table_count, repid);
     413                        return -ENOMEM;
     414                }
     415                socket->repid = repid;
     416                break;
     417        }
     418        default:
     419                return -ENOPROTOOPT;
    293420        }
    294421
    … …  
    343470        }
    344471        case AF_INET6: {
    345                 break;
    346         }
     472                if (len < 20) {
     473                        return -EINVAL;
     474                }
     475                if (socket->cepid == 0) {
     476                        ID cepid = new_id(tcp6_cepid_table, tcp6_cepid_table_count);
     477                        if (cepid < 0)
     478                                return -ENOMEM;
     479
     480                        socket->buf_size = 512 + 512;
     481                        socket->buf = malloc(socket->buf_size);
     482#ifdef _DEBUG
     483                        memset(socket->buf, 0, socket->buf_size);
     484#endif
     485                        T_TCP6_CCEP ccep = { 0, socket->buf, 512, &socket->buf[512], 512, (FP)socket_tcp6_callback };
     486                        ret = tcp6_cre_cep(cepid, &ccep);
     487                        if (ret != E_OK) {
     488                                delete_id(tcp6_cepid_table, tcp6_cepid_table_count, cepid);
     489                                return -ENOMEM;
     490                        }
     491                        fp->handle = cepid;
     492                        socket->cepid = cepid;
     493                }
     494                struct sockaddr_in6 *laddr = &socket->laddr6;
     495                struct sockaddr_in6 *raddr = &socket->raddr6;
     496                memset(raddr, 0, sizeof(*raddr));
     497                memcpy(raddr, addr, len);
     498                T_IPV6EP lep = { ntohl(laddr->sin6_addr.__in6_union.__s6_addr), ntohs(laddr->sin6_port) };
     499                T_IPV6EP rep = { ntohl(raddr->sin6_addr.__in6_union.__s6_addr), ntohs(raddr->sin6_port) };
     500                ret = tcp6_con_cep(socket->cepid, &lep, &rep, SOCKET_TIMEOUT);
     501                if (ret < 0) {
     502                        return -EHOSTUNREACH;
     503                }
     504                break;
     505        }
     506        default:
     507                return -ENOPROTOOPT;
    347508        }
    348509
    … …  
    409570                raddr->sin_port = htons(rep.portno);
    410571                raddr->sin_addr.s_addr = htonl(rep.ipaddr);
     572
     573                if (addr != NULL && len != NULL) {
     574                        int sz = *len;
     575                        if (sz < 8) {
     576                                return -EINVAL;
     577                        }
     578                        struct sockaddr_in *raddr = &socket->raddr4;
     579                        if (sz > sizeof(*raddr))
     580                                sz = sizeof(*raddr);
     581                        memcpy(addr, raddr, sz);
     582                        *len = sizeof(*raddr);
     583                }
    411584                break;
    412585        }
    413586        case AF_INET6: {
    414                 return -EAFNOSUPPORT;
    415         }
    416         }
    417 
    418         if (addr != NULL && len != NULL) {
    419                 int sz = *len;
    420                 if (sz < 8) {
    421                         return -EINVAL;
    422                 }
    423                 struct sockaddr_in *raddr = &socket->raddr4;
    424                 if (sz > sizeof(*raddr))
    425                         sz = sizeof(*raddr);
    426                 memcpy(addr, raddr, sz);
    427                 *len = sizeof(*raddr);
     587                ID cepid;
     588                if (socket->cepid == 0) {
     589                        cepid = new_id(tcp6_cepid_table, tcp6_cepid_table_count);
     590                        if (cepid < 0)
     591                                return -ENOMEM;
     592
     593                        socket->buf_size = 512 + 512;
     594                        socket->buf = malloc(socket->buf_size);
     595#ifdef _DEBUG
     596                        memset(socket->buf, 0, socket->buf_size);
     597#endif
     598                        T_TCP6_CCEP ccep = { 0, socket->buf, 512, &socket->buf[512], 512, (FP)socket_tcp6_callback };
     599                        ret = tcp6_cre_cep(cepid, &ccep);
     600                        if (ret != E_OK) {
     601                                delete_id(tcp6_cepid_table, tcp6_cepid_table_count, cepid);
     602                                return -ENOMEM;
     603                        }
     604                        fp->handle = cepid;
     605                        socket->cepid = cepid;
     606                }
     607                else {
     608                        cepid = ((socket_t *)lfp->exinf)->cepid;
     609                        fp->handle = cepid;
     610                        lfp->handle = tmax_tcp6_cepid + ((socket_t *)lfp->exinf)->repid;
     611                        ((socket_t *)lfp->exinf)->cepid = 0;
     612                        ((socket_t *)lfp->exinf)->buf_size = 0;
     613                        ((socket_t *)lfp->exinf)->buf = 0;
     614                }
     615                T_IPV6EP rep = { 0, 0 };
     616                ret = tcp6_acp_cep(socket->cepid, socket->repid, &rep, TMO_FEVR);
     617                if (ret < 0) {
     618                        return -ENOMEM;
     619                }
     620                struct sockaddr_in6 *raddr = &socket->raddr6;
     621                memset(raddr, 0, sizeof(*raddr));
     622                raddr->sin6_family = AF_INET;
     623                raddr->sin6_port = htons(rep.portno);
     624#if _NET_CFG_BYTE_ORDER == _NET_CFG_BIG_ENDIAN
     625                memcpy(raddr->sin6_addr.__in6_union.__s6_addr, rep.ipaddr.__u6_addr.__u6_addr8, 16);
     626#else
     627                for (int i = 0; i < 16; i++)
     628                        raddr->sin6_addr.__in6_union.__s6_addr[i] = rep.ipaddr.__u6_addr.__u6_addr8[i];
     629#endif
     630
     631                if (addr != NULL && len != NULL) {
     632                        int sz = *len;
     633                        if (sz < 8) {
     634                                return -EINVAL;
     635                        }
     636                        struct sockaddr_in6 *raddr = &socket->raddr6;
     637                        if (sz > sizeof(*raddr))
     638                                sz = sizeof(*raddr);
     639                        memcpy(addr, raddr, sz);
     640                        *len = sizeof(*raddr);
     641                }
     642                break;
     643        }
     644        default:
     645                return -ENOPROTOOPT;
    428646        }
    429647
    … …  
    490708        }
    491709        case AF_INET6: {
    492                 return -EAFNOSUPPORT;
    493         }
     710                switch (socket->type) {
     711                case SOCK_STREAM: {
     712                        if ((addr != NULL) || (alen != 0)) {
     713                                return -EISCONN;
     714                        }
     715
     716                        if (flags & MSG_OOB) {
     717                                ret = tcp6_snd_oob(socket->cepid, (void *)buf, len, SOCKET_TIMEOUT);
     718                                if (ret < 0) {
     719                                        return -ECOMM;
     720                                }
     721                        }
     722                        else {
     723                                for (;;) {
     724                                        ret = tcp6_snd_dat(socket->cepid, (void *)buf, len, SOCKET_TIMEOUT);
     725                                        if (ret < 0) {
     726                                                if (ret == E_TMOUT)
     727                                                        return -ETIME;
     728                                                return -ECOMM;
     729                                        }
     730                                        len -= ret;
     731                                        if (len <= 0)
     732                                                break;
     733                                        buf = (const void *)&((uint8_t *)buf)[ret];
     734                                }
     735                        }
     736                        break;
     737                }
     738                case SOCK_DGRAM: {
     739                        int sz = alen;
     740                        if ((addr == NULL) || (sz < 8)) {
     741                                return -EINVAL;
     742                        }
     743                        struct sockaddr_in6 *raddr = &socket->raddr6;
     744                        memset(raddr, 0, sizeof(*raddr));
     745                        memcpy(raddr, addr, sz);
     746                        T_IPV6EP rep = { ntohl(raddr->sin6_addr.__in6_union.__s6_addr), ntohs(raddr->sin6_port) };
     747                        ret = udp6_snd_dat(socket->cepid, &rep, (void *)buf, len,
     748                                (socket->flags & O_NONBLOCK) ? TMO_POL : SOCKET_TIMEOUT);
     749                        if (ret < 0) {
     750                                return (ret == E_TMOUT) ? -ETIME : -ECOMM;
     751                        }
     752                        break;
     753                }
     754                }
     755                break;
     756        }
     757        default:
     758                return -ENOPROTOOPT;
    494759        }
    495760
    … …  
    648913        }
    649914        case AF_INET6: {
    650                 return -EAFNOSUPPORT;
    651         }
     915                switch (socket->type) {
     916                case SOCK_STREAM: {
     917                        if (flags & MSG_OOB) {
     918                                ret = tcp6_rcv_oob(socket->cepid, buf, len);
     919                                if (ret < 0) {
     920                                        syslog(LOG_ERROR, "tcp6_rcv_oob => %d", ret);
     921                                        return -ECOMM;
     922                                }
     923                        }
     924                        else {
     925                                int rsz, tmp;
     926                                if (socket->input == NULL) {
     927                                        ret = wai_sem(SEM_FILEDESC);
     928                                        if (ret < 0) {
     929                                                syslog(LOG_ERROR, "wai_sem => %d", ret);
     930                                        }
     931                                        socket->len = 0;
     932                                        ret = sig_sem(SEM_FILEDESC);
     933                                        if (ret < 0) {
     934                                                syslog(LOG_ERROR, "sig_sem => %d", ret);
     935                                        }
     936                                        ret = tcp6_rcv_buf(socket->cepid, &socket->input, TMO_FEVR);
     937                                        if (ret < 0) {
     938                                                syslog(LOG_ERROR, "tcp6_rcv_buf => %d", ret);
     939                                                return -ECOMM;
     940                                        }
     941                                        rsz = ret;
     942                                }
     943                                else
     944                                        rsz = socket->len;
     945                                tmp = rsz;
     946                                if (rsz > len)
     947                                        rsz = len;
     948                                if (rsz >= 0) {
     949                                        memcpy(buf, socket->input, rsz);
     950                                        ret = wai_sem(SEM_FILEDESC);
     951                                        if (ret < 0) {
     952                                                syslog(LOG_ERROR, "wai_sem => %d", ret);
     953                                        }
     954                                        socket->len = tmp - rsz;
     955                                        ret = sig_sem(SEM_FILEDESC);
     956                                        if (ret < 0) {
     957                                                syslog(LOG_ERROR, "sig_sem => %d", ret);
     958                                        }
     959                                        if (tmp - rsz == 0) {
     960                                                socket->input = NULL;
     961                                        }
     962                                        else
     963                                                socket->input = (void *)&((uint8_t *)socket->input)[rsz];
     964                                        ret = tcp6_rel_buf(socket->cepid, rsz);
     965                                        if ((ret != E_OBJ) && (ret < 0)) {
     966                                                syslog(LOG_ERROR, "tcp6_rel_buf => %d", ret);
     967                                                //return -ECOMM;
     968                                        }
     969                                }
     970                                ret = rsz;
     971                        }
     972                        break;
     973                }
     974                case SOCK_DGRAM: {
     975                        struct sockaddr_in6 *raddr = &socket->raddr6;
     976                        int rsz;
     977                        ret = wai_sem(SEM_FILEDESC);
     978                        if (ret < 0) {
     979                                syslog(LOG_ERROR, "wai_sem => %d", ret);
     980                        }
     981                        T_NET_BUF *input = socket->input;
     982                        if (input == NULL) {
     983                                ret = sig_sem(SEM_FILEDESC);
     984                                if (ret < 0) {
     985                                        syslog(LOG_ERROR, "sig_sem => %d", ret);
     986                                }
     987
     988                                T_IPV6EP rep = { 0, 0 };
     989                                ret = udp6_rcv_dat(socket->cepid, &rep, buf, len,
     990                                        (socket->flags & O_NONBLOCK) ? TMO_POL : SOCKET_TIMEOUT);
     991                                if (ret < 0) {
     992                                        if ((socket->flags & O_NONBLOCK) == 0)
     993                                                syslog(LOG_ERROR, "udp6_rcv_buf => %d", ret);
     994                                        return (ret == E_TMOUT) ? -ETIME : -ECOMM;
     995                                }
     996                                rsz = ret;
     997                                if ((addr != NULL) && (alen != NULL)) {
     998                                        ret = wai_sem(SEM_FILEDESC);
     999                                        if (ret < 0) {
     1000                                                syslog(LOG_ERROR, "wai_sem => %d", ret);
     1001                                        }
     1002                                        int sz = *alen;
     1003                                        memset(raddr, 0, sizeof(socket->raddr6));
     1004                                        raddr->sin6_family = AF_INET;
     1005                                        raddr->sin6_port = htons(rep.portno);
     1006#if _NET_CFG_BYTE_ORDER == _NET_CFG_BIG_ENDIAN
     1007                                        memcpy(raddr->sin6_addr.__in6_union.__s6_addr, rep.ipaddr.__u6_addr.__u6_addr8, 16);
     1008#else
     1009                                        for (int i = 0; i < 16; i++)
     1010                                                raddr->sin6_addr.__in6_union.__s6_addr[i] = rep.ipaddr.__u6_addr.__u6_addr8[i];
     1011#endif
     1012                                        if (sz > sizeof(socket->raddr6))
     1013                                                sz = sizeof(socket->raddr6);
     1014                                        memcpy(addr, raddr, sz);
     1015                                        *alen = sz;
     1016                                        ret = sig_sem(SEM_FILEDESC);
     1017                                        if (ret < 0) {
     1018                                                syslog(LOG_ERROR, "sig_sem => %d", ret);
     1019                                        }
     1020                                }
     1021                        }
     1022                        else {
     1023                                rsz = socket->len;
     1024                                void *pbuf = socket->buf;
     1025                                socket->input = NULL;
     1026                                socket->len = 0;
     1027                                socket->buf = NULL;
     1028                                if ((addr != NULL) && (alen != NULL)) {
     1029                                        int sz = *alen;
     1030                                        if (sz > sizeof(socket->raddr6))
     1031                                                sz = sizeof(socket->raddr6);
     1032                                        memcpy(addr, raddr, sz);
     1033                                        *alen = sz;
     1034                                }
     1035                                ret = sig_sem(SEM_FILEDESC);
     1036                                if (ret < 0) {
     1037                                        syslog(LOG_ERROR, "sig_sem => %d", ret);
     1038                                }
     1039                                if (rsz > len)
     1040                                        rsz = len;
     1041                                memcpy(buf, pbuf, rsz);
     1042                                ret = rel_net_buf(input);
     1043                                if (ret < 0) {
     1044                                        syslog(LOG_ERROR, "rel_net_buf => %d", ret);
     1045                                        //return -ECOMM;
     1046                                }
     1047                        }
     1048                        ret = rsz;
     1049                }
     1050                }
     1051                break;
     1052        }
     1053        default:
     1054                return -ENOPROTOOPT;
    6521055        }
    6531056
    … …  
    6841087        }
    6851088        case AF_INET6: {
    686                 return -EAFNOSUPPORT;
    687         }
     1089                switch (socket->type) {
     1090                case SOCK_STREAM: {
     1091                        ret = tcp6_sht_cep(socket->cepid);
     1092                        if (ret < 0) {
     1093                                return -ECOMM;
     1094                        }
     1095                        break;
     1096                }
     1097                }
     1098                break;
     1099        }
     1100        default:
     1101                return -ENOPROTOOPT;
    6881102        }
    6891103
    … …  
    7601174        }
    7611175        case AF_INET6: {
    762                 return -EAFNOSUPPORT;
    763         }
     1176                switch (socket->type) {
     1177                case SOCK_STREAM: {
     1178                        switch (level) {
     1179                        case SOL_SOCKET:
     1180                                switch (optname) {
     1181                                case SO_REUSEADDR:
     1182                                        if (socket->flags & SO_REUSEADDR) {
     1183                                                *(bool *)optval = true;
     1184                                        }
     1185                                        else {
     1186                                                *(bool *)optval = false;
     1187                                        }
     1188                                        break;
     1189                                case SO_KEEPALIVE:
     1190                                        if (socket->flags & SO_KEEPALIVE) {
     1191                                                *(bool *)optval = true;
     1192                                        }
     1193                                        else {
     1194                                                *(bool *)optval = false;
     1195                                        }
     1196                                        break;
     1197                                case SO_ERROR:
     1198                                        *(int *)optval = 0;
     1199                                        break;
     1200                                default:
     1201                                        return -EINVAL;
     1202                                }
     1203                                break;
     1204                        case IPPROTO_TCP:
     1205                                ret = tcp6_get_opt(socket->cepid, optname, (void *)optval, *optlen);
     1206                                if (ret < 0) {
     1207                                        return -EINVAL;
     1208                                }
     1209                                *optlen = ret;
     1210                                break;
     1211                        default:
     1212                                return -EINVAL;
     1213                        }
     1214                        break;
     1215                }
     1216                case SOCK_DGRAM: {
     1217                        switch (level) {
     1218                        case IPPROTO_UDP:
     1219                                ret = udp6_get_opt(socket->cepid, optname, (void *)optval, *optlen);
     1220                                if (ret < 0) {
     1221                                        return -EINVAL;
     1222                                }
     1223                                *optlen = ret;
     1224                                break;
     1225                        default:
     1226                                return -EINVAL;
     1227                        }
     1228                        break;
     1229                }
     1230                }
     1231                break;
     1232        }
     1233        default:
     1234                return -ENOPROTOOPT;
    7641235        }
    7651236
    … …  
    8311302        }
    8321303        case AF_INET6: {
    833                 return -EAFNOSUPPORT;
    834         }
     1304                switch (socket->type) {
     1305                case SOCK_STREAM: {
     1306                        switch (level){
     1307                        case SOL_SOCKET:
     1308                                switch (optname) {
     1309                                case SO_REUSEADDR:
     1310                                        if (*(bool *)optval) {
     1311                                                socket->flags |= SO_REUSEADDR;
     1312                                        }
     1313                                        else {
     1314                                                socket->flags &= ~SO_REUSEADDR;
     1315                                        }
     1316                                        break;
     1317                                case SO_KEEPALIVE:
     1318                                        if (*(bool *)optval) {
     1319                                                socket->flags |= SO_KEEPALIVE;
     1320                                        }
     1321                                        else {
     1322                                                socket->flags &= ~SO_KEEPALIVE;
     1323                                        }
     1324                                        break;
     1325                                default:
     1326                                        return -EINVAL;
     1327                                }
     1328                                break;
     1329                        case IPPROTO_TCP:
     1330                                ret = tcp6_set_opt(socket->cepid, optname, (void *)optval, optlen);
     1331                                if (ret < 0) {
     1332                                        return -EINVAL;
     1333                                }
     1334                                break;
     1335                        default:
     1336                                return -EINVAL;
     1337                        }
     1338                        break;
     1339                }
     1340                case SOCK_DGRAM: {
     1341                        switch (level){
     1342                        case IPPROTO_UDP:
     1343                                ret = udp6_set_opt(socket->cepid, optname, (void *)optval, optlen);
     1344                                if (ret < 0) {
     1345                                        return -EINVAL;
     1346                                }
     1347                                break;
     1348                        default:
     1349                                return -EINVAL;
     1350                        }
     1351                        break;
     1352                }
     1353                }
     1354                break;
     1355        }
     1356        default:
     1357                return -ENOPROTOOPT;
    8351358        }
    8361359
    … …  
    8601383        }
    8611384        case AF_INET6: {
    862                 return -EAFNOSUPPORT;
    863         }
     1385                struct sockaddr_in6 *raddr = &socket->raddr6;
     1386                *len = sizeof(struct sockaddr_in6);
     1387                if (size > sizeof(struct sockaddr_in6))
     1388                        size = sizeof(struct sockaddr_in6);
     1389                memcpy(addr, raddr, size);
     1390                break;
     1391        }
     1392        default:
     1393                return -ENOPROTOOPT;
    8641394        }
    8651395
    … …  
    8941424        }
    8951425        case AF_INET6: {
    896                 return -EAFNOSUPPORT;
    897         }
     1426                const T_IN6_ADDR *laddr6 = in6_get_ifaddr(0);
     1427                struct sockaddr_in6 laddr;
     1428                laddr.sin6_family = AF_INET;
     1429#if _NET_CFG_BYTE_ORDER == _NET_CFG_BIG_ENDIAN
     1430                memcpy(laddr.sin6_addr.__in6_union.__s6_addr, laddr6->__u6_addr.__u6_addr8, 16);
     1431#else
     1432                for (int i = 0; i < 16; i++)
     1433                        laddr.sin6_addr.__in6_union.__s6_addr[i] = laddr6->__u6_addr.__u6_addr8[i];
     1434#endif
     1435                laddr.sin6_port = socket->laddr6.sin6_port;
     1436                *len = sizeof(struct sockaddr_in6);
     1437                if (size > sizeof(struct sockaddr_in6))
     1438                        size = sizeof(struct sockaddr_in6);
     1439                memcpy(addr, &laddr, size);
     1440                break;
     1441        }
     1442        default:
     1443                return -ENOPROTOOPT;
    8981444        }
    8991445
    … …  
    9371483        }
    9381484        case AF_INET6: {
    939                 return -EAFNOSUPPORT;
    940         }
     1485                if (socket->cepid != 0) {
     1486                        ID cepid = socket->cepid;
     1487                        ret = tcp6_sht_cep(cepid);
     1488                        if (ret < 0) {
     1489                                //return -1;
     1490                        }
     1491                        ret = tcp6_cls_cep(cepid, (socket->repid != 0) ? 0 : SOCKET_TIMEOUT);
     1492                        ret2 = tcp6_del_cep(cepid);
     1493                        //delete_fd_by_id(&IO_TYPE_TCP, cepid);
     1494                        delete_id(tcp6_cepid_table, tcp6_cepid_table_count, cepid);
     1495                        if ((ret < 0) || (ret2 < 0)) {
     1496                                return (ret == E_TMOUT) ? -ETIME : -EINVAL;
     1497                        }
     1498                }
     1499                else if (socket->repid != 0) {
     1500                        ID repid = socket->repid;
     1501                        ret = tcp6_del_rep(repid);
     1502                        //delete_fd_by_id(&IO_TYPE_TCP, tmax_tcp6_cepid + repid);
     1503                        delete_id(tcp6_repid_table, tcp6_repid_table_count, repid);
     1504                        if (ret < 0) {
     1505                                return -EINVAL;
     1506                        }
     1507                }
     1508                else {
     1509                        return -EINVAL;
     1510                }
     1511                break;
     1512        }
     1513        default:
     1514                return -ENOPROTOOPT;
    9411515        }
    9421516
    … …  
    10071581
    10081582ER socket_tcp_callback(ID cepid, FN fncd, void *p_parblk)
     1583{
     1584        struct SHELL_FILE *fp = id_to_fd(&IO_TYPE_TCP, cepid);
     1585        FLGPTN flgptn = 0;
     1586        ER ret;
     1587        int len;
     1588
     1589        if (fp == NULL)
     1590                return E_PAR;
     1591
     1592        int fd = fp->fd;
     1593        FD_SET(fd, (fd_set *)&flgptn);
     1594
     1595        switch (fncd) {
     1596        case TFN_TCP_RCV_BUF:
     1597                len = *(int *)p_parblk;
     1598                if ((len <= 0) || (fp->exinf == NULL))
     1599                        return E_OK;
     1600
     1601                ret = wai_sem(SEM_FILEDESC);
     1602                if (ret < 0) {
     1603                        syslog(LOG_ERROR, "wai_sem => %d", ret);
     1604                }
     1605                socket_t *socket = (socket_t *)fp->exinf;
     1606                socket->len += len;
     1607                ret = sig_sem(SEM_FILEDESC);
     1608                if (ret < 0) {
     1609                        syslog(LOG_ERROR, "sig_sem => %d", ret);
     1610                }
     1611
     1612                if (fp->readevt_w == fp->readevt_r) fp->readevt_w++;
     1613
     1614                set_flg(FLG_SELECT_WAIT, flgptn);
     1615                return E_OK;
     1616
     1617        case TFN_TCP_RCV_DAT:
     1618                len = *(int *)p_parblk;
     1619                if ((len <= 0) || (fp->exinf == NULL))
     1620                        return E_OK;
     1621
     1622                ret = wai_sem(SEM_FILEDESC);
     1623                if (ret < 0) {
     1624                        syslog(LOG_ERROR, "wai_sem => %d", ret);
     1625                }
     1626                socket->len += len;
     1627                ret = sig_sem(SEM_FILEDESC);
     1628                if (ret < 0) {
     1629                        syslog(LOG_ERROR, "sig_sem => %d", ret);
     1630                }
     1631
     1632                if (fp->readevt_w == fp->readevt_r) fp->readevt_w++;
     1633
     1634                set_flg(FLG_SELECT_WAIT, flgptn);
     1635                return E_OK;
     1636
     1637        case TFN_TCP_SND_DAT:
     1638                if (fp->writeevt_w == fp->writeevt_r) fp->writeevt_w++;
     1639
     1640                set_flg(FLG_SELECT_WAIT, flgptn);
     1641                return E_OK;
     1642
     1643        case TFN_TCP_CAN_CEP:
     1644                if (fp->errorevt_w == fp->errorevt_r) fp->errorevt_w++;
     1645
     1646                set_flg(FLG_SELECT_WAIT, flgptn);
     1647                return E_OK;
     1648
     1649        case TFN_TCP_DEL_REP:
     1650                delete_fd_by_id(&IO_TYPE_TCP, tmax_tcp_cepid + cepid);
     1651                return E_OK;
     1652
     1653        case TFN_TCP_DEL_CEP:
     1654                delete_fd_by_id(&IO_TYPE_TCP, cepid);
     1655                return E_OK;
     1656
     1657        default:
     1658                return E_OK;
     1659        }
     1660}
     1661
     1662ER socket_tcp6_callback(ID cepid, FN fncd, void *p_parblk)
    10091663{
    10101664        struct SHELL_FILE *fp = id_to_fd(&IO_TYPE_TCP, cepid);
    … …  
    11041758        }
    11051759        case AF_INET6: {
    1106                 return -EAFNOSUPPORT;
    1107         }
     1760                cepid = socket->cepid;
     1761                ret = udp6_del_cep(cepid);
     1762                //delete_fd_by_id(&IO_TYPE_UDP, cepid);
     1763                delete_id(udp6_cepid_table, udp6_cepid_table_count, cepid);
     1764                if (ret < 0) {
     1765                        return -EINVAL;
     1766                }
     1767                break;
     1768        }
     1769        default:
     1770                return -ENOPROTOOPT;
    11081771        }
    11091772
    … …  
    12351898}
    12361899
     1900ER socket_udp6_callback(ID cepid, FN fncd, void *p_parblk)
     1901{
     1902        struct SHELL_FILE *fp = id_to_fd(&IO_TYPE_UDP, cepid);
     1903        FLGPTN flgptn = 0;
     1904        int len;
     1905
     1906        if (fp == NULL)
     1907                return E_PAR;
     1908
     1909        int fd = fp->fd;
     1910        FD_SET(fd, (fd_set *)&flgptn);
     1911
     1912        switch (fncd) {
     1913        case TEV_UDP_RCV_DAT:
     1914        {
     1915                T_UDP_RCV_DAT_PARA *udppara = (T_UDP_RCV_DAT_PARA *)p_parblk;
     1916                len = udppara->len;
     1917                if ((len <= 0) || (fp->exinf == NULL))
     1918                        return E_OK;
     1919
     1920                ER ret = wai_sem(SEM_FILEDESC);
     1921                if (ret < 0) {
     1922                        syslog(LOG_ERROR, "wai_sem => %d", ret);
     1923                }
     1924                socket_t *socket = (socket_t *)fp->exinf;
     1925                socket->len = len;
     1926                if (socket->input != NULL) {
     1927                        ret = rel_net_buf(socket->input);
     1928                        if (ret < 0) {
     1929                                syslog(LOG_ERROR, "rel_net_buf => %d", ret);
     1930                        }
     1931                }
     1932                socket->input = udppara->input;
     1933                socket->buf = GET_UDP_SDU(udppara->input, udppara->off);
     1934                memset(&socket->raddr6, 0, sizeof(socket->raddr6));
     1935                socket->raddr6.sin6_family = AF_INET;
     1936                socket->raddr6.sin6_port = htons(udppara->rep6.portno);
     1937#if _NET_CFG_BYTE_ORDER == _NET_CFG_BIG_ENDIAN
     1938                memcpy(socket->raddr6.sin6_addr.__in6_union.__s6_addr, udppara->rep6.ipaddr.__u6_addr.__u6_addr8, 16);
     1939#else
     1940                for (int i = 0; i < 16; i++)
     1941                        socket->raddr6.sin6_addr.__in6_union.__s6_addr[i] = udppara->rep6.ipaddr.__u6_addr.__u6_addr8[i];
     1942#endif
     1943                udppara->input->flags |= NB_FLG_NOREL_IFOUT;
     1944                ret = sig_sem(SEM_FILEDESC);
     1945                if (ret < 0) {
     1946                        syslog(LOG_ERROR, "sig_sem => %d", ret);
     1947                }
     1948
     1949                if (fp->readevt_w == fp->readevt_r) fp->readevt_w++;
     1950
     1951                set_flg(FLG_SELECT_WAIT, flgptn);
     1952                return E_OK;
     1953        }
     1954        case TFN_UDP_CRE_CEP:
     1955                return E_OK;
     1956
     1957        case TFN_UDP_RCV_DAT:
     1958                len = *(int *)p_parblk;
     1959                if ((len <= 0) || (fp->exinf == NULL))
     1960                        return E_OK;
     1961
     1962                if (fp->readevt_w == fp->readevt_r) fp->readevt_w++;
     1963
     1964                set_flg(FLG_SELECT_WAIT, flgptn);
     1965                return E_OK;
     1966
     1967        case TFN_UDP_SND_DAT:
     1968                if (fp->writeevt_w == fp->writeevt_r) fp->writeevt_w++;
     1969
     1970                set_flg(FLG_SELECT_WAIT, flgptn);
     1971                return E_OK;
     1972
     1973        case TFN_UDP_CAN_CEP:
     1974                if (fp->errorevt_w == fp->errorevt_r) fp->errorevt_w++;
     1975
     1976                set_flg(FLG_SELECT_WAIT, flgptn);
     1977                return E_OK;
     1978
     1979        case TFN_UDP_DEL_CEP:
     1980                delete_fd_by_id(&IO_TYPE_UDP, cepid);
     1981                return E_OK;
     1982
     1983        default:
     1984                return E_OK;
     1985        }
     1986}
     1987
    12371988#ifndef TCP_CFG_EXTENTIONS
    12381989ER tcp_cre_rep(ID repid, T_TCP_CREP *pk_crep)

  • asp3_tinet_ecnl_arm/trunk/ntshell/src/socket_stub.h

    r374 r375  
    152152void clean_fd();
    153153
    154 ER socket_tcp_callback(ID cepid, FN fncd, void *p_parblk);
    155 ER socket_udp_callback(ID cepid, FN fncd, void *p_parblk);
    156 
    157154#endif // !SOCKET_STUB_H
Note: See TracChangeset for help on using the changeset viewer.