Ignore:
Timestamp:
Jan 21, 2018, 12:10:09 AM (6 years ago)
Author:
coas-nagasima
Message:

prototoolに関連するプロジェクトをnewlibからmuslを使うよう変更・更新
ntshellをnewlibの下位の実装から、muslのsyscallの実装に変更・更新
以下のOSSをアップデート
・mruby-1.3.0
・musl-1.1.18
・onigmo-6.1.3
・tcc-0.9.27
以下のOSSを追加
・openssl-1.1.0e
・curl-7.57.0
・zlib-1.2.11
以下のmrbgemsを追加
・iij/mruby-digest
・iij/mruby-env
・iij/mruby-errno
・iij/mruby-iijson
・iij/mruby-ipaddr
・iij/mruby-mock
・iij/mruby-require
・iij/mruby-tls-openssl

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r321 r331  
    3535 *  @(#) $Id$
    3636 */
    37 #include <sys/types.h>
    38 #include <stdint.h>
    39 #if 0
    40 #include <sys/socket.h>
    41 #include <sys/un.h>
    42 #include <netinet/in.h>
    43 #include <netinet/tcp.h>
    44 #include <arpa/inet.h>
    45 #include <netdb.h>
    46 #endif
    47 #include <fcntl.h>
    48 #include "sys/unistd.h"
    49 #include <stddef.h>
    50 #include <string.h>
    51 #include <stdlib.h>
     37#include "shellif.h"
    5238#include <kernel.h>
    5339#include <t_syslog.h>
    5440#include <t_stdlib.h>
     41#include <string.h>
    5542#include <sil.h>
    56 #include <stdlib.h>
    57 #include <string.h>
    58 #include <stdio.h>
    5943#include <setjmp.h>
    6044#include "syssvc/syslog.h"
    … …  
    7458#include "ff.h"
    7559#include "socket_stub.h"
    76 #define SO_REUSEADDR    2
     60
     61#define SOCKET_TIMEOUT 2000000
    7762
    7863typedef struct id_table_t {
    … …  
    10792}
    10893
    109         return -1;
     94        return -ENOMEM;
    11095}
    11196
    … …  
    120105                return 0;
    121106        }
    122         return -1;
     107        return -EINVAL;
    123108}
    124109
    125110int delete_tcp_rep(int repid)
    126111{
    127         delete_tcp_fd(tmax_tcp_cepid + repid);
     112        return delete_tcp_fd(tmax_tcp_cepid + repid);
    128113}
    129114
    … …  
    145130typedef struct _IO_FILE SOCKET;
    146131
    147 int socket(int family, int type, int protocol)
     132int shell_socket(int family, int type, int protocol)
    148133{
    149134        SOCKET *fp;
     135        unsigned int flags;
    150136
    151137        switch (family) {
    … …  
    154140                break;
    155141        default:
    156                 return -1;
    157         }
     142                return -EAFNOSUPPORT;
     143        }
     144
     145        flags = type & (SOCK_CLOEXEC|SOCK_NONBLOCK);
     146        type &= ~flags;
    158147
    159148        switch (type) {
    … …  
    165154                break;
    166155        default:
    167                 return -1;
     156                return -ENOPROTOOPT;
    168157        }
    169158
    170159        if (fp == NULL) {
    171                 return -1;
     160                return -ENOMEM;
    172161        }
    173162
    … …  
    175164        fp->socket.type = type;
    176165        fp->socket.protocol = protocol;
     166        fp->socket.flags = flags;
    177167
    178168        return fp->fd;
    179169}
    180170
    181 int bind(int fd, const struct sockaddr *addr, socklen_t len)
     171int shell_bind(int fd, const struct sockaddr *addr, socklen_t len)
    182172{
    183173        SOCKET *fp = fd_to_fp(fd);
    184         if (fp == NULL) {
    185                 return -1;
    186         }
    187 
    188         if (fp->socket.family != addr->sa_family) {
    189                 return -1;
    190         }
     174        if (fp == NULL)
     175                return -EBADF;
     176        if (fp->socket.family != addr->sa_family)
     177                return -EINVAL;
    191178
    192179        ER ret;
    … …  
    194181        case AF_INET: {
    195182                if (len < 8) {
    196                         return -1;
     183                        return -EINVAL;
    197184                }
    198185                struct sockaddr_in *addr_in = (struct sockaddr_in *)addr;
    … …  
    202189                        ID cepid = new_id(tcp_cepid_table, tcp_cepid_table_count);
    203190                        if (cepid < 0)
    204                                 return -1;
     191                                return -ENOMEM;
    205192
    206193                        fp->socket.buf_size = 512 + 512;
    207194                        fp->socket.buf = id_to_buff(cepid);
    208                         T_TCP_CCEP ccep = { 0, fp->socket.buf, 512, &fp->socket.buf[512], 512, socket_tcp_callback };
     195                        T_TCP_CCEP ccep = { 0, fp->socket.buf, 512, &fp->socket.buf[512], 512, (FP)socket_tcp_callback };
    209196                        ret = tcp_cre_cep(cepid, &ccep);
    210197                        if (ret != E_OK) {
    211198                                delete_id(tcp_cepid_table, tcp_cepid_table_count, cepid);
    212                                 return -1;
     199                                return -ENOMEM;
    213200                        }
    214201                        fp->handle = cepid;
    … …  
    219206                        ID cepid = new_id(udp_cepid_table, udp_cepid_table_count);
    220207                        if (cepid < 0)
    221                                 return -1;
    222 
    223                         T_UDP_CCEP ccep = { 0, {ntohl(addr_in->sin_addr.s_addr), ntohs(addr_in->sin_port)}, socket_udp_callback };
     208                                return -ENOMEM;
     209
     210                        T_UDP_CCEP ccep = { 0, {ntohl(addr_in->sin_addr.s_addr), ntohs(addr_in->sin_port)}, (FP)socket_udp_callback };
    224211                        ret = udp_cre_cep(cepid, &ccep);
    225212                        if (ret != E_OK) {
    226213                                delete_id(udp_cepid_table, udp_cepid_table_count, cepid);
    227                                 return -1;
     214                                return -ENOMEM;
    228215                        }
    229216                        fp->handle = cepid;
    … …  
    232219                }
    233220                default:
    234                         return -1;
     221                        return -ENOPROTOOPT;
    235222                }
    236223                break;
    … …  
    238225        case AF_INET6: {
    239226                if (len < 20) {
    240                         return -1;
     227                        return -EINVAL;
    241228                }
    242229                memcpy(&fp->socket.laddr4, addr, len);
    … …  
    248235}
    249236
    250 int listen(int fd, int backlog)
     237int shell_listen(int fd, int backlog)
    251238{
    252239        SOCKET *fp = fd_to_fp(fd);
    253         if ((fp == NULL) || (fp->socket.type != SOCK_STREAM)) {
    254                 return -1;
    255         }
     240        if (fp == NULL)
     241                return -EBADF;
     242        if (fp->socket.type != SOCK_STREAM)
     243                return -EINVAL;
    256244
    257245        fp->socket.backlog = backlog;
    … …  
    262250                ID repid = new_id(tcp_repid_table, tcp_repid_table_count);
    263251                if (repid < 0)
    264                         return -1;
     252                        return -ENOMEM;
    265253
    266254                struct sockaddr_in *laddr = &fp->socket.laddr4;
    … …  
    269257                if (ret != E_OK) {
    270258                        delete_id(tcp_repid_table, tcp_repid_table_count, repid);
    271                         return -1;
     259                        return -ENOMEM;
    272260                }
    273261                fp->socket.repid = repid;
    … …  
    282270}
    283271
    284 int connect(int fd, const struct sockaddr *addr, socklen_t len)
     272int shell_connect(int fd, const struct sockaddr *addr, socklen_t len)
    285273{
    286274        SOCKET *fp = fd_to_fp(fd);
    287         if ((fp == NULL) || (fp->socket.type != SOCK_STREAM)) {
    288                 return -1;
    289         }
     275        if (fp == NULL)
     276                return -EBADF;
     277        if (fp->socket.type != SOCK_STREAM)
     278                return -EINVAL;
    290279
    291280        ER ret;
    … …  
    293282        case AF_INET: {
    294283                if (len < 8) {
    295                         return -1;
     284                        return -EINVAL;
    296285                }
    297286                if (fp->socket.cepid == 0) {
    298287                        ID cepid = new_id(tcp_cepid_table, tcp_cepid_table_count);
    299288                        if (cepid < 0)
    300                                 return -1;
     289                                return -ENOMEM;
    301290
    302291                        fp->socket.buf_size = 512 + 512;
    303292                        fp->socket.buf = id_to_buff(cepid);
    304                         T_TCP_CCEP ccep = { 0, fp->socket.buf, 512, &fp->socket.buf[512], 512, socket_tcp_callback };
     293                        T_TCP_CCEP ccep = { 0, fp->socket.buf, 512, &fp->socket.buf[512], 512, (FP)socket_tcp_callback };
    305294                        ret = tcp_cre_cep(cepid, &ccep);
    306295                        if (ret != E_OK) {
    307296                                delete_id(tcp_cepid_table, tcp_cepid_table_count, cepid);
    308                                 return -1;
     297                                return -ENOMEM;
    309298                        }
    310299                        fp->handle = cepid;
    … …  
    317306                T_IPV4EP lep = { ntohl(laddr->sin_addr.s_addr), ntohs(laddr->sin_port) };
    318307                T_IPV4EP rep = { ntohl(raddr->sin_addr.s_addr), ntohs(raddr->sin_port) };
    319                 ret = tcp_con_cep(fp->socket.cepid, &lep, &rep, TMO_FEVR);
     308                ret = tcp_con_cep(fp->socket.cepid, &lep, &rep, SOCKET_TIMEOUT);
    320309                if (ret < 0) {
    321                         return -1;
     310                        return -EHOSTUNREACH;
    322311                }
    323312                break;
    … …  
    331320}
    332321
    333 int accept(int fd, struct sockaddr *addr, socklen_t *len)
     322int shell_accept(int fd, struct sockaddr *__restrict addr, socklen_t *__restrict len)
    334323{
    335324        SOCKET *lfp = fd_to_fp(fd);
    336         if ((lfp == NULL) || (lfp->socket.type != SOCK_STREAM)) {
    337                 return -1;
    338         }
     325        if (lfp == NULL)
     326                return -EBADF;
     327        if (lfp->socket.type != SOCK_STREAM)
     328                return -EINVAL;
    339329
    340330        SOCKET *fp = new_tcp_fd(0);
    341331        if (fp == NULL) {
    342                 return -1;
     332                return -ENOMEM;
    343333        }
    344334
    … …  
    352342                        cepid = new_id(tcp_cepid_table, tcp_cepid_table_count);
    353343                        if (cepid < 0)
    354                                 return -1;
     344                                return -ENOMEM;
    355345
    356346                        fp->socket.buf_size = 512 + 512;
    357347                        fp->socket.buf = id_to_buff(cepid);
    358                         T_TCP_CCEP ccep = { 0, fp->socket.buf, 512, &fp->socket.buf[512], 512, socket_tcp_callback };
     348                        T_TCP_CCEP ccep = { 0, fp->socket.buf, 512, &fp->socket.buf[512], 512, (FP)socket_tcp_callback };
    359349                        ret = tcp_cre_cep(cepid, &ccep);
    360350                        if (ret != E_OK) {
    361351                                delete_id(tcp_cepid_table, tcp_cepid_table_count, cepid);
    362                                 return -1;
     352                                return -ENOMEM;
    363353                        }
    364354                        fp->handle = cepid;
    … …  
    375365                ret = tcp_acp_cep(fp->socket.cepid, fp->socket.repid, &rep, TMO_FEVR);
    376366                if (ret < 0) {
    377                         return -1;
     367                        return -ENOMEM;
    378368                }
    379369                struct sockaddr_in *raddr = &fp->socket.raddr4;
    … …  
    385375        }
    386376        case AF_INET6: {
    387                 break;
     377                return -EAFNOSUPPORT;
    388378        }
    389379        }
    … …  
    392382                int sz = *len;
    393383                if (sz < 8) {
    394                         return -1;
     384                        return -EINVAL;
    395385                }
    396386                struct sockaddr_in *raddr = &fp->socket.raddr4;
    … …  
    404394}
    405395
    406 ssize_t send(int fd, const void *buf, size_t len, int flags)
     396ssize_t shell_send(int fd, const void *buf, size_t len, int flags)
    407397{
    408398        SOCKET *fp = fd_to_fp(fd);
    409399        if (fp == NULL) {
    410                 return -1;
     400                return -EBADF;
    411401        }
    412402
    … …  
    417407                case SOCK_STREAM: {
    418408                        if (flags & MSG_OOB) {
    419                                 ret = tcp_snd_oob(fp->socket.cepid, (void *)buf, len, TMO_FEVR);
     409                                ret = tcp_snd_oob(fp->socket.cepid, (void *)buf, len, SOCKET_TIMEOUT);
    420410                                if (ret < 0) {
    421                                         return -1;
     411                                        return -ECOMM;
    422412                                }
    423413                        }
    424414                        else {
    425                                 ret = tcp_snd_dat(fp->socket.cepid, (void *)buf, len, TMO_FEVR);
     415                                ret = tcp_snd_dat(fp->socket.cepid, (void *)buf, len, SOCKET_TIMEOUT);
    426416                                if (ret < 0) {
    427                                         return -1;
     417                                        return -ECOMM;
    428418                                }
    429419                        }
    … …  
    431421                }
    432422                case SOCK_DGRAM: {
    433                         return -1;
    434                 }
    435                 }
    436                 break;
    437         }
    438         case AF_INET6: {
    439                 break;
     423                        return -EINVAL;
     424                }
     425                }
     426                break;
     427        }
     428        case AF_INET6: {
     429                return -EAFNOSUPPORT;
    440430        }
    441431        }
    … …  
    444434}
    445435
    446 ssize_t sendto(int fd, const void *buf, size_t len, int flags, const struct sockaddr *addr, socklen_t alen)
     436ssize_t shell_sendto(int fd, const void *buf, size_t len, int flags, const struct sockaddr *addr, socklen_t alen)
    447437{
    448438        SOCKET *fp = fd_to_fp(fd);
    449439        if (fp == NULL) {
    450                 return -1;
     440                return -EBADF;
    451441        }
    452442
    … …  
    457447                case SOCK_STREAM: {
    458448                        if ((addr != NULL) && (alen != 0)) {
    459                                 return -1;
     449                                return -EINVAL;
    460450                        }
    461451
    462452                        if (flags & MSG_OOB) {
    463                                 ret = tcp_snd_oob(fp->socket.cepid, (void *)buf, len, TMO_FEVR);
     453                                ret = tcp_snd_oob(fp->socket.cepid, (void *)buf, len, SOCKET_TIMEOUT);
    464454                                if (ret < 0) {
    465                                         return -1;
     455                                        return -ECOMM;
    466456                                }
    467457                        }
    468458                        else {
    469                                 ret = tcp_snd_dat(fp->socket.cepid, (void *)buf, len, TMO_FEVR);
     459                                ret = tcp_snd_dat(fp->socket.cepid, (void *)buf, len, SOCKET_TIMEOUT);
    470460                                if (ret < 0) {
    471                                         return -1;
     461                                        return -ECOMM;
    472462                                }
    473463                        }
    … …  
    477467                        int sz = alen;
    478468                        if (sz < 8) {
    479                                 return -1;
     469                                return -EINVAL;
    480470                        }
    481471                        struct sockaddr_in *raddr = &fp->socket.raddr4;
    … …  
    483473                        memcpy(raddr, addr, sz);
    484474                        T_IPV4EP rep = { ntohl(raddr->sin_addr.s_addr), ntohs(raddr->sin_port) };
    485                         ret = udp_snd_dat(fp->socket.cepid, &rep, (void *)buf, len, TMO_FEVR);
     475                        ret = udp_snd_dat(fp->socket.cepid, &rep, (void *)buf, len,
     476                                (fp->socket.flags & O_NONBLOCK) ? 0 : SOCKET_TIMEOUT);
    486477                        if (ret < 0) {
    487                                 return -1;
    488                         }
    489                         break;
    490                 }
    491                 }
    492                 break;
    493         }
    494         case AF_INET6: {
    495                 break;
     478                                return -ECOMM;
     479                        }
     480                        break;
     481                }
     482                }
     483                break;
     484        }
     485        case AF_INET6: {
     486                return -EAFNOSUPPORT;
    496487        }
    497488        }
    … …  
    500491}
    501492
    502 ssize_t recv(int fd, void *buf, size_t len, int flags)
     493ssize_t shell_sendmsg(int fd, const struct msghdr *msg, int flags)
     494{
     495        no_implement("sendmsg\n");
     496        return -ENOSYS;
     497}
     498
     499ssize_t shell_recv(int fd, void *buf, size_t len, int flags)
    503500{
    504501        SOCKET *fp = fd_to_fp(fd);
    505502        if (fp == NULL) {
    506                 return -1;
     503                return -EBADF;
    507504        }
    508505
    … …  
    515512                                ret = tcp_rcv_oob(fp->socket.cepid, buf, len);
    516513                                if (ret < 0) {
    517                                         return -1;
     514                                        return -ECOMM;
    518515                                }
    519516                        }
    … …  
    521518                                ret = tcp_rcv_dat(fp->socket.cepid, buf, len, TMO_FEVR);
    522519                                if (ret < 0) {
    523                                         return -1;
     520                                        return -ECOMM;
    524521                                }
    525522                        }
    … …  
    528525                case SOCK_DGRAM: {
    529526                        T_IPV4EP rep = { 0, 0 };
    530                         ret = udp_rcv_dat(fp->socket.cepid, &rep, buf, len, TMO_FEVR);
     527                        ret = udp_rcv_dat(fp->socket.cepid, &rep, buf, len, (fp->socket.flags & O_NONBLOCK) ? 0 : TMO_FEVR);
    531528                        if (ret < 0) {
    532                                 return -1;
    533                         }
    534                 }
    535                 }
    536                 break;
    537         }
    538         case AF_INET6: {
    539                 break;
     529                                return -ECOMM;
     530                        }
     531                }
     532                }
     533                break;
     534        }
     535        case AF_INET6: {
     536                return -EAFNOSUPPORT;
    540537        }
    541538        }
    … …  
    544541}
    545542
    546 ssize_t recvfrom(int fd, void *buf, size_t len, int flags, struct sockaddr *addr, socklen_t *alen)
     543ssize_t shell_recvfrom(int fd, void *buf, size_t len, int flags, struct sockaddr *__restrict addr, socklen_t *__restrict alen)
    547544{
    548545        SOCKET *fp = fd_to_fp(fd);
    549546        if (fp == NULL) {
    550                 return -1;
     547                return -EBADF;
    551548        }
    552549
    … …  
    559556                                ret = tcp_rcv_oob(fp->socket.cepid, buf, len);
    560557                                if (ret < 0) {
    561                                         return -1;
     558                                        return -ECOMM;
    562559                                }
    563560                        }
    … …  
    565562                                ret = tcp_rcv_dat(fp->socket.cepid, buf, len, TMO_FEVR);
    566563                                if (ret < 0) {
    567                                         return -1;
     564                                        return -ECOMM;
    568565                                }
    569566                        }
    … …  
    574571                        ret = udp_rcv_dat(fp->socket.cepid, &rep, buf, len, TMO_FEVR);
    575572                        if (ret < 0) {
    576                                 return -1;
     573                                return -ECOMM;
    577574                        }
    578575                        int sz = *alen;
    … …  
    590587        }
    591588        case AF_INET6: {
    592                 break;
     589                return -EAFNOSUPPORT;
    593590        }
    594591        }
    … …  
    597594}
    598595
    599 int shutdown(int fd, int how)
     596ssize_t shell_recvmsg(int fd, struct msghdr *msg, int flags)
     597{
     598        no_implement("recvmsg\n");
     599        return -ENOSYS;
     600}
     601
     602int shell_shutdown(int fd, int how)
    600603{
    601604        SOCKET *fp = fd_to_fp(fd);
    602605        if (fp == NULL) {
    603                 return -1;
     606                return -EBADF;
    604607        }
    605608
    … …  
    611614                        ret = tcp_sht_cep(fp->socket.cepid);
    612615                        if (ret < 0) {
    613                                 return -1;
    614                         }
    615                         break;
    616                 }
    617                 }
    618                 break;
    619         }
    620         case AF_INET6: {
    621                 break;
     616                                return -ECOMM;
     617                        }
     618                        break;
     619                }
     620                }
     621                break;
     622        }
     623        case AF_INET6: {
     624                return -EAFNOSUPPORT;
    622625        }
    623626        }
    … …  
    626629}
    627630
    628 int getsockopt(int fd, int level, int optname, void *optval, socklen_t *optlen)
     631int shell_getsockopt(int fd, int level, int optname, void *optval, socklen_t *__restrict optlen)
    629632{
    630633        SOCKET *fp = fd_to_fp(fd);
    631634        if (fp == NULL) {
    632                 return -1;
     635                return -EBADF;
    633636        }
    634637
    … …  
    650653                                ret = tcp_get_opt(fp->socket.cepid, optname, (void *)optval, *optlen);
    651654                                if (ret < 0) {
    652                                         return -1;
     655                                        return -EINVAL;
    653656                                }
    654657                                *optlen = ret;
    … …  
    660663                        ret = udp_get_opt(fp->socket.cepid, optname, (void *)optval, *optlen);
    661664                        if (ret < 0) {
    662                                 return -1;
     665                                return -EINVAL;
    663666                        }
    664667                        *optlen = ret;
    … …  
    669672        }
    670673        case AF_INET6: {
    671                 break;
     674                return -EAFNOSUPPORT;
    672675        }
    673676        }
    … …  
    676679}
    677680
    678 int setsockopt(int fd, int level, int optname, const void *optval, socklen_t optlen)
     681int shell_setsockopt(int fd, int level, int optname, const void *optval, socklen_t optlen)
    679682{
    680683        SOCKET *fp = fd_to_fp(fd);
    681684        if (fp == NULL) {
    682                 return -1;
     685                return -EBADF;
    683686        }
    684687
    … …  
    700703                                ret = tcp_set_opt(fp->socket.cepid, optname, (void *)optval, optlen);
    701704                                if (ret < 0) {
    702                                         return -1;
     705                                        return -EINVAL;
    703706                                }
    704707                                break;
    … …  
    709712                        ret = udp_set_opt(fp->socket.cepid, optname, (void *)optval, optlen);
    710713                        if (ret < 0) {
    711                                 return -1;
    712                         }
    713                         break;
    714                 }
    715                 }
    716                 break;
    717         }
    718         case AF_INET6: {
    719                 break;
     714                                return -EINVAL;
     715                        }
     716                        break;
     717                }
     718                }
     719                break;
     720        }
     721        case AF_INET6: {
     722                return -EAFNOSUPPORT;
    720723        }
    721724        }
    … …  
    735738                                //return -1;
    736739                        }
    737                         ret = tcp_cls_cep(cepid, TMO_FEVR);
     740                        ret = tcp_cls_cep(cepid, (fp->socket.repid != 0) ? 0 : SOCKET_TIMEOUT);
    738741                        if (ret < 0) {
    739742                                //return -1;
    … …  
    743746                        delete_id(tcp_cepid_table, tcp_cepid_table_count, cepid);
    744747                        if (ret < 0) {
    745                                 return -1;
     748                                return -EINVAL;
    746749                        }
    747750                }
    … …  
    752755                        delete_id(tcp_repid_table, tcp_repid_table_count, repid);
    753756                        if (ret < 0) {
    754                                 return -1;
     757                                return -EINVAL;
    755758                        }
    756759                }
    757760                else {
    758                         return -1;
    759                 }
    760                 break;
    761         }
    762         case AF_INET6: {
    763                 break;
     761                        return -EINVAL;
     762                }
     763                break;
     764        }
     765        case AF_INET6: {
     766                return -EAFNOSUPPORT;
    764767        }
    765768        }
    … …  
    770773size_t tcp_fd_read(struct _IO_FILE *fp, unsigned char *dst, size_t dstsz)
    771774{
    772         return recv(fp->fd, dst, dstsz, 0);
     775        return shell_recv(fp->fd, dst, dstsz, 0);
    773776}
    774777
    775778size_t tcp_fd_write(struct _IO_FILE *fp, const unsigned char *src, size_t srcsz)
    776779{
    777         return send(fp->fd, src, srcsz, 0);
     780        return shell_send(fp->fd, src, srcsz, 0);
    778781}
    779782
    780783off_t tcp_fd_seek(struct _IO_FILE *fp, off_t ofs, int org)
    781784{
    782         return -1;
     785        return -EPERM;
     786}
     787
     788int tcp_fd_ioctl(struct _IO_FILE *fp, int req, void *arg)
     789{
     790        return -EINVAL;
    783791}
    784792
    … …  
    794802                delete_id(udp_cepid_table, udp_cepid_table_count, cepid);
    795803                if (ret < 0) {
    796                         return -1;
    797                 }
    798                 break;
    799         }
    800         case AF_INET6: {
    801                 break;
     804                        return -EINVAL;
     805                }
     806                break;
     807        }
     808        case AF_INET6: {
     809                return -EAFNOSUPPORT;
    802810        }
    803811        }
    … …  
    808816size_t udp_fd_read(struct _IO_FILE *fp, unsigned char *dst, size_t dstsz)
    809817{
    810         return recv(fp->fd, dst, dstsz, 0);
     818        return shell_recv(fp->fd, dst, dstsz, 0);
    811819}
    812820
    813821size_t udp_fd_write(struct _IO_FILE *fp, const unsigned char *src, size_t srcsz)
    814822{
    815         return send(fp->fd, src, srcsz, 0);
     823        return shell_send(fp->fd, src, srcsz, 0);
    816824}
    817825
    818826off_t udp_fd_seek(struct _IO_FILE *fp, off_t ofs, int org)
    819827{
    820         return -1;
     828        return -EPERM;
     829}
     830
     831int udp_fd_ioctl(struct _IO_FILE *fp, int req, void *arg)
     832{
     833        return -EINVAL;
    821834}
    822835
Note: See TracChangeset for help on using the changeset viewer.