ûjli

 ÿþLinux x86_64 1.10.3 v1.10.3 0b4590a5507d3f3046e5bafc007cacbbfc9b310b  wŒ«ñýüûú                £   ZMQ®Q¯ôí})Âáä‰ù#»<hÜš8       e      (   /opt/julia/packages/ZMQ/4Jw8C/src/ZMQ.jl¦b¹äþ”ÙA        hEv°¿¿Ÿœ \^¾eZeroMQ_jll                   îµÁ¥,z¼¸ÜXzsy`{FileWatching                   ÌÞ”Ý—†1VÞ$þbdSockets               .   /opt/julia/packages/ZMQ/4Jw8C/src/constants.jl¦b¹äþ”ÙA       ,   /opt/julia/packages/ZMQ/4Jw8C/src/optutil.jl¦b¹äþ”ÙA       *   /opt/julia/packages/ZMQ/4Jw8C/src/error.jl¦b¹äþ”ÙA       ,   /opt/julia/packages/ZMQ/4Jw8C/src/context.jl¦b¹äþ”ÙA       +   /opt/julia/packages/ZMQ/4Jw8C/src/socket.jl¦b¹äþ”ÙA       -   /opt/julia/packages/ZMQ/4Jw8C/src/sockopts.jl¦b¹äþ”ÙA       ,   /opt/julia/packages/ZMQ/4Jw8C/src/message.jl¦b¹äþ”ÙA       -   /opt/julia/packages/ZMQ/4Jw8C/src/_message.jl¦b¹äþ”ÙA       )   /opt/julia/packages/ZMQ/4Jw8C/src/comm.jl¦b¹äþ”ÙA            *ØgnŠVˆƒ@jj¾§®PrecompileTools                      precompile_workload            Q         Core                æmÑƒúûüýçÑÆ×J5    Base                æmÑƒúûüý]‹™¸üJ5    Main                æmÑƒúûüýÆôÔÆ×J5    ArgToolsæBÑÅ„­Ÿx»Úï(æmÑƒúûüýêFž	K5 	   Artifactsñ˜mýr-òV3|ÀÝðæmÑƒúûüý¹ùû	K5    Base64½UƒlãD*_½˜—±ä‡æmÑƒúûüý>÷
