Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.jruby.util.io;
  
  import org.jruby.Ruby;
 
 import java.io.File;
 
 public class Sockaddr {
 
     public static InetAddress addressFromString(Ruby runtimeString s) {
         try {
             byte[] bs = ByteList.plain(s);
             return InetAddress.getByAddress(bs);
         } catch(Exception e) {
             throw sockerr(runtime"strtoaddr: " + e.toString());
         }
     }
 
     public static String stringFromAddress(Ruby runtimeInetAddress as) {
         try {
             return new String(ByteList.plain(as.getAddress()));
         } catch(Exception e) {
             throw sockerr(runtime"addrtostr: " + e.toString());
         }
     }
 
     public static InetSocketAddress addressFromSockaddr_in(ThreadContext contextIRubyObject arg) {
         RubyArray sockaddr = (RubyArrayunpack_sockaddr_in(contextarg);
 
         IRubyObject addr = sockaddr.pop(context);
         IRubyObject _port = sockaddr.pop(context);
         int port = SocketUtils.portToInt(_port);
 
         return new InetSocketAddress(
                 addr.convertToString().toString(), port);
     }
 
     public static UnixSocketAddress addressFromSockaddr_un(ThreadContext contextIRubyObject arg) {
         ByteList bl = arg.convertToString().getByteList();
         byte[] raw = bl.bytes();
 
         int end = 2;
         for (; end < raw.lengthend++) {
             if (raw[end] == 0) break;
         }
 
         ByteList path = new ByteList(raw, 2, endfalse);
         String pathStr = path.toString();
 
         return new UnixSocketAddress(new File(pathStr));
     }
 
     public static IRubyObject unpack_sockaddr_in(ThreadContext contextIRubyObject addr) {
         Ruby runtime = context.runtime;
         ByteList val = addr.convertToString().getByteList();
 
         validateSockaddr(runtimeval);
 
         int port = ((val.get(2)&0xff) << 8) + (val.get(3)&0xff);
 
         StringBuilder sb = new StringBuilder()
                 .append(val.get(4)&0xff)
                 .append(".")
                 .append(val.get(5)&0xff)
                 .append(".")
                 .append(val.get(6)&0xff)
                 .append(".")
                 .append(val.get(7)&0xff);
 
         IRubyObject[] result = new IRubyObject[]{
                 runtime.newFixnum(port),
                 runtime.newString(sb.toString())};
 
         return runtime.newArrayNoCopy(result);
     }
 
     public static IRubyObject packSockaddrFromAddress(ThreadContext contextInetSocketAddress sock) {
         if (sock == null) {
             return Sockaddr.pack_sockaddr_in(context, 0, "");
         } else {
             return Sockaddr.pack_sockaddr_in(contextsock);
         }
     }
 
    public static IRubyObject pack_sockaddr_in(ThreadContext contextint iportString host) {
        ByteArrayOutputStream bufS = new ByteArrayOutputStream();
        try {
            DataOutputStream ds = new DataOutputStream(bufS);
            writeSockaddrHeader(.ds);
            writeSockaddrPort(dsiport);
            try {
                if(host != null && "".equals(host)) {
                    ds.writeInt(0);
                } else {
                    InetAddress[] addrs = InetAddress.getAllByName(host);
                    byte[] addr = addrs[0].getAddress();
                    ds.write(addr, 0, addr.length);
                }
            } catch (UnknownHostException e) {
                throw sockerr(context.runtime"getaddrinfo: No address associated with nodename");
            }
            writeSockaddrFooter(ds);
        } catch (IOException e) {
            throw sockerr(context.runtime"pack_sockaddr_in: internal error");
        }
        return context.runtime.newString(new ByteList(bufS.toByteArray(),
                false));
    }
    public static IRubyObject pack_sockaddr_in(ThreadContext contextInetSocketAddress sock) {
        ByteArrayOutputStream bufS = new ByteArrayOutputStream();
        try {
            DataOutputStream ds = new DataOutputStream(bufS);
            writeSockaddrHeader(.ds);
            writeSockaddrPort(dssock);
            String host = sock.getAddress().getHostAddress();
            if(host != null && "".equals(host)) {
                ds.writeInt(0);
            } else {
                byte[] addr = sock.getAddress().getAddress();
                ds.write(addr, 0, addr.length);
            }
            writeSockaddrFooter(ds);
        } catch (IOException e) {
            throw sockerr(context.runtime"pack_sockaddr_in: internal error");
        }
        return context.runtime.newString(new ByteList(bufS.toByteArray(),
                false));
    }
    public static void writeSockaddrHeader(AddressFamily familyDataOutputStream dsthrows IOException {
        int value = family.intValue();
        int high = (value & 0xff00) >> 8;
        int low = value & 0xff;
        ds.write((byte)high);
        ds.write((byte)low);
    }
    public static void writeSockaddrFooter(DataOutputStream dsthrows IOException {
        ds.writeInt(0);
        ds.writeInt(0);
    }
    public static void writeSockaddrPort(DataOutputStream dsInetSocketAddress sockaddrthrows IOException {
        writeSockaddrPort(dssockaddr.getPort());
    }
    public static void writeSockaddrPort(DataOutputStream dsint portthrows IOException {
        ds.write(port >> 8);
        ds.write(port);
    }
    public static void validateSockaddr(Ruby runtimeByteList val) {
        int high = val.get(0) & 0xff;
        int low = val.get(1) & 0xff;
        AddressFamily af = AddressFamily.valueOf((high << 8) + low);
        if (af != . &&
                af != .) {
            throw runtime.newArgumentError("can't resolve socket address of wrong type");
        }
    }
    private static RuntimeException sockerr(Ruby runtimeString msg) {
        return new RaiseException(runtimeruntime.getClass("SocketError"), msgtrue);
    }
New to GrepCode? Check out our FAQ X