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

Location:
EcnlProtoTool/trunk/mrbgems
Files:
109 added
16 edited

Legend:

Unmodified
Added
Removed

  • EcnlProtoTool/trunk/mrbgems/mruby-dir/src/dir.c

    r321 r331  
    1111#include "error.h"
    1212#include <sys/types.h>
    13 #if (defined(_WIN32) || defined(_WIN64)) && !defined(MUSL_LIBC)
     13#if defined(_WIN32) || defined(_WIN64)
    1414  #define MAXPATHLEN 1024
    1515 #if !defined(PATH_MAX)
    … …  
    2323  #define mkdir _mkdir
    2424  #define chdir _chdir
    25 #elif defined(__NEWLIB__)
    26   #include <sys/param.h>
    27   #include "_dirent.h"
    28   #include <unistd.h>
    2925#else
    3026  #include <sys/param.h>
    … …  
    161157  mrb_get_args(mrb, "S|i", &spath, &mode);
    162158  path = mrb_str_to_cstr(mrb, spath);
    163 #if (!defined(_WIN32) && !defined(_WIN64)) || defined(MUSL_LIBC)
     159#ifndef _WIN32
    164160  if (mkdir(path, mode) == -1) {
    165161#else

  • EcnlProtoTool/trunk/mrbgems/mruby-io/README.md

    r279 r331  
    11mruby-io
    22========
     3[![Build Status](https://travis-ci.org/iij/mruby-io.svg?branch=master)](https://travis-ci.org/iij/mruby-io)
    34
    4 IO, File module for mruby
     5
     6`IO` and `File` classes for mruby
    57
    68## Installation
    … …  
    6365| IO#internal_encoding       |          |      |
    6466| IO#ioctl                   |          |      |
    65 | IO#isatty, IO#tty?         |          |      |
     67| IO#isatty, IO#tty?         |    o     |      |
    6668| IO#lineno                  |          |      |
    6769| IO#lineno=                 |          |      |
    … …  
    107109| File.blockdev?              |          | FileTest |
    108110| File.chardev?               |          | FileTest |
    109 | File.chmod                  |          |      |
     111| File.chmod                  |   o      |      |
    110112| File.chown                  |          |      |
    111113| File.ctime                  |          |      |
    … …  
    135137| File.readable?              |          | FileTest |
    136138| File.readable_real?         |          | FileTest |
    137 | File.readlink               |          |      |
     139| File.readlink               |   o      |      |
    138140| File.realdirpath            |          |      |
    139141| File.realpath               |   o      |      |

  • EcnlProtoTool/trunk/mrbgems/mruby-io/mrblib/io.rb

    r321 r331  
    124124    str = string.is_a?(String) ? string : string.to_s
    125125    return str.size unless str.size > 0
    126 
     126    if 0 < @buf.length
     127      # reset real pos ignore buf
     128      seek(pos, SEEK_SET)
     129    end
    127130    len = syswrite(str)
    128     if len != -1
    129       @pos += len
    130       return len
    131     end
    132 
    133     raise IOError
     131    len
    134132  end
    135133
    … …  
    152150  def pos
    153151    raise IOError if closed?
    154     @pos
     152    sysseek(0, SEEK_CUR) - @buf.length
    155153  end
    156154  alias_method :tell, :pos
    … …  
    166164  def seek(i, whence = SEEK_SET)
    167165    raise IOError if closed?
    168     @pos = sysseek(i, whence)
     166    sysseek(i, whence)
    169167    @buf = ''
    170168    0
    … …  
    178176  def ungetc(substr)
    179177    raise TypeError.new "expect String, got #{substr.class}" unless substr.is_a?(String)
    180     @pos -= substr.size
    181178    if @buf.empty?
    182179      @buf = substr.dup
    … …  
    187184  end
    188185
    189   def read(length = nil)
     186  def read(length = nil, outbuf = "")
    190187    unless length.nil?
    191188      unless length.is_a? Fixnum
    … …  
    201198
    202199    array = []
    203     start_pos = @pos
    204200    while 1
    205201      begin
    206202        _read_buf
    207       rescue EOFError => e
     203      rescue EOFError
    208204        array = nil if array.empty? and (not length.nil?) and length != 0
    209205        break
    210206      end
    211207
    212       if length && (@pos - start_pos + @buf.size) >= length
    213         len = length - (@pos - start_pos)
    214         array.push @buf[0, len]
    215         @pos += len
    216         @buf = @buf[len, @buf.size - len]
    217         break
     208      if length
     209        consume = (length <= @buf.size) ? length : @buf.size
     210        array.push @buf[0, consume]
     211        @buf = @buf[consume, @buf.size - consume]
     212        length -= consume
     213        break if length == 0
    218214      else
    219215        array.push @buf
    220         @pos += @buf.size
    221216        @buf = ''
    222217      end
    223218    end
    224219
    225     array && array.join
     220    if array.nil?
     221      outbuf.replace("")
     222      nil
     223    else
     224      outbuf.replace(array.join)
     225    end
    226226  end
    227227
    … …  
    246246
    247247    array = []
    248     start_pos = @pos
    249248    while 1
    250249      begin
    251250        _read_buf
    252       rescue EOFError => e
     251      rescue EOFError
    253252        array = nil if array.empty?
    254253        break
    255254      end
    256255
    257       if limit && (@pos - start_pos + @buf.size) >= limit
    258         len = limit - (@pos - start_pos)
    259         array.push @buf[0, len]
    260         @pos += len
    261         @buf = @buf[len, @buf.size - len]
     256      if limit && limit <= @buf.size
     257        array.push @buf[0, limit]
     258        @buf = @buf[limit, @buf.size - limit]
    262259        break
    263260      elsif idx = @buf.index(rs)
    264261        len = idx + rs.size
    265262        array.push @buf[0, len]
    266         @pos += len
    267263        @buf = @buf[len, @buf.size - len]
    268264        break
    269265      else
    270266        array.push @buf
    271         @pos += @buf.size
    272267        @buf = ''
    273268      end
    … …  
    282277    begin
    283278      readline(*args)
    284     rescue EOFError => e
     279    rescue EOFError
    285280      nil
    286281    end
    … …  
    291286    c = @buf[0]
    292287    @buf = @buf[1, @buf.size]
    293     @pos += 1
    294288    c
    295289  end
    … …  
    298292    begin
    299293      readchar
    300     rescue EOFError => e
     294    rescue EOFError
    301295      nil
    302296    end

  • EcnlProtoTool/trunk/mrbgems/mruby-io/src/file.c

    r321 r331  
    4646  #include <pwd.h>
    4747#endif
    48 #if defined(__NEWLIB__)
    49   #define _MAX_DIR              253
    50   #define _MAX_DRIVE    2
    51   #define PATH_MAX              (_MAX_DRIVE + _MAX_DIR)
    52   #define MAXPATHLEN    (_MAX_DRIVE + _MAX_DIR)
    53 #endif
    5448
    5549#define FILE_SEPARATOR "/"
    … …  
    8175mrb_file_s_umask(mrb_state *mrb, mrb_value klass)
    8276{
    83 #if defined(_WIN32) || defined(_WIN64) || defined(__NEWLIB__)
     77#if defined(_WIN32) || defined(_WIN64)
    8478  /* nothing to do on windows */
    8579  return mrb_fixnum_value(0);
    … …  
    126120  dst = mrb_string_value_cstr(mrb, &to);
    127121  if (rename(src, dst) < 0) {
     122#if defined(_WIN32) || defined(_WIN64)
    128123    if (CHMOD(dst, 0666) == 0 && UNLINK(dst) == 0 && rename(src, dst) == 0) {
    129124      return mrb_fixnum_value(0);
    130125    }
     126#endif
    131127    mrb_sys_fail(mrb, mrb_str_to_cstr(mrb, mrb_format(mrb, "(%S, %S)", from, to)));
    132128  }
    … …  
    253249mrb_file__gethome(mrb_state *mrb, mrb_value klass)
    254250{
    255 #if !defined(_WIN32) && !defined(_WIN64) && !defined(__NEWLIB__)
     251#ifndef _WIN32
    256252  mrb_value username;
    257253  int argc;
    … …  
    288284mrb_file_flock(mrb_state *mrb, mrb_value self)
    289285{
    290 #if defined(_WIN32) || defined(_WIN64) || defined(sun) || defined(__NEWLIB__)
     286#if defined(_WIN32) || defined(_WIN64) || defined(sun)
    291287  mrb_raise(mrb, E_NOTIMP_ERROR, "flock is not supported on Illumos/Solaris/Windows");
    292288#else
    … …  
    322318mrb_file_s_symlink(mrb_state *mrb, mrb_value klass)
    323319{
    324 #if defined(_WIN32) || defined(_WIN64) || defined(__NEWLIB__)
     320#if defined(_WIN32) || defined(_WIN64)
    325321  mrb_raise(mrb, E_NOTIMP_ERROR, "symlink is not supported on this platform");
    326322#else
    … …  
    362358static mrb_value
    363359mrb_file_s_readlink(mrb_state *mrb, mrb_value klass) {
    364 #if defined(_WIN32) || defined(_WIN64) || defined(__NEWLIB__)
     360#if defined(_WIN32) || defined(_WIN64)
    365361  mrb_raise(mrb, E_NOTIMP_ERROR, "readlink is not supported on this platform");
    366362  return mrb_nil_value(); // unreachable

  • EcnlProtoTool/trunk/mrbgems/mruby-io/src/file_test.c

    r321 r331  
    2222  #include <winsock.h>
    2323#else
    24   //#define LSTAT lstat
    25   #define LSTAT stat
     24  #define LSTAT lstat
    2625  #include <sys/file.h>
    2726  #include <sys/param.h>

  • EcnlProtoTool/trunk/mrbgems/mruby-io/src/io.c

    r321 r331  
    190190}
    191191
    192 #if !defined(_WIN32) && !defined(_WIN64) && !defined(__NEWLIB__)
     192#ifndef _WIN32
    193193static int
    194194mrb_cloexec_pipe(mrb_state *mrb, int fildes[2])
    … …  
    265265#endif
    266266
    267 #if !defined(_WIN32) && !defined(_WIN64) && !defined(__NEWLIB__)
     267#ifndef _WIN32
    268268static int
    269269option_to_fd(mrb_state *mrb, mrb_value obj, const char *key)
    … …  
    390390
    391391      mrb_iv_set(mrb, io, mrb_intern_cstr(mrb, "@buf"), mrb_str_new_cstr(mrb, ""));
    392       mrb_iv_set(mrb, io, mrb_intern_cstr(mrb, "@pos"), mrb_fixnum_value(0));
    393392
    394393      fptr = mrb_io_alloc(mrb);
    … …  
    444443
    445444  mrb_iv_set(mrb, io, mrb_intern_cstr(mrb, "@buf"), mrb_str_new_cstr(mrb, ""));
    446   mrb_iv_set(mrb, io, mrb_intern_cstr(mrb, "@pos"), mrb_fixnum_value(0));
    447445
    448446  fptr = (struct mrb_io *)DATA_PTR(io);
    … …  
    488486  }
    489487
    490 #if !defined(_WIN32) && !defined(_WIN64) && !defined(__NEWLIB__)
     488#if !defined(_WIN32) && !defined(_WIN64)
    491489  if (fptr->pid != 0) {
    492490    pid_t pid;
    … …  
    557555mrb_cloexec_open(mrb_state *mrb, const char *pathname, mrb_int flags, mrb_int mode)
    558556{
     557  mrb_value emsg;
    559558  int fd, retry = FALSE;
    560559
    … …  
    577576      }
    578577    }
    579     mrb_sys_fail(mrb, "open");
     578
     579    emsg = mrb_format(mrb, "open %S", mrb_str_new_cstr(mrb, pathname));
     580    mrb_str_modify(mrb, mrb_str_ptr(emsg));
     581    mrb_sys_fail(mrb, RSTRING_PTR(emsg));
    580582  }
    581583
    … …  
    620622  mrb_get_args(mrb, "i|S", &maxlen, &buf);
    621623  if (maxlen < 0) {
    622     return mrb_nil_value();
     624    mrb_raise(mrb, E_ARGUMENT_ERROR, "negative expanding string size");
     625  }
     626  else if (maxlen == 0) {
     627    return mrb_str_new(mrb, NULL, maxlen);
    623628  }
    624629
    … …  
    626631    buf = mrb_str_new(mrb, NULL, maxlen);
    627632  }
     633
    628634  if (RSTRING_LEN(buf) != maxlen) {
    629635    buf = mrb_str_resize(mrb, buf, maxlen);
    630   }
    631 
    632   fptr = (struct mrb_io *)mrb_get_datatype(mrb, io, &mrb_io_type);
     636  } else {
     637    mrb_str_modify(mrb, RSTRING(buf));
     638  }
     639
     640  fptr = (struct mrb_io *)io_get_open_fptr(mrb, io);
     641  if (!fptr->readable) {
     642    mrb_raise(mrb, E_IO_ERROR, "not opened for reading");
     643  }
    633644  ret = read(fptr->fd, RSTRING_PTR(buf), maxlen);
    634645  switch (ret) {
    … …  
    702713  }
    703714  length = write(fd, RSTRING_PTR(buf), RSTRING_LEN(buf));
     715  if (length == -1) {
     716    mrb_sys_fail(mrb, 0);
     717  }
    704718
    705719  return mrb_fixnum_value(length);
    … …  
    773787}
    774788
    775 #if !defined(_WIN32) && !defined(_WIN64) && !defined(__NEWLIB__)
     789#ifndef _WIN32
    776790static mrb_value
    777791mrb_io_s_pipe(mrb_state *mrb, mrb_value klass)
    … …  
    789803  r = mrb_obj_value(mrb_data_object_alloc(mrb, mrb_class_ptr(klass), NULL, &mrb_io_type));
    790804  mrb_iv_set(mrb, r, mrb_intern_cstr(mrb, "@buf"), mrb_str_new_cstr(mrb, ""));
    791   mrb_iv_set(mrb, r, mrb_intern_cstr(mrb, "@pos"), mrb_fixnum_value(0));
    792805  fptr_r = mrb_io_alloc(mrb);
    793806  fptr_r->fd = pipes[0];
    … …  
    800813  w = mrb_obj_value(mrb_data_object_alloc(mrb, mrb_class_ptr(klass), NULL, &mrb_io_type));
    801814  mrb_iv_set(mrb, w, mrb_intern_cstr(mrb, "@buf"), mrb_str_new_cstr(mrb, ""));
    802   mrb_iv_set(mrb, w, mrb_intern_cstr(mrb, "@pos"), mrb_fixnum_value(0));
    803815  fptr_w = mrb_io_alloc(mrb);
    804816  fptr_w->fd = pipes[1];
    … …  
    10721084
    10731085  mrb_include_module(mrb, io, mrb_module_get(mrb, "Enumerable")); /* 15.2.20.3 */
    1074 #if !defined(_WIN32) && !defined(_WIN64) && !defined(__NEWLIB__)
     1086#ifndef _WIN32
    10751087  mrb_define_class_method(mrb, io, "_popen",  mrb_io_s_popen,   MRB_ARGS_ANY());
    10761088  mrb_define_class_method(mrb, io, "_sysclose",  mrb_io_s_sysclose, MRB_ARGS_REQ(1));
    … …  
    10791091  mrb_define_class_method(mrb, io, "select",  mrb_io_s_select,  MRB_ARGS_ANY());
    10801092  mrb_define_class_method(mrb, io, "sysopen", mrb_io_s_sysopen, MRB_ARGS_ANY());
    1081 #if !defined(_WIN32) && !defined(_WIN64) && !defined(__NEWLIB__)
     1093#ifndef _WIN32
    10821094  mrb_define_class_method(mrb, io, "_pipe", mrb_io_s_pipe, MRB_ARGS_NONE());
    10831095#endif

  • EcnlProtoTool/trunk/mrbgems/mruby-io/test/io.rb

    r321 r331  
    141141end
    142142
     143assert "IO#read(n) with n > IO::BUF_SIZE" do
     144  r,w = IO.pipe
     145  n = IO::BUF_SIZE+1
     146  w.write 'a'*n
     147  assert_equal r.read(n), 'a'*n
     148end
     149
    143150assert('IO#readchar', '15.2.20.5.15') do
    144151  # almost same as IO#getc
    … …  
    182189  assert_equal 0, io.write("")
    183190  io.close
     191
     192  io = IO.open(IO.sysopen($mrbtest_io_wfname, "r+"), "r+")
     193  assert_equal 7, io.write("abcdefg")
     194  io.rewind
     195  assert_equal "ab", io.read(2)
     196  assert_equal 3, io.write("123")
     197  io.rewind
     198  assert_equal "ab123fg", io.read
     199  io.close
     200
    184201  true
    185202end
    … …  
    234251    io.sysread(10000)
    235252  end
    236   io.close
    237   io.closed?
     253
     254  assert_raise RuntimeError do
     255    io.sysread(5, "abcde".freeze)
     256  end
     257
     258  io.close
     259  assert_equal "", io.sysread(0)
     260  assert_raise(IOError) { io.sysread(1) }
     261  assert_raise(ArgumentError) { io.sysread(-1) }
     262  io.closed?
     263
     264  fd = IO.sysopen $mrbtest_io_wfname, "w"
     265  io = IO.new fd, "w"
     266  assert_raise(IOError) { io.sysread(1) }
     267  io.close
     268  true
    238269end
    239270

  • EcnlProtoTool/trunk/mrbgems/mruby-onig-regexp/src/mruby_onig_regexp.c

    r321 r331  
    3636#define ONIG_EXTERN extern
    3737#endif
    38 #include "oniguruma.h"
     38#include "onigmo.h"
    3939
    4040#ifdef MRUBY_VERSION
    … …  
    947947  mrb_define_const(mrb, clazz, "NOTBOL", mrb_fixnum_value(ONIG_OPTION_NOTBOL));
    948948  mrb_define_const(mrb, clazz, "NOTEOL", mrb_fixnum_value(ONIG_OPTION_NOTEOL));
    949   mrb_define_const(mrb, clazz, "POSIX_REGION", mrb_fixnum_value(ONIG_OPTION_POSIX_REGION));
    950949#ifdef ONIG_OPTION_ASCII_RANGE
    951950  mrb_define_const(mrb, clazz, "ASCII_RANGE", mrb_fixnum_value(ONIG_OPTION_ASCII_RANGE));

  • EcnlProtoTool/trunk/mrbgems/mruby-pack/README.md

    r279 r331  
    3939 - S : 16-bit unsigned, native endian (`uint16_t`)
    4040 - s : 16-bit signed, native endian (`int16_t`)
     41 - U : UTF-8 character
    4142 - V : 32-bit unsigned, VAX (little-endian) byte order
    4243 - v : 16-bit unsigned, VAX (little-endian) byte order
     44 - x : null byte
    4345 - Z : same as "a", except that null is added with *
     46
    4447
    4548

  • EcnlProtoTool/trunk/mrbgems/mruby-pack/src/pack.c

    r321 r331  
    7878hex2int(unsigned char ch)
    7979{
    80   if (ch >= '0' && ch <= '9') 
     80  if (ch >= '0' && ch <= '9')
    8181    return ch - '0';
    8282  else if (ch >= 'A' && ch <= 'F')
    … …  
    415415  char utf8[4];
    416416  int len;
    417  
    418   unsigned long c = mrb_fixnum(o);
     417  unsigned long c = 0;
     418
     419  if (mrb_float_p(o)) {
     420    goto range_error;
     421  }
     422  c = mrb_fixnum(o);
    419423
    420424  /* Unicode character */
    … …  
    435439    len = 3;
    436440  }
    437   else {
     441  else if (c < 0x200000) {
    438442    utf8[0] = (char)(0xF0 |  (c >> 18)        );
    439443    utf8[1] = (char)(0x80 | ((c >> 12) & 0x3F));
    … …  
    442446    len = 4;
    443447  }
    444  
     448  else {
     449range_error:
     450    mrb_raise(mrb, E_RANGE_ERROR, "pack(U): value out of range");
     451  }
     452
    445453  str = str_len_ensure(mrb, str, sidx + len);
    446454  memcpy(RSTRING_PTR(str) + sidx, utf8, len);
    447  
     455
    448456  return len;
     457}
     458
     459static const unsigned long utf8_limits[] = {
     460  0x0,        /* 1 */
     461  0x80,       /* 2 */
     462  0x800,      /* 3 */
     463  0x10000,    /* 4 */
     464  0x200000,   /* 5 */
     465  0x4000000,  /* 6 */
     466  0x80000000, /* 7 */
     467};
     468
     469static unsigned long
     470utf8_to_uv(mrb_state *mrb, const char *p, long *lenp)
     471{
     472  int c = *p++ & 0xff;
     473  unsigned long uv = c;
     474  long n;
     475
     476  if (!(uv & 0x80)) {
     477    *lenp = 1;
     478    return uv;
     479  }
     480  if (!(uv & 0x40)) {
     481    *lenp = 1;
     482    mrb_raise(mrb, E_ARGUMENT_ERROR, "malformed UTF-8 character");
     483  }
     484
     485  if      (!(uv & 0x20)) { n = 2; uv &= 0x1f; }
     486  else if (!(uv & 0x10)) { n = 3; uv &= 0x0f; }
     487  else if (!(uv & 0x08)) { n = 4; uv &= 0x07; }
     488  else if (!(uv & 0x04)) { n = 5; uv &= 0x03; }
     489  else if (!(uv & 0x02)) { n = 6; uv &= 0x01; }
     490  else {
     491    *lenp = 1;
     492    mrb_raise(mrb, E_ARGUMENT_ERROR, "malformed UTF-8 character");
     493  }
     494  if (n > *lenp) {
     495    mrb_raisef(mrb, E_ARGUMENT_ERROR, "malformed UTF-8 character (expected %S bytes, given %S bytes)",
     496    mrb_fixnum_value(n), mrb_fixnum_value(*lenp));
     497  }
     498  *lenp = n--;
     499  if (n != 0) {
     500    while (n--) {
     501      c = *p++ & 0xff;
     502      if ((c & 0xc0) != 0x80) {
     503        *lenp -= n + 1;
     504        mrb_raisef(mrb, E_ARGUMENT_ERROR, "malformed UTF-8 character");
     505      }
     506      else {
     507        c &= 0x3f;
     508        uv = uv << 6 | c;
     509      }
     510    }
     511  }
     512  n = *lenp - 1;
     513  if (uv < utf8_limits[n]) {
     514    mrb_raisef(mrb, E_ARGUMENT_ERROR, "redundant UTF-8 sequence");
     515  }
     516  return uv;
     517}
     518
     519static int
     520unpack_utf8(mrb_state *mrb, const unsigned char * src, int srclen, mrb_value ary, unsigned int flags)
     521{
     522  unsigned long uv;
     523  long lenp = srclen;
     524
     525  if (srclen == 0) {
     526    return 1;
     527  }
     528  uv = utf8_to_uv(mrb, (const char *)src, &lenp);
     529  mrb_ary_push(mrb, ary, mrb_fixnum_value((mrb_int)uv));
     530  return (int)lenp;
    449531}
    450532
    … …  
    483565    *dptr++ = pad;
    484566  }
    485  
     567
    486568  return dptr - dptr0;
    487569}
    … …  
    542624    slen = count;
    543625  }
    544    
     626
    545627  dst = str_len_ensure(mrb, dst, didx + count);
    546628  dptr = RSTRING_PTR(dst) + didx;
    … …  
    11481230        srcidx += unpack_double(mrb, sptr, srclen - srcidx, result, flags);
    11491231        break;
     1232      case PACK_DIR_UTF8:
     1233        srcidx += unpack_utf8(mrb, sptr, srclen - srcidx, result, flags);
     1234        break;
     1235      default:
     1236        mrb_raise(mrb, E_RUNTIME_ERROR, "mruby-pack's bug");
    11501237      }
    11511238      if (count > 0) {

  • EcnlProtoTool/trunk/mrbgems/mruby-pack/test/pack.rb

    r321 r331  
    146146  assert_pack 'I', str, [12345]
    147147end
     148
     149assert 'pack/unpack "U"' do
     150  assert_equal [], "".unpack("U")
     151  assert_equal [], "".unpack("U*")
     152  assert_equal [65, 66], "ABC".unpack("U2")
     153  assert_equal [12371, 12435, 12395, 12385, 12399, 19990, 30028], "こんにちは世界".unpack("U*")
     154
     155  assert_equal "", [].pack("U")
     156  assert_equal "", [].pack("U*")
     157  assert_equal "AB", [65, 66, 67].pack("U2")
     158  assert_equal "こんにちは世界", [12371, 12435, 12395, 12385, 12399, 19990, 30028].pack("U*")
     159
     160  assert_equal "\000", [0].pack("U")
     161
     162  assert_raise(RangeError) { [-0x40000000].pack("U") }
     163  assert_raise(RangeError) { [-1].pack("U") }
     164  assert_raise(RangeError) { [0x40000000].pack("U") }
     165end

  • EcnlProtoTool/trunk/mrbgems/mruby-socket/README.md

    r279 r331  
    3737Copyright (c) 2013 Internet Initiative Japan Inc.
    3838
    39 Permission is hereby granted, free of charge, to any person obtaining a 
    40 copy of this software and associated documentation files (the "Software"), 
    41 to deal in the Software without restriction, including without limitation 
    42 the rights to use, copy, modify, merge, publish, distribute, sublicense, 
    43 and/or sell copies of the Software, and to permit persons to whom the 
     39Permission is hereby granted, free of charge, to any person obtaining a
     40copy of this software and associated documentation files (the "Software"),
     41to deal in the Software without restriction, including without limitation
     42the rights to use, copy, modify, merge, publish, distribute, sublicense,
     43and/or sell copies of the Software, and to permit persons to whom the
    4444Software is furnished to do so, subject to the following conditions:
    4545
    46 The above copyright notice and this permission notice shall be included in 
     46The above copyright notice and this permission notice shall be included in
    4747all copies or substantial portions of the Software.
    4848
    49 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
    50 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
    51 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
    52 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
    53 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 
    54 FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 
     49THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
     50IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
     51FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
     52AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
     53LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
     54FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
    5555DEALINGS IN THE SOFTWARE.

  • EcnlProtoTool/trunk/mrbgems/mruby-socket/mrbgem.rake

    r321 r331  
    44
    55  spec.cc.include_paths << "#{build.root}/src"
    6  
     6
    77  # If Windows, use winsock
    88  if ( /mswin|mingw|win32/ =~ RUBY_PLATFORM ) then

  • EcnlProtoTool/trunk/mrbgems/mruby-socket/mrblib/socket.rb

    r321 r331  
    155155  end
    156156
    157   def to_sockaddr 
     157  def to_sockaddr
    158158    @sockaddr
    159159  end
    … …  
    234234      s = nil
    235235      e = SocketError
    236       Addrinfo.foreach(host, service) { |ai|
     236      Addrinfo.foreach(host, service, nil, Socket::SOCK_STREAM, Socket::IPPROTO_TCP) do |ai|
    237237        begin
    238238          s = Socket._socket(ai.afamily, Socket::SOCK_STREAM, 0)
    … …  
    245245          Socket._connect(s, ai.to_sockaddr)
    246246          super(s, "r+")
    247           return
     247          e = nil
     248          break
    248249        rescue => e0
    249250          e = e0
    250251        end
    251       }
    252       raise e
     252      end
     253      if e != nil
     254        raise e
     255      end
    253256    end
    254257  end

  • EcnlProtoTool/trunk/mrbgems/mruby-socket/src/const.def

    • Property svn:keywords deleted

  • EcnlProtoTool/trunk/mrbgems/mruby-socket/src/socket.c

    r321 r331  
    44** See Copyright Notice in mruby.h
    55*/
    6 #include <sys/types.h>
    7 #include <sys/socket.h>
    8 #include <sys/un.h>
    9 #include <netinet/in.h>
    10 #include <netinet/tcp.h>
    11 #include <arpa/inet.h>
    12 #include <fcntl.h>
    13 #include <netdb.h>
    14 #include <unistd.h>
     6
     7#ifdef _WIN32
     8  #define _WIN32_WINNT 0x0501
     9
     10  #include <winsock2.h>
     11  #include <ws2tcpip.h>
     12  #include <windows.h>
     13
     14  #define SHUT_RDWR SD_BOTH
     15#else
     16  #include <sys/types.h>
     17  #include <sys/socket.h>
     18  #include <sys/un.h>
     19  #include <netinet/in.h>
     20  #include <netinet/tcp.h>
     21  #include <arpa/inet.h>
     22  #include <fcntl.h>
     23  #include <netdb.h>
     24  #include <unistd.h>
     25#endif
     26
    1527#include <stddef.h>
    1628#include <string.h>
    17 
    18 /*#include <unistd.h>*/
    19 extern int gethostname(char *name, size_t len);
    2029
    2130#include "mruby.h"
    … …  
    2736#include "error.h"
    2837
    29 #ifndef NI_MAXHOST
    30 #define NI_MAXHOST 255
    31 #endif
    32 #ifndef NI_MAXSERV
    33 #define NI_MAXSERV 32
    34 #endif
    3538#define E_SOCKET_ERROR             (mrb_class_get(mrb, "SocketError"))
    3639
    … …  
    4144#endif
    4245
    43 //#ifdef _WIN32
     46#ifdef _WIN32
    4447const char *inet_ntop(int af, const void *src, char *dst, socklen_t cnt)
    4548{
    … …  
    5962        memset(&in, 0, sizeof(in));
    6063        in.sin6_family = AF_INET6;
    61         memcpy(&in.sin6_addr, src, sizeof(struct in6_addr));
     64        memcpy(&in.sin6_addr, src, sizeof(struct in_addr6));
    6265        getnameinfo((struct sockaddr *)&in, sizeof(struct
    6366                    sockaddr_in6), dst, cnt, NULL, 0, NI_NUMERICHOST);
    … …  
    9295}
    9396
    94 //#endif
     97#endif
    9598
    9699static mrb_value
    … …  
    192195}
    193196
     197#ifndef _WIN32
    194198static mrb_value
    195199mrb_addrinfo_unix_path(mrb_state *mrb, mrb_value self)
    … …  
    202206  return mrb_str_new_cstr(mrb, ((struct sockaddr_un *)RSTRING_PTR(sastr))->sun_path);
    203207}
     208#endif
    204209
    205210static mrb_value
    … …  
    256261static mrb_value
    257262mrb_basicsocket_getpeereid(mrb_state *mrb, mrb_value self)
    258 { 
     263{
    259264#ifdef HAVE_GETPEEREID
    260265  mrb_value ary;
    … …  
    262267  uid_t euid;
    263268  int s;
    264  
     269
    265270  s = socket_fd(mrb, self);
    266271  if (getpeereid(s, &euid, &egid) != 0)
    … …  
    279284static mrb_value
    280285mrb_basicsocket_getpeername(mrb_state *mrb, mrb_value self)
    281 { 
     286{
    282287  struct sockaddr_storage ss;
    283288  socklen_t salen;
    284  
     289
    285290  salen = sizeof(ss);
    286291  if (getpeername(socket_fd(mrb, self), (struct sockaddr *)&ss, &salen) != 0)
    … …  
    292297static mrb_value
    293298mrb_basicsocket_getsockname(mrb_state *mrb, mrb_value self)
    294 { 
     299{
    295300  struct sockaddr_storage ss;
    296301  socklen_t salen;
    297  
     302
    298303  salen = sizeof(ss);
    299304  if (getsockname(socket_fd(mrb, self), (struct sockaddr *)&ss, &salen) != 0)
    … …  
    305310static mrb_value
    306311mrb_basicsocket_getsockopt(mrb_state *mrb, mrb_value self)
    307 { 
     312{
    308313  char opt[8];
    309314  int s;
    … …  
    325330static mrb_value
    326331mrb_basicsocket_recv(mrb_state *mrb, mrb_value self)
    327 { 
     332{
    328333  int n;
    329334  mrb_int maxlen, flags = 0;
    … …  
    341346static mrb_value
    342347mrb_basicsocket_recvfrom(mrb_state *mrb, mrb_value self)
    343 { 
     348{
    344349  int n;
    345350  mrb_int maxlen, flags = 0;
    … …  
    364369static mrb_value
    365370mrb_basicsocket_send(mrb_state *mrb, mrb_value self)
    366 { 
     371{
    367372  int n;
    368373  mrb_int flags;
    … …  
    383388static mrb_value
    384389mrb_basicsocket_setnonblock(mrb_state *mrb, mrb_value self)
    385 { 
     390{
    386391  int fd, flags;
    387392  mrb_value bool;
     393#ifdef _WIN32
     394  u_long mode = 1;
     395#endif
    388396
    389397  mrb_get_args(mrb, "o", &bool);
    390398  fd = socket_fd(mrb, self);
     399#ifdef _WIN32
     400  flags = ioctlsocket(fd, FIONBIO, &mode);
     401  if (flags != NO_ERROR)
     402    mrb_sys_fail(mrb, "ioctlsocket");
     403#else
    391404  flags = fcntl(fd, F_GETFL, 0);
    392405  if (flags == 1)
    … …  
    398411  if (fcntl(fd, F_SETFL, flags) == -1)
    399412    mrb_sys_fail(mrb, "fcntl");
     413#endif
    400414  return mrb_nil_value();
    401415}
    … …  
    403417static mrb_value
    404418mrb_basicsocket_setsockopt(mrb_state *mrb, mrb_value self)
    405 { 
     419{
    406420  int argc, s;
    407421  mrb_int level = 0, optname;
    … …  
    420434      optval = mrb_str_new(mrb, (char *)&i, sizeof(i));
    421435    } else if (mrb_fixnum_p(optval)) {
    422       mrb_int i = mrb_fixnum(optval);
    423       optval = mrb_str_new(mrb, (char *)&i, sizeof(i));
     436      if (optname == IP_MULTICAST_TTL || optname == IP_MULTICAST_LOOP) {
     437        char uc = mrb_fixnum(optval);
     438        optval = mrb_str_new(mrb, &uc, sizeof(uc));
     439      } else {
     440        mrb_int i = mrb_fixnum(optval);
     441        optval = mrb_str_new(mrb, (char *)&i, sizeof(i));
     442      }
    424443    } else {
    425444      mrb_raise(mrb, E_ARGUMENT_ERROR, "optval should be true, false, an integer, or a string");
    … …  
    443462static mrb_value
    444463mrb_basicsocket_shutdown(mrb_state *mrb, mrb_value self)
    445 { 
     464{
    446465  mrb_int how = SHUT_RDWR;
    447466
    … …  
    454473static mrb_value
    455474mrb_ipsocket_ntop(mrb_state *mrb, mrb_value klass)
    456 { 
     475{
    457476  mrb_int af, n;
    458477  char *addr, buf[50];
    … …  
    468487static mrb_value
    469488mrb_ipsocket_pton(mrb_state *mrb, mrb_value klass)
    470 { 
     489{
    471490  mrb_int af, n;
    472491  char *bp, buf[50];
    … …  
    498517static mrb_value
    499518mrb_ipsocket_recvfrom(mrb_state *mrb, mrb_value self)
    500 { 
     519{
    501520  struct sockaddr_storage ss;
    502521  socklen_t socklen;
    … …  
    528547  mrb_value buf;
    529548  size_t bufsize;
    530  
     549
    531550#ifdef HOST_NAME_MAX
    532551  bufsize = HOST_NAME_MAX + 1;
    … …  
    568587{
    569588  mrb_value sastr;
    570   int s;
     589  mrb_int s;
    571590
    572591  mrb_get_args(mrb, "iS", &s, &sastr);
    573   if (bind(s, (struct sockaddr *)RSTRING_PTR(sastr), (socklen_t)RSTRING_LEN(sastr)) == -1) {
     592  if (bind((int)s, (struct sockaddr *)RSTRING_PTR(sastr), (socklen_t)RSTRING_LEN(sastr)) == -1) {
    574593    mrb_sys_fail(mrb, "bind");
    575594  }
    … …  
    581600{
    582601  mrb_value sastr;
    583   int s;
     602  mrb_int s;
    584603
    585604  mrb_get_args(mrb, "iS", &s, &sastr);
    586   if (connect(s, (struct sockaddr *)RSTRING_PTR(sastr), (socklen_t)RSTRING_LEN(sastr)) == -1) {
     605  if (connect((int)s, (struct sockaddr *)RSTRING_PTR(sastr), (socklen_t)RSTRING_LEN(sastr)) == -1) {
    587606    mrb_sys_fail(mrb, "connect");
    588607  }
    … …  
    593612mrb_socket_listen(mrb_state *mrb, mrb_value klass)
    594613{
    595   int backlog, s;
     614  mrb_int backlog, s;
    596615
    597616  mrb_get_args(mrb, "ii", &s, &backlog);
    598   if (listen(s, backlog) == -1) {
     617  if (listen((int)s, (int)backlog) == -1) {
    599618    mrb_sys_fail(mrb, "listen");
    600619  }
    … …  
    623642mrb_socket_sockaddr_un(mrb_state *mrb, mrb_value klass)
    624643{
     644#ifdef _WIN32
     645  mrb_raise(mrb, E_NOTIMP_ERROR, "sockaddr_un unsupported on Windows");
     646  return mrb_nil_value();
     647#else
    625648  struct sockaddr_un *sunp;
    626649  mrb_value path, s;
    627  
     650
    628651  mrb_get_args(mrb, "S", &path);
    629652  if (RSTRING_LEN(path) > sizeof(sunp->sun_path) - 1) {
    … …  
    637660  mrb_str_resize(mrb, s, sizeof(struct sockaddr_un));
    638661  return s;
     662#endif
    639663}
    640664
    … …  
    642666mrb_socket_socketpair(mrb_state *mrb, mrb_value klass)
    643667{
     668#ifdef _WIN32
     669  mrb_raise(mrb, E_NOTIMP_ERROR, "socketpair unsupported on Windows");
     670  return mrb_nil_value();
     671#else
    644672  mrb_value ary;
    645673  mrb_int domain, type, protocol;
    … …  
    655683  mrb_ary_push(mrb, ary, mrb_fixnum_value(sv[1]));
    656684  return ary;
     685#endif
    657686}
    658687
    … …  
    686715 * will break on socket descriptors.
    687716 */
     717#ifdef _WIN32
     718static mrb_value
     719mrb_win32_basicsocket_close(mrb_state *mrb, mrb_value self)
     720{
     721  if (closesocket(socket_fd(mrb, self)) != NO_ERROR)
     722    mrb_raise(mrb, E_SOCKET_ERROR, "closesocket unsuccessful");
     723  return mrb_nil_value();
     724}
     725
     726#define E_EOF_ERROR                (mrb_class_get(mrb, "EOFError"))
     727static mrb_value
     728mrb_win32_basicsocket_sysread(mrb_state *mrb, mrb_value self)
     729{
     730  int sd, ret;
     731  mrb_value buf = mrb_nil_value();
     732  mrb_int maxlen;
     733
     734  mrb_get_args(mrb, "i|S", &maxlen, &buf);
     735  if (maxlen < 0) {
     736    return mrb_nil_value();
     737  }
     738
     739  if (mrb_nil_p(buf)) {
     740    buf = mrb_str_new(mrb, NULL, maxlen);
     741  }
     742  if (RSTRING_LEN(buf) != maxlen) {
     743    buf = mrb_str_resize(mrb, buf, maxlen);
     744  }
     745
     746  sd = socket_fd(mrb, self);
     747  ret = recv(sd, RSTRING_PTR(buf), maxlen, 0);
     748
     749  switch (ret) {
     750    case 0: /* EOF */
     751      if (maxlen == 0) {
     752        buf = mrb_str_new_cstr(mrb, "");
     753      } else {
     754        mrb_raise(mrb, E_EOF_ERROR, "sysread failed: End of File");
     755      }
     756      break;
     757    case SOCKET_ERROR: /* Error */
     758      mrb_sys_fail(mrb, "recv");
     759      break;
     760    default:
     761      if (RSTRING_LEN(buf) != ret) {
     762        buf = mrb_str_resize(mrb, buf, ret);
     763      }
     764      break;
     765  }
     766
     767  return buf;
     768}
     769
     770static mrb_value
     771mrb_win32_basicsocket_sysseek(mrb_state *mrb, mrb_value self)
     772{
     773  mrb_raise(mrb, E_NOTIMP_ERROR, "sysseek not implemented for windows sockets");
     774  return mrb_nil_value();
     775}
     776
     777static mrb_value
     778mrb_win32_basicsocket_syswrite(mrb_state *mrb, mrb_value self)
     779{
     780  int n;
     781  SOCKET sd;
     782  mrb_value str;
     783
     784  sd = socket_fd(mrb, self);
     785  mrb_get_args(mrb, "S", &str);
     786  n = send(sd, RSTRING_PTR(str), RSTRING_LEN(str), 0);
     787  if (n == SOCKET_ERROR)
     788    mrb_sys_fail(mrb, "send");
     789  return mrb_fixnum_value(n);
     790}
     791
     792#endif
    688793
    689794void
    … …  
    693798  struct RClass *constants;
    694799
     800#ifdef _WIN32
     801  WSADATA wsaData;
     802  int result;
     803  result = WSAStartup(MAKEWORD(2,2), &wsaData);
     804  if (result != NO_ERROR)
     805    mrb_raise(mrb, E_RUNTIME_ERROR, "WSAStartup failed");
     806#else
    695807  struct RClass *usock;
     808#endif
    696809
    697810  ai = mrb_define_class(mrb, "Addrinfo", mrb->object_class);
    … …  
    699812  mrb_define_class_method(mrb, ai, "getaddrinfo", mrb_addrinfo_getaddrinfo, MRB_ARGS_REQ(2)|MRB_ARGS_OPT(4));
    700813  mrb_define_method(mrb, ai, "getnameinfo", mrb_addrinfo_getnameinfo, MRB_ARGS_OPT(1));
     814#ifndef _WIN32
    701815  mrb_define_method(mrb, ai, "unix_path", mrb_addrinfo_unix_path, MRB_ARGS_NONE());
     816#endif
    702817
    703818  io = mrb_class_get(mrb, "IO");
    … …  
    746861  //mrb_define_method(mrb, sock, "sysaccept", mrb_socket_accept, MRB_ARGS_NONE());
    747862
     863#ifndef _WIN32
    748864  usock = mrb_define_class(mrb, "UNIXSocket", bsock);
     865#endif
    749866  //mrb_define_class_method(mrb, usock, "pair", mrb_unixsocket_open, MRB_ARGS_OPT(2));
    750867  //mrb_define_class_method(mrb, usock, "socketpair", mrb_unixsocket_open, MRB_ARGS_OPT(2));
    … …  
    755872
    756873  /* Windows IO Method Overrides on BasicSocket */
     874#ifdef _WIN32
     875  mrb_define_method(mrb, bsock, "close", mrb_win32_basicsocket_close, MRB_ARGS_NONE());
     876  mrb_define_method(mrb, bsock, "sysread", mrb_win32_basicsocket_sysread, MRB_ARGS_REQ(1)|MRB_ARGS_OPT(1));
     877  mrb_define_method(mrb, bsock, "sysseek", mrb_win32_basicsocket_sysseek, MRB_ARGS_REQ(1));
     878  mrb_define_method(mrb, bsock, "syswrite", mrb_win32_basicsocket_syswrite, MRB_ARGS_REQ(1));
     879#endif
    757880
    758881  constants = mrb_define_module_under(mrb, sock, "Constants");
    … …  
    774897    freeaddrinfo(mrb_cptr(ai));
    775898  }
    776 }
     899#ifdef _WIN32
     900  WSACleanup();
     901#endif
     902}
Note: See TracChangeset for help on using the changeset viewer.