K5    CRC32c«\yÁ¨.õ‹¼©·žj—æmÑƒúûüýj¾Ì
K5    FileWatchingÜXzsy`{îµÁ¥,z¼¸æmÑƒúûüýh&
K5    LibdluVW5£9ÛË—,ƒûÿµæmÑƒúûüý‚-"
K5    LoggingáT{…°ÝVhUÛXMÛ=¸æmÑƒúûüýr÷U"
K5    Mmap„P~Ñ:¦xg,þO•æmÑƒúûüý›|'
K5    NetworkOptions©CãÂ0YWÊ,‹˜ä¬æmÑƒúûüý‚Ê ,
K5    SHA¯Q<$œ‘ŽêÎ!×<¦ª%ˆæmÑƒúûüý‹–û1
K5    Serialization[)ø*´ˆžk˜1’žé»æmÑƒúûüý¹-¤G
K5    Sockets1VÞ$þbdÌÞ”Ý—†æmÑƒúûüýY‹BY
K5    UnicodeâP>I>¨ÀNõ¨õ¬r¬¹æmÑƒúûüýeszo
K5    LinearAlgebraSømäâ7ŽœÌÌƒî´æmÑƒúûüýuux
K5    OpenBLAS_jll€[(Åšb6Ec³ÅQøF½æmÑƒúûüýDuûx
K5    libblastrampoline_jllLSÛ†…Ž“}lxÓ æmÑƒúûüý¯^ô}
K5    MarkdownZPõ®n7ôÖz`”sœÁ–æmÑƒúûüý/Ed~K5    Printfg^cÚXÞ×¸îÞíQD‡æmÑƒúûüý;hŒ¸K5    Random_É¢„‚?š\ý¡€Y„šæmÑƒúûüýî?ÃK5    Tar¤Oè¦iå¤>±Õ¡÷îó°æmÑƒúûüý!t,úK5    DatesEY‘8pÊâ­jà2”	Üû˜æmÑƒúûüýXûŽK5    FuturebS;3{I¨Ÿ xèVMžæmÑƒúûüýsDî…K5    InteractiveUtils W‘ÒL
~·@¢'Z²èæmÑƒúûüýŠVg‡K5    LibGit2Z[&RPTøv3´EÐšRªŽæmÑƒúûüýè8JµK5    LibGit2_jll
Y¤Xg¯}ãÅÿÒ]$°™ŽæmÑƒúûüý‘D…µK5    MbedTLS_jllAX3ÃÙÿÈ¡_×Ž·æmÑƒúûüý-µµK5    LibSSH2_jlloT«¹Zk)¨ß†­í<“æmÑƒúûüý{dd¶K5    UUIDs[vi§qÏ¤‘õrÜz9šæmÑƒúûüýËÛ)K5    REPLvVñî–Í ?û¿‹u¸³aŠæmÑƒúûüý N/K5    TOMLOI`&úvíáúº3TªæmÑƒúûüýy‡‰VK5    LibCURLÈPç£Â2p²!ýËÛ6-Í€æmÑƒúûüýÐ™[K5    LibCURL_jllYÇ‹G›¬ÞÀ„ÜV¬5þ æmÑƒúûüý §Ê[K5    nghttp2_jll9SˆvÞ…Ž¯*Í*0| æmÑƒúûüýœðë[K5    MozillaCACerts_jll.Vöm`£YÍrÙ!‘æmÑƒúûüýbŽ”\K5 	   DownloadsÔJ
Â$:ôÆax$±ö,…æmÑƒúûüýíâtyK5    PkgêR²ZéÏD·iß¯âr¶æmÑƒúûüý©&ùK5 	   p7zip_jll³SØ33é? ·ÃQ½«ªæmÑƒúûüýPá¾K5    Preferencesces.jl!!Preferen€¡å*ýüûú-å"7      JLLWrappersK…<Í;+i2ëà<ñ±§ÀžÐýüûúƒ³—7      libsodium_jllÙV#ÊòJ©øÌµ÷O˜ã4…ýüûúÔ°æ8   
   ZeroMQ_jll \^¾ehEv°¿¿Ÿœ†c%ýüûúùòx8      PrecompileToolsƒ@jj¾§®*ØgnŠVˆÓxáýüûúUb“7       s                                                         Øv    )	¯ýó_@: AÅa	!          0         generic    (   /opt/julia/packages/ZMQ/4Jw8C/src/ZMQ.jlð      # Support for ZeroMQ, a network and interprocess communication library

module ZMQ
using ZeroMQ_jll

using Base.Libc: EAGAIN
using FileWatching: UV_READABLE, uv_pollcb, _FDWatcher
import Sockets
using Sockets: connect, bind, send, recv
import Base.GC: @preserve

export
    #Types
    StateError,Context,Socket,Message,
    #functions
    set, subscribe, unsubscribe,
    #Constants
    IO_THREADS,MAX_SOCKETS,PAIR,PUB,SUB,REQ,REP,ROUTER,DEALER,PULL,PUSH,XPUB,XSUB,XREQ,XREP,UPSTREAM,DOWNSTREAM,MORE,POLLIN,POLLOUT,POLLERR,STREAMER,FORWARDER,QUEUE,SNDMORE,
    #Sockets
    connect, bind, send, recv


include("constants.jl")
include("optutil.jl")
include("error.jl")
include("context.jl")
include("socket.jl")
include("sockopts.jl")
include("message.jl")
include("comm.jl")

function __init__()
    major = Ref{Cint}()
    minor = Ref{Cint}()
    patch = Ref{Cint}()
    ccall((:zmq_version, libzmq), Cvoid, (Ptr{Cint}, Ptr{Cint}, Ptr{Cint}), major, minor, patch)
    global version = VersionNumber(major[], minor[], patch[])
    if version < v"3"
        error("ZMQ version $version < 3 is not supported")
    end
    atexit() do
        close(_context)
    end
end

using PrecompileTools
@compile_workload begin
    __init__()
    # The ZMQ scoping below isn't necessary, but it makes it easier to copy/paste
    # the workload to test impact.
    s=Socket(PUB)
    ZMQ.close(s)

    s1=Socket(REP)
    s1.sndhwm = 1000
    s1.linger = 1
    s1.routing_id = "abcd"

    s2=Socket(REQ)

    ZMQ.bind(s1, "tcp://*:5555")
    ZMQ.connect(s2, "tcp://localhost:5555")

    msg = Message("test request")

    ZMQ.send(s2, msg)
    unsafe_string(ZMQ.recv(s1))
    ZMQ.send(s1, Message("test response"))
    unsafe_string(ZMQ.recv(s2))
    ZMQ.close(s1)
    ZMQ.close(s2)
end

end
.   /opt/julia/packages/ZMQ/4Jw8C/src/constants.jl      
## Constants

# Context options
const IO_THREADS = 1
const MAX_SOCKETS = 2
const IPV6 = 42

"[PAIR](https://zeromq.org/socket-api/#pair-socket) socket."
const PAIR = 0
"[PUB](https://zeromq.org/socket-api/#pub-socket) socket."
const PUB = 1
"[SUB](https://zeromq.org/socket-api/#sub-socket) socket."
const SUB = 2
"[REQ](https://zeromq.org/socket-api/#req-socket) socket."
const REQ = 3
"[REP](https://zeromq.org/socket-api/#rep-socket) socket."
const REP = 4
"[DEALER](https://zeromq.org/socket-api/#dealer-socket) socket."
const DEALER = 5
"[ROUTER](https://zeromq.org/socket-api/#router-socket) socket."
const ROUTER = 6
"[PULL](https://zeromq.org/socket-api/#pull-socket) socket."
const PULL = 7
"[PUSH](https://zeromq.org/socket-api/#push-socket) socket."
const PUSH = 8
"[XPUB](https://zeromq.org/socket-api/#xpub-socket) socket."
const XPUB = 9
"[XSUB](https://zeromq.org/socket-api/#xsub-socket) socket."
const XSUB = 10
"[XREQ](https://zeromq.org/socket-api/#dealer-socket) socket."
const XREQ = DEALER
"[XREP](https://zeromq.org/socket-api/#router-socket) socket."
const XREP = ROUTER
"[UPSTREAM](https://zeromq.org/socket-api/#pull-socket) socket."
const UPSTREAM = PULL
"[DOWNSTREAM](https://zeromq.org/socket-api/#push-socket) socket."
const DOWNSTREAM = PUSH

#Message options
const MORE = 1
const SNDMORE = true

#IO Multiplexing
const POLLIN = 1
const POLLOUT = 2
const POLLERR = 4

#Built in devices
const STREAMER = 1
const FORWARDER = 2
const QUEUE = 3


#Send/Recv Options
const ZMQ_DONTWAIT = 1
const ZMQ_SNDMORE = 2
,   /opt/julia/packages/ZMQ/4Jw8C/src/optutil.jl!      # Utility to make it easier to define get/setproperty for a long list of options.

# build up the body of get/setproperty from a list of properties, of the form
#     if name === $prop
#         ($doit(prop))
#     elseif ...
# for getproperty(value, name) or setproperty!(value, name, x)
function propexpression(doit::Function, properties)
    ex = :(error(typeof(value), " has no field ", name))
    for prop in properties
        ex = Expr(:elseif, :(name === $(QuoteNode(prop))), doit(prop), ex)
    end
    return Expr(:if, ex.args...)
end
*   /opt/julia/packages/ZMQ/4Jw8C/src/error.jl¼      # A server will report most errors to the client over a Socket, but
# errors in ZMQ state can't be reported because the socket may be
# corrupted. Therefore, we need an exception type for errors that
# should be reported locally.
struct StateError <: Exception
    msg::AbstractString
end
show(io, thiserr::StateError) = print(io, "ZMQ: ", thiserr.msg)

# Basic functions
zmq_errno() = ccall((:zmq_errno, libzmq), Cint, ())
function jl_zmq_error_str()
    errno = zmq_errno()
    c_strerror = ccall((:zmq_strerror, libzmq), Ptr{UInt8}, (Cint,), errno)
    if c_strerror != C_NULL
        strerror = unsafe_string(c_strerror)
        return strerror
    else
        return "Unknown error"
    end
end,   /opt/julia/packages/ZMQ/4Jw8C/src/context.jl       
## Contexts ##

# the low-level context constructor
function _ctx_new()
    p = ccall((:zmq_ctx_new, libzmq), Ptr{Cvoid},  ())
    if p == C_NULL
        throw(StateError(jl_zmq_error_str()))
    end
    return p
end

mutable struct Context
    data::Ptr{Cvoid}

    # need to keep a list of weakrefs to sockets for this Context in order to
    # close them before finalizing (otherwise zmq_term will hang)
    sockets::Vector{WeakRef}

    function Context()
        zctx = new(_ctx_new(), WeakRef[])
        finalizer(close, zctx)
        return zctx
    end
    function Context(::UndefInitializer)
        zctx = new(C_NULL, WeakRef[])
        finalizer(close, zctx)
        return zctx
    end
end

function Context(f::Function, args...)
    ctx = Context(args...)
    try
        f(ctx)
    finally
        close(ctx)
    end
end

Base.unsafe_convert(::Type{Ptr{Cvoid}}, c::Context) = getfield(c, :data)

# define a global context that is initialized lazily
# and is used by default in Socket constructors, to
# save 99% of users from the low-level need to set up
# a context
const _context = Context(undef)

"""
    context()

Return the default ZMQ context (of type `Context`), initializing
it if this has not been done already.  (This context is automatically
closed when Julia exits.)
"""
function context()
    if !isopen(_context)
        setfield!(_context, :data, _ctx_new())
    end
    return _context
end

@deprecate Context(n::Integer) Context()

Base.isopen(ctx::Context) = getfield(ctx, :data) != C_NULL
function Base.close(ctx::Context)
    if isopen(ctx) # don't close twice!
        for w in getfield(ctx, :sockets)
            s = w.value
            if s isa Socket && isopen(s)
                s.linger = 0 # allow socket to shut down immediately
                close(s)
            end
        end
        empty!(getfield(ctx, :sockets))
        rc = ccall((:zmq_ctx_destroy, libzmq), Cint,  (Ptr{Cvoid},), ctx)
        setfield!(ctx, :data, C_NULL)
        if rc != 0
            throw(StateError(jl_zmq_error_str()))
        end
    end
end
@deprecate term(ctx::Context) close(ctx)

function _get(ctx::Context, option::Integer)
    val = ccall((:zmq_ctx_get, libzmq), Cint, (Ptr{Cvoid}, Cint), ctx, option)
    if val < 0
        throw(StateError(jl_zmq_error_str()))
    end
    return val
end
function _set(ctx::Context, option::Integer, value::Integer)
    rc = ccall((:zmq_ctx_set, libzmq), Cint, (Ptr{Cvoid}, Cint, Cint), ctx, option, value)
    if rc != 0
        throw(StateError(jl_zmq_error_str()))
    end
end

const ctxopts = (:io_threads, :max_sockets, :ipv6)
Base.propertynames(::Context) = ctxopts
@eval function Base.getproperty(value::Context, name::Symbol)
    $(propexpression(ctxopts) do p
        :(_get(value, $(Symbol(uppercase(String(p))))))
    end)
end
@eval function Base.setproperty!(value::Context, name::Symbol, x::Integer)
    $(propexpression(ctxopts) do p
        :(_set(value, $(Symbol(uppercase(String(p)))), x))
    end)
    return x
end

function Base.get(ctx::Context, option::Integer)
    Base.depwarn("get(ctx, option) is deprecated; use ctx.option instead", :get)
    return _get(ctx, option)
end
function set(ctx::Context, option::Integer, value::Integer)
    Base.depwarn("set(ctx, option, val) is deprecated; use ctx.option = val instead", :set)
    return _set(ctx, option, value)
end
+   /opt/julia/packages/ZMQ/4Jw8C/src/socket.jl       """
A ZMQ socket.

    Socket(typ::Integer)

Create a socket of a certain type.

---

    Socket(ctx::Context, typ::Integer)

Create a socket in a given context.

---

    Socket(f::Function, args...)

Do-block constructor.
"""
mutable struct Socket
    data::Ptr{Cvoid}
    pollfd::_FDWatcher

    """
        Socket(ctx::Context, typ::Integer)

    Create a socket in a given context.
    """
    function Socket(ctx::Context, typ::Integer)
        p = ccall((:zmq_socket, libzmq), Ptr{Cvoid}, (Ptr{Cvoid}, Cint), ctx, typ)
        if p == C_NULL
            throw(StateError(jl_zmq_error_str()))
        end
        socket = new(p)
        setfield!(socket, :pollfd, _FDWatcher(fd(socket), #=readable=#true, #=writable=#false))
        finalizer(close, socket)
        push!(getfield(ctx, :sockets), WeakRef(socket))
        return socket
    end

    """
        Socket(typ::Integer)

    Create a socket of a certain type.
    """
    Socket(typ::Integer) = Socket(context(), typ)
end

"""
    Socket(f::Function, args...)

Do-block constructor.
"""
function Socket(f::Function, args...)
    socket = Socket(args...)
    try
        f(socket)
    finally
        close(socket)
    end
end

Base.unsafe_convert(::Type{Ptr{Cvoid}}, s::Socket) = getfield(s, :data)

"""
    Base.isopen(socket::Socket)
"""
Base.isopen(socket::Socket) = getfield(socket, :data) != C_NULL

"""
    Base.close(socket::Socket)
"""
function Base.close(socket::Socket)
    if isopen(socket)
        close(getfield(socket, :pollfd), #=readable=#true, #=writable=#false)
        rc = ccall((:zmq_close, libzmq), Cint,  (Ptr{Cvoid},), socket)
        setfield!(socket, :data, C_NULL)
        if rc != 0
            throw(StateError(jl_zmq_error_str()))
        end
    end
end

# Raw FD access
if Sys.isunix()
    Base.fd(socket::Socket) = RawFD(socket.fd)
end
if Sys.iswindows()
    using Base.Libc: WindowsRawSocket
    Base.fd(socket::Socket) = WindowsRawSocket(convert(Ptr{Cvoid}, socket.fd))
end

Base.wait(socket::Socket) = wait(getfield(socket, :pollfd), readable=true, writable=false)
Base.notify(socket::Socket) = @preserve socket uv_pollcb(getfield(socket, :pollfd).handle, Int32(0), Int32(UV_READABLE))

"""
    Sockets.bind(socket::Socket, endpoint::AbstractString)

Bind the socket to an endpoint. Note that the endpoint must be formatted as
described
[here](http://api.zeromq.org/4-3:zmq-bind). e.g. `tcp://127.0.0.1:42000`.
"""
function Sockets.bind(socket::Socket, endpoint::AbstractString)
    rc = ccall((:zmq_bind, libzmq), Cint, (Ptr{Cvoid}, Ptr{UInt8}), socket, endpoint)
    if rc != 0
        throw(StateError(jl_zmq_error_str()))
    end
end

"""
    Sockets.connect(socket::Socket, endpoint::AbstractString)

Connect the socket to an endpoint.
"""
function Sockets.connect(socket::Socket, endpoint::AbstractString)
    rc=ccall((:zmq_connect, libzmq), Cint, (Ptr{Cvoid}, Ptr{UInt8}), socket, endpoint)
    if rc != 0
        throw(StateError(jl_zmq_error_str()))
    end
end
-   /opt/julia/packages/ZMQ/4Jw8C/src/sockopts.jlƒ      # Socket options

for (fset, fget, k, T) in [
    (:set_affinity,                :get_affinity,                 4, UInt64)
    (:set_type,                    :get_type,                    16,   Cint)
    (:set_linger,                  :get_linger,                  17,   Cint)
    (:set_reconnect_ivl,           :get_reconnect_ivl,           18,   Cint)
    (:set_backlog,                 :get_backlog,                 19,   Cint)
    (:set_reconnect_ivl_max,       :get_reconnect_ivl_max,       21,   Cint)
    (:set_rate,                    :get_rate,                     8,   Cint)
    (:set_recovery_ivl,            :get_recovery_ivl,             9,   Cint)
    (:set_sndbuf,                  :get_sndbuf,                  11,   Cint)
    (:set_rcvbuf,                  :get_rcvbuf,                  12,   Cint)
    (nothing,                      :_zmq_getsockopt_rcvmore,     13,   Cint)
    (nothing,                      :get_events,                  15,   Cint)
    (:set_maxmsgsize,              :get_maxmsgsize,              22,   Cint)
    (:set_sndhwm,                  :get_sndhwm,                  23,   Cint)
    (:set_rcvhwm,                  :get_rcvhwm,                  24,   Cint)
    (:set_multicast_hops,          :get_multicast_hops,          25,   Cint)
    (:set_ipv4only,                :get_ipv4only,                31,   Cint)
    (:set_tcp_keepalive,           :get_tcp_keepalive,           34,   Cint)
    (:set_tcp_keepalive_idle,      :get_tcp_keepalive_idle,      35,   Cint)
    (:set_tcp_keepalive_cnt,       :get_tcp_keepalive_cnt,       36,   Cint)
    (:set_tcp_keepalive_intvl,     :get_tcp_keepalive_intvl,     37,   Cint)
    (:set_rcvtimeo,                :get_rcvtimeo,                27,   Cint)
    (:set_sndtimeo,                :get_sndtimeo,                28,   Cint)
    (:set_immediate,               :get_immediate,               39,   Cint)
    (:set_conflate,                :get_conflate,                54,   Cint)
    (nothing,                      :get_fd,                      14, Sys.iswindows() ? Ptr{Cvoid} : Cint)
    ]
    if fset != nothing
        @eval function $(Symbol("_",fset))(socket::Socket, option_val::Integer)
            rc = ccall((:zmq_setsockopt, libzmq), Cint,
                       (Ptr{Cvoid}, Cint, Ref{$T}, Csize_t),
                       socket, $k, option_val, sizeof($T))
            if rc != 0
                throw(StateError(jl_zmq_error_str()))
            end
        end
        prop = QuoteNode(Symbol(String(fset)[5:end]))
        @eval @deprecate $fset(socket::Socket, option_val::Integer) setproperty!(socket, $prop, option_val)
    end
    if fget != nothing
        @eval function $(Symbol("_",fget))(socket::Socket)
            val = Ref{$T}()
            rc = ccall((:zmq_getsockopt, libzmq), Cint,
                       (Ptr{Cvoid}, Cint, Ref{$T}, Ref{Csize_t}),
                       socket, $k, val, sizeof($T))
            if rc != 0
                throw(StateError(jl_zmq_error_str()))
            end
            return Int(val[])
        end
        prop = QuoteNode(Symbol(String(fget)[5:end]))
        @eval @deprecate $fget(socket::Socket) getproperty(socket, $prop)
    end
end

# For some functions, the publicly-visible versions should require &
# return boolean:
_get_rcvmore(socket::Socket) = Bool(__zmq_getsockopt_rcvmore(socket))
@deprecate get_rcvmore(socket::Socket) getproperty(socket, :rcvmore)
@deprecate ismore(socket::Socket) getproperty(socket, :rcvmore)

# subscribe/unsubscribe options take an arbitrary byte array
for (f,k) in ((:subscribe,6), (:unsubscribe,7))
    f_ = Symbol(f, "_")
    @eval begin
        function $f_(socket::Socket, filter::Ptr{T}, len::Integer) where {T}
            rc = ccall((:zmq_setsockopt, libzmq), Cint,
                       (Ptr{Cvoid}, Cint, Ptr{T}, Csize_t),
                       socket, $k, filter, len)
            if rc != 0
                throw(StateError(jl_zmq_error_str()))
            end
        end
        $f(socket::Socket, filter::Union{Vector{UInt8},String}) =
            @preserve filter $f_(socket, pointer(filter), sizeof(filter))
        $f(socket::Socket, filter::AbstractString) = $f(socket, String(filter))
        $f(socket::Socket) = $f_(socket, C_NULL, 0)
    end
end

# string properties
for (fset, fget, k) in [
    (:_set_routing_id,           :_get_routing_id,              5)
    (nothing,                    :_get_last_endpoint,          32)
    # (:_set_tcp_accept_filter,       nothing,                     38) #  deprecated
    ]
    if fset != nothing
        @eval function ($fset)(socket::Socket, option_val::String)
            if sizeof(option_val) > 255
                throw(StateError("option value too large"))
            end
            rc = ccall((:zmq_setsockopt, libzmq), Cint,
                       (Ptr{Cvoid}, Cint, Ptr{UInt8}, Csize_t),
                       socket, $k, option_val, sizeof(option_val))
            if rc != 0
                throw(StateError(jl_zmq_error_str()))
            end
        end
        @eval ($fset)(socket::Socket, option_val::AbstractString) = $fset(socket, String(option_val))
    end
    if fget != nothing
        @eval function ($fget)(socket::Socket)
            buf = Base.StringVector(255)
            len = Ref{Csize_t}(sizeof(buf))
            rc = ccall((:zmq_getsockopt, libzmq), Cint,
                       (Ptr{Cvoid}, Cint, Ptr{UInt8}, Ref{Csize_t}),
                       socket, $k, buf, len)
            if rc != 0
                throw(StateError(jl_zmq_error_str()))
            end
            return String(resize!(buf, len[]))
        end
    end
end
@deprecate get_identity(socket::Socket) getproperty(socket, :routing_id)
@deprecate set_identity(socket::Socket, val) setproperty!(socket, :routing_id, val)

# getproperty/setproperty API for socket properties
const sockprops = (:affinity, :type, :linger, :reconnect_ivl, :backlog, :reconnect_ivl_max,
                   :rate, :recovery_ivl, :sndbuf, :rcvbuf, :rcvmore, :events, :maxmsgsize,
                   :sndhwm, :rcvhwm, :multicast_hops, :ipv4only,
                   :tcp_keepalive, :tcp_keepalive_idle, :tcp_keepalive_cnt, :tcp_keepalive_intvl,
                   :rcvtimeo, :sndtimeo, :fd, :routing_id, :last_endpoint, :immediate, :conflate)

Base.propertynames(::Socket) = sockprops
@eval function Base.getproperty(value::Socket, name::Symbol)
    $(propexpression(filter!(p -> isdefined(@__MODULE__, Symbol("_get_", p)), collect(sockprops))) do p
        :($(Symbol("_get_", p))(value))
    end)
end
@eval function Base.setproperty!(value::Socket, name::Symbol, x)
    $(propexpression(filter!(p -> isdefined(@__MODULE__, Symbol("_set_", p)), collect(sockprops))) do p
        :($(Symbol("_set_", p))(value, x))
    end)
    return x
end
,   /opt/julia/packages/ZMQ/4Jw8C/src/message.jl       include("_message.jl")

# in order to support zero-copy messages that share data with Julia
# arrays, we need to hold a reference to the Julia object in a dictionary
# until zeromq is done with the data, to prevent it from being garbage
# collected.  The gc_protect dictionary is keyed by a uv_async_t* pointer,
# used in uv_async_send to tell Julia to when zeromq is done with the data.
const gc_protect = Dict{Ptr{Cvoid},Any}()

# callback argument for AsyncCondition
gc_protect_cb(work) = (pop!(gc_protect, work.handle, nothing); Base.close(work))

function gc_protect_handle(obj::Any)
    work = Base.AsyncCondition(gc_protect_cb)
    gc_protect[work.handle] = (work,obj)
    work.handle
end

# Thread-safe zeromq callback when data is freed, passed to zmq_msg_init_data.
# The hint parameter will be a uv_async_t* pointer.
function gc_free_fn(data::Ptr{Cvoid}, hint::Ptr{Cvoid})
    ccall(:uv_async_send,Cint,(Ptr{Cvoid},),hint)
end

"""
High-level Message object for sending/receiving ZMQ messages in shared buffers.

    Message()

Create an empty message (for receive).

---

    Message(len::Integer)

Create a message with a given buffer size (for send).

---

    Message(origin::Any, m::Ptr{T}, len::Integer) where {T}

Low-level function to create a message (for send) with an existing
data buffer, without making a copy.  The origin parameter should
be the Julia object that is the origin of the data, so that
we can hold a reference to it until ZMQ is done with the buffer.

---

    Message(m::String)

Create a message with a string as a buffer (for send). Note: the Message now
"owns" the string, it must not be resized, or even written to after the message
is sent.

---

    Message(p::SubString{String})

Create a message with a sub-string as a buffer (for send). Note: the same
ownership semantics as for [`Message(m::String)`](@ref) apply.

---

    Message(a::Array)

Create a message with an array as a buffer (for send). Note: the same
ownership semantics as for [`Message(m::String)`](@ref) apply.

---

    Message(io::IOBuffer)

Create a message with an
[`IOBuffer`](https://docs.julialang.org/en/v1/base/io-network/#Base.IOBuffer) as
a buffer (for send). Note: the same ownership semantics as for
[`Message(m::String)`](@ref) apply.
"""
mutable struct Message <: AbstractArray{UInt8,1}
    # Matching the declaration in the header: char _[64];
    w_padding::_Message
    handle::Ptr{Cvoid} # index into gc_protect, if any

    """
        Message()

    Create an empty message (for receive).
    """
    function Message()
        zmsg = new()
        setfield!(zmsg, :handle, C_NULL)
        rc = ccall((:zmq_msg_init, libzmq), Cint, (Ref{Message},), zmsg)
        if rc != 0
            throw(StateError(jl_zmq_error_str()))
        end
        finalizer(close, zmsg)
        return zmsg
    end

    """
        Message(len::Integer)

    Create a message with a given buffer size (for send).
    """
    function Message(len::Integer)
        zmsg = new()
        setfield!(zmsg, :handle, C_NULL)
        rc = ccall((:zmq_msg_init_size, libzmq), Cint, (Ref{Message}, Csize_t), zmsg, len)
        if rc != 0
            throw(StateError(jl_zmq_error_str()))
        end
        finalizer(close, zmsg)
        return zmsg
    end

    """
        Message(origin::Any, m::Ptr{T}, len::Integer) where {T}

    Low-level function to create a message (for send) with an existing
    data buffer, without making a copy.  The origin parameter should
    be the Julia object that is the origin of the data, so that
    we can hold a reference to it until ZMQ is done with the buffer.
    """
    function Message(origin::Any, m::Ptr{T}, len::Integer) where {T}
        zmsg = new()
        setfield!(zmsg, :handle, gc_protect_handle(origin))
        gc_free_fn_c = @cfunction(gc_free_fn, Cint, (Ptr{Cvoid}, Ptr{Cvoid}))
        rc = ccall((:zmq_msg_init_data, libzmq), Cint, (Ref{Message}, Ptr{T}, Csize_t, Ptr{Cvoid}, Ptr{Cvoid}),
                   zmsg, m, len, gc_free_fn_c, getfield(zmsg, :handle))
        if rc != 0
            gc_free_fn(C_NULL, getfield(zmsg, :handle)) # don't leak memory on error
            throw(StateError(jl_zmq_error_str()))
        end
        finalizer(close, zmsg)
        return zmsg
    end

    """
        Message(m::String)

    Create a message with a string as a buffer (for send). Note: the Message now
    "owns" the string, it must not be resized, or even written to after the message
    is sent.
    """
    Message(m::String) = Message(m, pointer(m), sizeof(m))

    """
        Message(p::SubString{String})

    Create a message with a sub-string as a buffer (for send). Note: the same
    ownership semantics as for [`Message(m::String)`](@ref) apply.
    """
    Message(p::SubString{String}) =
        Message(p, pointer(p.string)+p.offset, sizeof(p))

    """
        Message(a::Array)

    Create a message with an array as a buffer (for send). Note: the same
    ownership semantics as for [`Message(m::String)`](@ref) apply.
    """
    Message(a::Array) = Message(a, pointer(a), sizeof(a))

    """
        Message(io::IOBuffer)

    Create a message with an
    [`IOBuffer`](https://docs.julialang.org/en/v1/base/io-network/#Base.IOBuffer) as
    a buffer (for send). Note: the same ownership semantics as for
    [`Message(m::String)`](@ref) apply.
    """
    function Message(io::IOBuffer)
        if !io.readable || !io.seekable
            error("byte read failed")
        end
        Message(io.data)
    end
end

# check whether zeromq has called our free-function, i.e. whether
# we are save to reclaim ownership of any buffer object
isfreed(m::Message) = haskey(gc_protect, getfield(m, :handle))

# AbstractArray behaviors:
Base.similar(a::Message, ::Type{T}, dims::Dims) where {T} = Array{T}(undef, dims) # ?
Base.length(zmsg::Message) = Int(ccall((:zmq_msg_size, libzmq), Csize_t, (Ref{Message},), zmsg))
Base.size(zmsg::Message) = (length(zmsg),)
Base.unsafe_convert(::Type{Ptr{UInt8}}, zmsg::Message) = ccall((:zmq_msg_data, libzmq), Ptr{UInt8}, (Ref{Message},), zmsg)
function Base.getindex(a::Message, i::Integer)
    @boundscheck if i < 1 || i > length(a)
        throw(BoundsError())
    end
    @preserve a unsafe_load(pointer(a), i)
end
function Base.setindex!(a::Message, v, i::Integer)
    @boundscheck if i < 1 || i > length(a)
        throw(BoundsError())
    end
    @preserve a unsafe_store!(pointer(a), v, i)
    return v
end

# Convert message to string (copies data)
Base.unsafe_string(zmsg::Message) = @preserve zmsg unsafe_string(pointer(zmsg), length(zmsg))

Base.elsize(::Message) = 1
Base.strides(::Message) = (1,)

# Build an IOStream from a message
# Copies the data
function Base.convert(::Type{IOStream}, zmsg::Message)
    s = IOBuffer()
    write(s, zmsg)
    return s
end

# Close a message. You should not need to call this manually (let the
# finalizer do it).
function Base.close(zmsg::Message)
    rc = ccall((:zmq_msg_close, libzmq), Cint, (Ref{Message},), zmsg)
    if rc != 0
        throw(StateError(jl_zmq_error_str()))
    end
    return nothing
end

function _get(zmsg::Message, property::Integer)
    val = ccall((:zmq_msg_get, libzmq), Cint, (Ref{Message}, Cint), zmsg, property)
    if val < 0
        throw(StateError(jl_zmq_error_str()))
    end
    val
end
function _set(zmsg::Message, property::Integer, value::Integer)
    rc = ccall((:zmq_msg_set, libzmq), Cint, (Ref{Message}, Cint, Cint), zmsg, property, value)
    if rc < 0
        throw(StateError(jl_zmq_error_str()))
    end
end
Base.propertynames(zmsg::Message) = (:more,)
function Base.getproperty(zmsg::Message, name::Symbol)
    if name === :more
        return _get(zmsg, MORE)
    else
        error("Message has no field $name")
    end
end
function Base.setproperty!(zmsg::Message, name::Symbol, value::Integer)
    # Currently the zmq_msg_set() function does not support any property names
    error("Message has no writable field $name")
end
function Base.get(zmsg::Message, option::Integer)
    Base.depwarn("get(zmsg, option) is deprecated; use zmsg.option instead", :get)
    return _get(zmsg, option)
end
@deprecate set(zmsg::Message, property::Integer, value::Integer) _set(zmsg, property, value)
-   /opt/julia/packages/ZMQ/4Jw8C/src/_message.jlº      ## Low-level _Message type for sending/receiving small ZMQ messages directly, without the complications
## and overhead of the Message object for sharing buffers between Julia and libzmq.

# Low-level message type, matching the declaration of
# zmq_msg_t in the header: char _[64];
primitive type _Message 64 * 8 end

const _MessageOrRef = Union{_Message,Base.RefValue{_Message}}

function msg_init()
    zmsg = Ref{_Message}()
    rc = ccall((:zmq_msg_init, libzmq), Cint, (Ref{_Message},), zmsg)
    rc != 0 && throw(StateError(jl_zmq_error_str()))
    return zmsg
end

function msg_init(nbytes::Int)
    zmsg = Ref{_Message}()
    rc = ccall((:zmq_msg_init_size, libzmq), Cint, (Ref{_Message}, Csize_t), zmsg, nbytes % Csize_t)
    rc != 0 && throw(StateError(jl_zmq_error_str()))
    return zmsg
end

# note: no finalizer for _Message, so we need to call close manually!
function Base.close(zmsg::_MessageOrRef)
    rc = ccall((:zmq_msg_close, libzmq), Cint, (Ref{_Message},), zmsg)
    rc != 0 && throw(StateError(jl_zmq_error_str()))
    return nothing
end

Base.length(zmsg::_MessageOrRef) = ccall((:zmq_msg_size, libzmq), Csize_t, (Ref{_Message},), zmsg) % Int
Base.unsafe_convert(::Type{Ptr{UInt8}}, zmsg::_MessageOrRef) =
    ccall((:zmq_msg_data, libzmq), Ptr{UInt8}, (Ref{_Message},), zmsg)

# isbits data, vectors thereof, and strings can be converted to/from _Message

function _MessageRef(x::T) where {T}
    isbitstype(T) || throw(MethodError(_MessageRef, (x,)))
    n = sizeof(x)
    zmsg = msg_init(n)
    @preserve zmsg unsafe_store!(Ptr{T}(Base.unsafe_convert(Ptr{UInt8}, zmsg)), x)
    return zmsg
end

function _MessageRef(x::Vector{T}) where {T}
    isbitstype(T) || throw(MethodError(_MessageRef, (x,)))
    n = sizeof(x)
    zmsg = msg_init(n)
    ccall(:memcpy, Ptr{Cvoid}, (Ptr{UInt8}, Ptr{T}, Csize_t), zmsg, x, n)
    return zmsg
end

function _MessageRef(x::String)
    n = sizeof(x)
    zmsg = msg_init(n)
    ccall(:memcpy, Ptr{Cvoid}, (Ptr{UInt8}, Ptr{UInt8}, Csize_t), zmsg, x, n)
    return zmsg
end

function unsafe_copy(::Type{Vector{T}}, zmsg::_MessageOrRef) where {T}
    isbitstype(T) || throw(MethodError(unsafe_copy, (T, zmsg,)))
    n = length(zmsg)
    len, remainder = divrem(n, sizeof(T))
    iszero(remainder) || error("message length $n not a multiple of sizeof($T)")
    a = Array{T}(undef, len)
    ccall(:memcpy, Ptr{Cvoid}, (Ptr{T}, Ptr{UInt8}, Csize_t), a, zmsg, n)
    return a
end

function unsafe_copy(::Type{T}, zmsg::_MessageOrRef) where {T}
    isbitstype(T) || throw(MethodError(unsafe_copy, (T, zmsg,)))
    n = length(zmsg)
    n == sizeof(T) || error("message length $n â‰  sizeof($T)")
    return @preserve zmsg unsafe_load(Ptr{T}(Base.unsafe_convert(Ptr{UInt8}, zmsg)))
end

function unsafe_copy(::Type{String}, zmsg::_MessageOrRef)
    n = length(zmsg)
    return @preserve zmsg unsafe_string(Base.unsafe_convert(Ptr{UInt8}, zmsg), n)
end

unsafe_copy(::Type{IOBuffer}, zmsg::_MessageOrRef) = IOBuffer(unsafe_copy(Vector{UInt8}, zmsg))
)   /opt/julia/packages/ZMQ/4Jw8C/src/comm.jl”      
## Send/receive messages.

############################################################################

msg_send(socket::Socket, zmsg::_MessageOrRef, flags::Integer) =
    ccall((:zmq_msg_send, libzmq), Cint, (Ref{_Message}, Ptr{Cvoid}, Cint), zmsg, socket, flags)
msg_send(socket::Socket, zmsg::Message, flags::Integer) =
    ccall((:zmq_msg_send, libzmq), Cint, (Ref{Message}, Ptr{Cvoid}, Cint), zmsg, socket, flags)

function _send(socket::Socket, zmsg, more::Bool=false)
    while true
        if -1 == msg_send(socket, zmsg, (ZMQ_SNDMORE*more) | ZMQ_DONTWAIT)
            zmq_errno() == EAGAIN || throw(StateError(jl_zmq_error_str()))
            while (socket.events & POLLOUT) == 0
                wait(socket)
            end
        else
            notify_is_expensive = !isempty(getfield(socket,:pollfd).notify.waitq)
            if notify_is_expensive
                socket.events != 0 && notify(socket)
            end
            break
        end
    end
end

# By default, we send using _Message objects, which are optimized for
# small messages and copy the data.    If the caller wants zero-copy communications,
# then should explicitly create a Message() object, a more heavyweight object
# that allows zero-copy access.

"""
    send(socket::Socket, data; more=false)

Send `data` over `socket`.  A `more=true` keyword argument can be passed
to indicate that `data` is a portion of a larger multipart message.
`data` can be any `isbits` type, a `Vector` of `isbits` elements, a
`String`, or a [`Message`](@ref) object to perform zero-copy sends
of large arrays.
"""
function Sockets.send(socket::Socket, data; more::Bool=false)
    zmsg = _MessageRef(data)
    try
        _send(socket, zmsg, more)
    finally
        close(zmsg)
    end
end

"""
    send(socket::Socket, zmsg::Message; more::Bool=false)

Zero-copy version of [`Sockets.send(socket, data)`](@ref) using a user-allocated
[`Message`](@ref).
"""
Sockets.send(socket::Socket, zmsg::Message; more::Bool=false) = _send(socket, zmsg, more)

import Sockets: send
@deprecate send(socket::Socket, data, more::Bool) send(socket, data; more=more)

function Sockets.send(f::Function, socket::Socket; more::Bool=false)
    io = IOBuffer()
    f(io)
    send(socket, take!(io); more=more)
end

############################################################################

msg_recv(socket::Socket, zmsg::_MessageOrRef, flags::Integer) =
    ccall((:zmq_msg_recv, libzmq), Cint, (Ref{_Message}, Ptr{Cvoid}, Cint), zmsg, socket, flags)
msg_recv(socket::Socket, zmsg::Message, flags::Integer) =
    ccall((:zmq_msg_recv, libzmq), Cint, (Ref{Message}, Ptr{Cvoid}, Cint), zmsg, socket, flags)

function _recv!(socket::Socket, zmsg)
    while true
        if -1 == msg_recv(socket, zmsg, ZMQ_DONTWAIT)
            zmq_errno() == EAGAIN || throw(StateError(jl_zmq_error_str()))
            while socket.events & POLLIN== 0
                wait(socket)
            end
        else
            notify_is_expensive = !isempty(getfield(socket,:pollfd).notify.waitq)
            if notify_is_expensive
                socket.events != 0 && notify(socket)
            end
            break
        end
    end
    return zmsg
end

"""
    recv(socket::Socket)

Return a `Message` object representing a message received from a ZMQ `Socket`
(without making a copy of the message data).
"""
Sockets.recv(socket::Socket) = _recv!(socket, Message())

"""
    recv(socket::Socket, ::Type{T})

Receive a message of type `T` (typically a `String`, `Vector{UInt8}`, or
[`isbits`](https://docs.julialang.org/en/v1/base/base/#Base.isbits) type)
from a ZMQ [`Socket`](@ref).  (Makes a copy of the message data; you can alternatively
use [`recv(socket)`](@ref) to work with zero-copy bytearray-like representation for
large messages.)

"""
function Sockets.recv(socket::Socket, ::Type{T}) where {T}
    zmsg = msg_init()
    try
        _recv!(socket, zmsg)
        return unsafe_copy(T, zmsg)
    finally
        close(zmsg)
    end
end
    Û÷à