path: root/lib/erl_interface/doc/src/ei_connect.xml

<?xml version="1.0" encoding="utf-8" ?>
<!DOCTYPE cref SYSTEM "cref.dtd">

<cref>
  <header>
    <copyright>
      <year>2001</year><year>2016</year>
      <holder>Ericsson AB. All Rights Reserved.</holder>
    </copyright>
    <legalnotice>
      Licensed under the Apache License, Version 2.0 (the "License");
      you may not use this file except in compliance with the License.
      You may obtain a copy of the License at

          http://www.apache.org/licenses/LICENSE-2.0

      Unless required by applicable law or agreed to in writing, software
      distributed under the License is distributed on an "AS IS" BASIS,
      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
      See the License for the specific language governing permissions and
      limitations under the License.

    </legalnotice>

    <title>ei_connect</title>
    <prepared>Jakob Cederlund</prepared>
    <docno></docno>
    <approved></approved>
    <checked></checked>
    <date>2001-09-01</date>
    <rev>A</rev>
    <file>ei_connect.xml</file>
  </header>
  <lib>ei_connect</lib>
  <libsummary>Communicate with distributed Erlang.</libsummary>
  <description>
    <p>This module enables C-programs to communicate with Erlang nodes,
      using the Erlang distribution over TCP/IP.</p>

    <p>A C-node appears to Erlang as a <em>hidden node</em>.
      That is, Erlang processes that know the name of the
      C-node can communicate with it in a normal manner, but
      the node name is not shown in the listing provided by
      <seealso marker="erts:erlang#nodes/0"><c>erlang:nodes/0</c></seealso>
      in <c>ERTS</c>.</p>

    <p>The environment variable <c>ERL_EPMD_PORT</c> can be used
      to indicate which logical cluster a C-node belongs to.</p>
  </description>

  <section>
    <title>Time-Out Functions</title>
    <p>Most functions appear in a version with the suffix
      <c>_tmo</c> appended to the function name. Those functions
      take an extra argument, a time-out in <em>milliseconds</em>. The
      semantics is this: for each communication primitive involved in
      the operation, if the primitive does not complete within the time
      specified, the function returns an error and
      <c>erl_errno</c> is set to <c>ETIMEDOUT</c>.
      With communication primitive is meant an operation on the socket, like
      <c>connect</c>, <c>accept</c>,
      <c>recv</c>, or <c>send</c>.</p>

    <p>Clearly the time-outs are for implementing fault tolerance,
      not to keep hard real-time promises. The <c>_tmo</c> functions
      are for detecting non-responsive peers and to avoid blocking on
      socket operations.</p>

    <p>A time-out value of <c>0</c> (zero) means that time-outs are
      disabled. Calling a <c>_tmo</c> function with the last
      argument as <c>0</c> is therefore the same thing as calling
      the function without the <c>_tmo</c> suffix.</p>

    <p>As with all other functions starting with <c>ei_</c>,
      you are <em>not</em> expected
      to put the socket in non-blocking mode yourself in the program. Every
      use of non-blocking mode is embedded inside the time-out
      functions. The socket will always be back in blocking mode after
      the operations are completed (regardless of the result). To
      avoid problems, leave the socket options alone. <c>ei</c> handles
      any socket options that need modification.</p>

    <p>In all other senses, the <c>_tmo</c> functions inherit all
      the return values and the semantics from the functions without
      the <c>_tmo</c> suffix.</p>
  </section>

  <funcs>
    <func>
      <name since=""><ret>struct hostent *</ret><nametext>ei_gethostbyaddr(const char *addr, int len, int type)</nametext></name>
      <name since=""><ret>struct hostent *</ret><nametext>ei_gethostbyaddr_r(const char *addr, int length,  int type,  struct hostent *hostp, char *buffer,   int buflen,  int *h_errnop)</nametext></name>
      <name since=""><ret>struct hostent *</ret><nametext>ei_gethostbyname(const char *name)</nametext></name>
      <name since=""><ret>struct hostent *</ret><nametext>ei_gethostbyname_r(const char *name,  struct hostent *hostp,  char *buffer,  int buflen,  int *h_errnop)</nametext></name>
      <fsummary>Name lookup functions.</fsummary>
      <desc>
        <p>Convenience functions for some common name lookup functions.</p>
      </desc>
    </func>

    <func>
      <name since=""><ret>int</ret><nametext>ei_accept(ei_cnode *ec, int listensock, ErlConnect *conp)</nametext></name>
      <fsummary>Accept a connection from another node.</fsummary>
      <desc>
        <p>Used by a server process to accept a
          connection from a client process.</p>
        <list type="bulleted">
          <item>
            <p><c>ec</c> is the C-node structure.</p>
          </item>
          <item>
            <p><c>listensock</c> is an open socket descriptor on
              which <c>listen()</c> has previously been called.</p>
          </item>
          <item>
            <p><c>conp</c> is a pointer to an
              <c>ErlConnect</c> struct, described as follows:</p>
            <code type="none"><![CDATA[
typedef struct {
  char ipadr[4];             
  char nodename[MAXNODELEN];
} ErlConnect;
        ]]></code>
          </item>
        </list>
        <p>On success, <c>conp</c> is filled in with the address and
          node name of the connecting client and a file descriptor is
          returned. On failure, <c>ERL_ERROR</c> is returned and
          <c>erl_errno</c> is set to <c>EIO</c>.</p>
      </desc>
    </func>

    <func>
      <name since=""><ret>int</ret><nametext>ei_accept_tmo(ei_cnode *ec, int listensock, ErlConnect *conp, unsigned timeout_ms)</nametext></name>
      <fsummary>Accept a connection from another node with optional
        time-out.</fsummary>
      <desc>
        <p>Equivalent to
          <c>ei_accept</c> with an optional time-out argument,
          see the description at the beginning of this manual page.</p>
      </desc>
    </func>

    <func>
      <name since=""><ret>int</ret><nametext>ei_connect(ei_cnode* ec, char *nodename)</nametext></name>
      <name since=""><ret>int</ret><nametext>ei_xconnect(ei_cnode* ec, Erl_IpAddr adr, char *alivename)</nametext></name>
      <fsummary>Establish a connection to an Erlang node.</fsummary>
      <desc>
        <p>Sets up a connection to an Erlang node.</p>
        <p><c>ei_xconnect()</c> requires the IP address of the
          remote host and the alive name of the remote node to be
          specified. <c>ei_connect()</c> provides an alternative
          interface and determines the information from the node name
          provided.</p>
        <list type="bulleted">
          <item><c>addr</c> is the 32-bit IP address of the remote
            host.</item>
          <item><c>alive</c> is the alivename of the remote node.
          </item>
          <item><c>node</c> is the name of the remote node.</item>
        </list>
        <p>These functions return an open file descriptor on success, or
          a negative value indicating that an error occurred. In the latter
          case they set <c>erl_errno</c> to one of the
          following:</p>
        <taglist>
          <tag><c>EHOSTUNREACH</c></tag>
          <item>The remote host <c>node</c> is unreachable.</item>
          <tag><c>ENOMEM</c></tag>
          <item>No more memory is available.</item>
          <tag><c>EIO</c></tag>
          <item>I/O error.</item>
        </taglist>
        <p>Also, <c>errno</c> values from
          <c>socket</c><em>(2)</em> and
          <c>connect</c><em>(2)</em>
          system calls may be propagated into <c>erl_errno</c>.</p>
        <p><em>Example:</em></p>
        <code type="none"><![CDATA[
#define NODE   "[email protected]"
#define ALIVE  "madonna"
#define IP_ADDR "150.236.14.75"

/*** Variant 1 ***/
int fd = ei_connect(&ec, NODE);

/*** Variant 2 ***/
struct in_addr addr;
addr.s_addr = inet_addr(IP_ADDR);
fd = ei_xconnect(&ec, &addr, ALIVE);
        ]]></code>
      </desc>
    </func>

    <func>
      <name since=""><ret>int</ret><nametext>ei_connect_init(ei_cnode* ec, const char* this_node_name, const char *cookie, short creation)</nametext></name>
      <name since=""><ret>int</ret><nametext>ei_connect_xinit(ei_cnode* ec, const char *thishostname, const char *thisalivename, const char *thisnodename, Erl_IpAddr thisipaddr, const char *cookie, short creation)</nametext></name>
      <fsummary>Initialize for a connection.</fsummary>
      <desc>
        <p>Initializes the <c>ec</c> structure, to
          identify the node name and cookie of the server. One of them
          must be called before other functions that works on the
          <c>ei_cnode</c> type or a file descriptor associated with
          a connection to another node is used.</p>
        <list type="bulleted">
          <item>
            <p><c>ec</c> is a structure containing information about
              the C-node. It is used in other <c>ei</c> functions
              for connecting and receiving data.</p>
          </item>
          <item>
            <p><c>this_node_name</c> is the registered name of the
              process (the name before '@').</p>
          </item>
          <item>
            <p><c>cookie</c> is the cookie for the node.</p>
          </item>
          <item>
            <p><c>creation</c> identifies a specific instance of a
              C-node. It can help prevent the node from receiving messages
              sent to an earlier process with the same registered name.</p>
          </item>
          <item>
            <p><c>thishostname</c> is the name of the machine we are
              running on. If long names are to be used, they are to be fully
              qualified (that is, <c>durin.erix.ericsson.se</c>
              instead of <c>durin</c>).</p>
          </item>
          <item>
            <p><c>thisalivename</c> is the registered name of the
              process.</p>
          </item>
          <item>
            <p><c>thisnodename</c> is the full name of the node,
              that is, <c>einode@durin</c>.</p>
          </item>
          <item>
            <p><c>thispaddr</c> if the IP address of the host.</p>
          </item>
        </list>
        <p>A C-node acting as a server is assigned a creation
          number when it calls <c>ei_publish()</c>.</p>
        <p>A connection is closed by simply closing the socket.
          For information about how to close the socket gracefully (when
          there are outgoing packets before close), see the relevant system
          documentation.</p>
        <p>These functions return a negative value indicating that an error
          occurred.</p>
        <p><em>Example 1:</em></p>
        <code type="none"><![CDATA[
int n = 0;
struct in_addr addr;
ei_cnode ec;
addr.s_addr = inet_addr("150.236.14.75");
if (ei_connect_xinit(&ec,
                     "chivas",
                     "madonna",
                     "[email protected]",
                     &addr;
                     "cookie...",
                     n++) < 0) {
    fprintf(stderr,"ERROR when initializing: %d",erl_errno);
    exit(-1);
}
        ]]></code>
        <p><em>Example 2:</em></p>
        <code type="none"><![CDATA[
if (ei_connect_init(&ec, "madonna", "cookie...", n++) < 0) {
    fprintf(stderr,"ERROR when initializing: %d",erl_errno);
    exit(-1);
}
        ]]></code>
      </desc>
    </func>

    <func>
      <name since=""><ret>int</ret><nametext>ei_connect_tmo(ei_cnode* ec, char *nodename, unsigned timeout_ms)</nametext></name>
      <name since=""><ret>int</ret><nametext>ei_xconnect_tmo(ei_cnode* ec, Erl_IpAddr adr, char *alivename, unsigned timeout_ms)</nametext></name>
      <fsummary>Establish a connection to an Erlang node with optional
        time-out.</fsummary>
      <desc>
        <p>Equivalent to
          <c>ei_connect</c> and <c>ei_xconnect</c> with an optional time-out
          argument, see the description at the beginning of this manual
          page.</p>
      </desc>
    </func>

    <func>
      <name since="OTP R13B04"><ret>int</ret><nametext>ei_get_tracelevel(void)</nametext></name>
      <name since="OTP R13B04"><ret>void</ret><nametext>ei_set_tracelevel(int level)</nametext></name>
      <fsummary>Get and set functions for tracing.</fsummary>
      <desc>
        <p>Used to set tracing on the distribution. The levels are different
          verbosity levels. A higher level means more information. See also
          section <seealso marker="#debug_information">
          Debug Information</seealso>.</p>
	<p>These functions are not thread safe.</p>
      </desc>
    </func>

    <func>
      <name since=""><ret>int</ret><nametext>ei_publish(ei_cnode *ec, int port)</nametext></name>
      <fsummary>Publish a node name.</fsummary>
      <desc>
        <p>Used by a server process to register
          with the local name server EPMD, thereby allowing
          other processes to send messages by using the registered name.
          Before calling either of these functions, the process should
          have called <c>bind()</c> and <c>listen()</c>
          on an open socket.</p>
        <list type="bulleted">
          <item>
            <p><c>ec</c> is the C-node structure.</p>
          </item>
          <item>
            <p><c>port</c> is the local name to register, and is to
              be the same as the port number that was previously bound to the
              socket.</p>
          </item>
          <item>
            <p><c>addr</c> is the 32-bit IP address of the local
              host.</p>
          </item>
        </list>
        <p>To unregister with EPMD, simply close the returned descriptor. Do
          not use <c>ei_unpublish()</c>, which is deprecated
          anyway.</p>
        <p>On success, the function returns a descriptor connecting the
          calling process to EPMD. On failure, <c>-1</c> is returned and
          <c>erl_errno</c> is set to <c>EIO</c>.</p>
        <p>Also, <c>errno</c> values from
          <c>socket</c><em>(2)</em> and
          <c>connect</c><em>(2)</em> system calls may be propagated
          into <c>erl_errno</c>.</p>
      </desc>
    </func>

    <func>
      <name since=""><ret>int</ret><nametext>ei_publish_tmo(ei_cnode *ec, int port, unsigned timeout_ms)</nametext></name>
      <fsummary>Publish a node name with optional time-out.</fsummary>
      <desc>
        <p>Equivalent to
          <c>ei_publish</c> with an optional time-out argument,
          see the description at the beginning of this manual page.</p>
      </desc>
    </func>

    <func>
      <name since=""><ret>int</ret><nametext>ei_receive(int fd, unsigned char* bufp, int bufsize)</nametext></name>
      <fsummary>Receive a message.</fsummary>
      <desc>
        <p>Receives a message consisting of a sequence
          of bytes in the Erlang external format.</p>
        <list type="bulleted">
          <item>
            <p><c>fd</c> is an open descriptor to an Erlang
              connection. It is obtained from a previous
              <c>ei_connect</c> or <c>ei_accept</c>.</p>
          </item>
          <item>
            <p><c>bufp</c> is a buffer large enough to hold the
              expected message.</p>
          </item>
          <item>
            <p><c>bufsize</c> indicates the size of
              <c>bufp</c>.</p>
          </item>
        </list>
        <p>If a <em>tick</em> occurs, that is, the Erlang node on the
          other end of the connection has polled this node to see if it
          is still alive, the function returns <c>ERL_TICK</c> and
          no message is placed in the buffer. Also,
          <c>erl_errno</c> is set to <c>EAGAIN</c>.</p>
        <p>On success, the message is placed in the specified buffer
          and the function returns the number of bytes actually read. On
          failure, the function returns <c>ERL_ERROR</c> and sets
          <c>erl_errno</c> to one of the following:</p>
        <taglist>
          <tag><c>EAGAIN</c></tag>
          <item>Temporary error: Try again.</item>
          <tag><c>EMSGSIZE</c></tag>
          <item>Buffer is too small.</item>
          <tag><c>EIO</c></tag>
          <item>I/O error.</item>
        </taglist>
      </desc>
    </func>

    <func>
      <name since=""><ret>int</ret><nametext>ei_receive_encoded(int fd, char **mbufp, int *bufsz,  erlang_msg *msg, int *msglen)</nametext></name>
      <fsummary>Obsolete function for receiving a message.</fsummary>
      <desc>
        <p>This function is retained for compatibility with code
          generated by the interface compiler and with code following
          examples in the same application.</p>
        <p>In essence, the function performs the same operation as
          <c>ei_xreceive_msg</c>, but instead of using an
          <c>ei_x_buff</c>, the function expects a pointer to a character
          pointer (<c>mbufp</c>), where the character pointer
          is to point to a memory area allocated by <c>malloc</c>.
          Argument <c>bufsz</c> is to be a pointer to an integer
          containing the exact size (in bytes) of the memory area. The function
          may reallocate the memory area and will in such cases put the new
          size in <c>*bufsz</c> and update
          <c>*mbufp</c>.</p>
        <p>Returns either <c>ERL_TICK</c> or the
          <c>msgtype</c> field of the
          <c>erlang_msg *msg</c>. The length
          of the message is put in <c>*msglen</c>. On error
          a value <c>&lt; 0</c> is returned.</p>
        <p>It is recommended to use <c>ei_xreceive_msg</c> instead when
          possible, for the sake of readability. However, the function will
          be retained in the interface for compatibility and
          will <em>not</em> be removed in future releases without prior
          notice.</p>
      </desc>
    </func>

    <func>
      <name since=""><ret>int</ret><nametext>ei_receive_encoded_tmo(int fd, char **mbufp, int *bufsz,  erlang_msg *msg, int *msglen, unsigned timeout_ms)</nametext></name>
      <fsummary>Obsolete function for receiving a message with time-out.
      </fsummary>
      <desc>
        <p>Equivalent to
          <c>ei_receive_encoded</c> with an optional time-out argument,
          see the description at the beginning of this manual page.</p>
      </desc>
    </func>

    <func>
      <name since=""><ret>int</ret><nametext>ei_receive_msg(int fd, erlang_msg* msg, ei_x_buff* x)</nametext></name>
      <name since=""><ret>int</ret><nametext>ei_xreceive_msg(int fd, erlang_msg* msg, ei_x_buff* x)</nametext></name>
      <fsummary>Receive a message.</fsummary>
      <desc>
        <p>Receives a message to the buffer in <c>x</c>.
          <c>ei_xreceive_msg</c> allows the buffer in
          <c>x</c> to grow, but <c>ei_receive_msg</c>
          fails if the message is larger than the pre-allocated buffer in
          <c>x</c>.</p>
        <list type="bulleted">
          <item><c>fd</c> is an open descriptor to an Erlang
            connection.</item>
          <item><c>msg</c> is a pointer to an
            <c>erlang_msg</c> structure
            and contains information on the message received.</item>
          <item><c>x</c> is buffer obtained from
            <c>ei_x_new</c>.</item>
        </list>
        <p>On success, the functions return <c>ERL_MSG</c> and the
          <c>msg</c> struct is initialized.
          <c>erlang_msg</c> is defined as follows:</p>
        <code type="none"><![CDATA[
typedef struct {
    long msgtype;
    erlang_pid from;
    erlang_pid to;
    char toname[MAXATOMLEN+1];
    char cookie[MAXATOMLEN+1];
    erlang_trace token;
} erlang_msg;
        ]]></code>
        <p><c>msgtype</c> identifies the type of message, and is
          one of the following:</p>
        <taglist>
          <tag><c>ERL_SEND</c></tag>
          <item>
            <p>Indicates that an ordinary send operation has occurred.
              <c>msg-&gt;to</c> contains the pid of the recipient (the
              C-node).</p>
          </item>
          <tag><c>ERL_REG_SEND</c></tag>
          <item>
            <p>A registered send operation occurred.
              <c>msg-&gt;from</c> contains the pid of the sender.</p>
          </item>
          <tag><c>ERL_LINK</c> or
            <c>ERL_UNLINK</c></tag>
          <item>
            <p><c>msg-&gt;to</c> and
              <c>msg-&gt;from</c> contain the pids of the
              sender and recipient of the link or unlink.</p>
          </item>
          <tag><c>ERL_EXIT</c></tag>
          <item>
            <p>Indicates a broken link. <c>msg-&gt;to</c> and
              <c>msg-&gt;from</c> contain the pids of the linked
               processes.</p>
          </item>
        </taglist>
        <p>The return value is the same as for
          <seealso marker="#ei_receive"><c>ei_receive</c></seealso>.</p>
      </desc>
    </func>

    <func>
      <name since=""><ret>int</ret><nametext>ei_receive_msg_tmo(int fd, erlang_msg* msg, ei_x_buff* x, unsigned imeout_ms)</nametext></name>
      <name since=""><ret>int</ret><nametext>ei_xreceive_msg_tmo(int fd, erlang_msg* msg, ei_x_buff* x, unsigned timeout_ms)</nametext></name>
      <fsummary>Receive a message with optional time-out.</fsummary>
      <desc>
        <p>Equivalent to <c>ei_receive_msg</c> and <c>ei_xreceive_msg</c>
          with an optional time-out argument,
          see the description at the beginning of this manual page.</p>
      </desc>
    </func>

    <func>
      <name since=""><ret>int</ret><nametext>ei_receive_tmo(int fd, unsigned char* bufp, int bufsize, unsigned timeout_ms)</nametext></name>
      <fsummary>Receive a message with optional time-out.</fsummary>
      <desc>
        <p>Equivalent to
          <c>ei_receive</c> with an optional time-out argument,
          see the description at the beginning of this manual page.</p>
      </desc>
    </func>

    <func>
      <name since=""><ret>int</ret><nametext>ei_reg_send(ei_cnode* ec, int fd, char* server_name, char* buf, int len)</nametext></name>
      <fsummary>Send a message to a registered name.</fsummary>
      <desc>
        <p>Sends an Erlang term to a registered process.</p>
        <list type="bulleted">
          <item>
            <p><c>fd</c> is an open descriptor to an Erlang
              connection.</p>
          </item>
          <item><c>server_name</c> is the registered name of the
            intended recipient.</item>
          <item><c>buf</c> is the buffer containing the term in
            binary format.</item>
          <item><c>len</c> is the length of the message in bytes.
          </item>
        </list>
        <p>Returns <c>0</c> if successful, otherwise <c>-1</c>. In
          the latter case it sets <c>erl_errno</c> to
          <c>EIO</c>.</p>
        <p><em>Example:</em></p>
        <p>Send the atom "ok" to the process "worker":</p>
        <code type="none"><![CDATA[
ei_x_buff x;
ei_x_new_with_version(&x);
ei_x_encode_atom(&x, "ok");
if (ei_reg_send(&ec, fd, x.buff, x.index) < 0)
    handle_error();
        ]]></code>
      </desc>
    </func>

    <func>
      <name since=""><ret>int</ret><nametext>ei_reg_send_tmo(ei_cnode* ec, int fd, char* server_name, char* buf, int len, unsigned timeout_ms)</nametext></name>
      <fsummary>Send a message to a registered name with optional time-out
      </fsummary>
      <desc>
        <p>Equivalent to
          <c>ei_reg_send</c> with an optional time-out argument,
          see the description at the beginning of this manual page.</p>
      </desc>
    </func>

    <func>
      <name since=""><ret>int</ret><nametext>ei_rpc(ei_cnode *ec, int fd, char *mod, char *fun, const char *argbuf, int argbuflen, ei_x_buff *x)</nametext></name>
      <name since=""><ret>int</ret><nametext>ei_rpc_to(ei_cnode *ec, int fd, char *mod, char *fun, const char *argbuf, int argbuflen)</nametext></name>
      <name since=""><ret>int</ret><nametext>ei_rpc_from(ei_cnode *ec, int fd, int timeout, erlang_msg *msg, ei_x_buff *x)</nametext></name>
      <fsummary>Remote Procedure Call from C to Erlang.</fsummary>
      <desc>
        <p>Supports calling Erlang functions on remote nodes.
          <c>ei_rpc_to()</c> sends an RPC request to a remote node
          and <c>ei_rpc_from()</c> receives the results of such a
          call. <c>ei_rpc()</c> combines the functionality of these
          two functions by sending an RPC request and waiting for the results.
          See also <seealso marker="kernel:rpc#call/4">
          <c>rpc:call/4</c></seealso> in Kernel.</p>
        <list type="bulleted">
          <item>
            <p><c>ec</c> is the C-node structure previously
              initiated by a call to <c>ei_connect_init()</c> or
              <c>ei_connect_xinit()</c>.</p>
          </item>
          <item>
            <p><c>fd</c> is an open descriptor to an Erlang
              connection.</p>
          </item>
          <item>
            <p><c>timeout</c> is the maximum time (in milliseconds)
              to wait for results. Specify <c>ERL_NO_TIMEOUT</c> to
              wait forever.
              <c>ei_rpc()</c> waits infinitely for the answer,
              that is, the call will never time out.</p>
          </item>
          <item>
            <p><c>mod</c> is the name of the module containing the
              function to be run on the remote node.</p>
          </item>
          <item>
            <p><c>fun</c> is the name of the function to run.</p>
          </item>
          <item>
            <p><c>argbuf</c> is a pointer to a buffer with an
              encoded Erlang list, without a version magic number, containing
              the arguments to be passed to the function.</p>
          </item>
          <item>
            <p><c>argbuflen</c> is the length of the buffer
              containing the encoded Erlang list.</p>
          </item>
          <item>
            <p><c>msg</c> is structure of type
              <c>erlang_msg</c> and contains information on the
              message
              received. For a description of the <c>erlang_msg</c>
              format, see <seealso marker="#ei_receive_msg">
              <c>ei_receive_msg</c></seealso>.</p>
          </item>
          <item>
            <p><c>x</c> points to the dynamic buffer that receives
              the result. For <c>ei_rpc()</c> this is the result
              without the version magic number. For
              <c>ei_rpc_from()</c> the result returns a version
              magic number and a 2-tuple <c>{rex,Reply}</c>.</p>
          </item>
        </list>
        <p><c>ei_rpc()</c> returns the number of bytes in the
          result on success and <c>-1</c> on failure.
          <c>ei_rpc_from()</c> returns the
          number of bytes, otherwise one of <c>ERL_TICK</c>,
          <c>ERL_TIMEOUT</c>,
          and <c>ERL_ERROR</c>. When failing, all three
          functions set <c>erl_errno</c> to one of the
          following:</p>
        <taglist>
          <tag><c>EIO</c></tag>
          <item>I/O error.</item>
          <tag><c>ETIMEDOUT</c></tag>
          <item>Time-out expired.</item>
          <tag><c>EAGAIN</c></tag>
          <item>Temporary error: Try again.</item>
        </taglist>
        <p><em>Example:</em></p>
        <p>Check to see if an Erlang process is alive:</p>
        <code type="none"><![CDATA[
int index = 0, is_alive;
ei_x_buff args, result;

ei_x_new(&result);
ei_x_new(&args);
ei_x_encode_list_header(&args, 1);
ei_x_encode_pid(&args, &check_pid);
ei_x_encode_empty_list(&args);

if (ei_rpc(&ec, fd, "erlang", "is_process_alive",
           args.buff, args.index, &result) < 0)
    handle_error();

if (ei_decode_version(result.buff, &index) < 0
    || ei_decode_bool(result.buff, &index, &is_alive) < 0)
    handle_error();
        ]]></code>
      </desc>
    </func>

    <func>
      <name since=""><ret>erlang_pid *</ret><nametext>ei_self(ei_cnode *ec)</nametext></name>
      <fsummary>Retrieve the pid of the C-node.</fsummary>
      <desc>
        <p>Retrieves the pid of the C-node. Every C-node
          has a (pseudo) pid used in <c>ei_send_reg</c>,
          <c>ei_rpc</c>,
          and others. This is contained in a field in the <c>ec</c>
          structure. It will be safe for a long time to fetch this
          field directly from the <c>ei_cnode</c> structure.</p>
      </desc>
    </func>

    <func>
      <name since=""><ret>int</ret><nametext>ei_send(int fd, erlang_pid* to, char* buf, int len)</nametext></name>
      <fsummary>Send a message.</fsummary>
      <desc>
        <p>Sends an Erlang term to a process.</p>
        <list type="bulleted">
          <item><c>fd</c> is an open descriptor to an Erlang
            connection.</item>
          <item><c>to</c> is the pid of the intended recipient of
            the message.</item>
          <item><c>buf</c> is the buffer containing the term in
            binary format.</item>
          <item><c>len</c> is the length of the message in bytes.
          </item>
        </list>
        <p>Returns <c>0</c> if successful, otherwise <c>-1</c>. In
          the latter case it sets <c>erl_errno</c> to
          <c>EIO</c>.</p>
      </desc>
    </func>

    <func>
      <name since=""><ret>int</ret><nametext>ei_send_encoded(int fd, erlang_pid* to, char* buf, int len)</nametext></name>
      <fsummary>Obsolete function to send a message.</fsummary>
      <desc>
        <p>Works exactly as <c>ei_send</c>, the alternative name is retained for
          backward compatibility. The function will <em>not</em> be
          removed without prior notice.</p>
      </desc>
    </func>

    <func>
      <name since=""><ret>int</ret><nametext>ei_send_encoded_tmo(int fd, erlang_pid* to, char* buf, int len, unsigned timeout_ms)</nametext></name>
      <fsummary>Obsolete function to send a message with optional time-out.
      </fsummary>
      <desc>
        <p>Equivalent to
          <c>ei_send_encoded</c> with an optional time-out argument,
          see the description at the beginning of this manual page.</p>
      </desc>
    </func>

    <func>
      <name since=""><ret>int</ret><nametext>ei_send_reg_encoded(int fd, const erlang_pid *from, const char *to, const char *buf, int len)</nametext></name>
      <fsummary>Obsolete function to send a message to a registered name.
      </fsummary>
      <desc>
        <p>This function is retained for compatibility with code
          generated by the interface compiler and with code following
          examples in the same application.</p>
        <p>The function works as <c>ei_reg_send</c> with one
          exception. Instead of taking <c>ei_cnode</c> as first
          argument, it takes a second argument, an
          <c>erlang_pid</c>,
          which is to be the process identifier of the sending process
          (in the Erlang distribution protocol).</p>
        <p>A suitable <c>erlang_pid</c> can be constructed from the
          <c>ei_cnode</c> structure by the following example
          code:</p>
        <code type="none"><![CDATA[
ei_cnode ec;
erlang_pid *self;
int fd; /* the connection fd */
...
self = ei_self(&ec);
self->num = fd;
        ]]></code>
      </desc>
    </func>

    <func>
      <name since=""><ret>int</ret><nametext>ei_send_reg_encoded_tmo(int fd, const erlang_pid *from, const char *to, const char *buf, int len)</nametext></name>
      <fsummary>Obsolete function to send a message to a registered name with
        time-out.</fsummary>
      <desc>
        <p>Equivalent to
          <c>ei_send_reg_encoded</c> with an optional time-out argument,
          see the description at the beginning of this manual page.</p>
      </desc>
    </func>

    <func>
      <name since=""><ret>int</ret><nametext>ei_send_tmo(int fd, erlang_pid* to, char* buf, int len, unsigned timeout_ms)</nametext></name>
      <fsummary>Send a message with optional time-out.</fsummary>
      <desc>
        <p>Equivalent to
          <c>ei_send</c> with an optional time-out argument,
          see the description at the beginning of this manual page.</p>
      </desc>
    </func>

    <func>
      <name since=""><ret>const char *</ret><nametext>ei_thisnodename(ei_cnode *ec)</nametext></name>
      <name since=""><ret>const char *</ret><nametext>ei_thishostname(ei_cnode *ec)</nametext></name>
      <name since=""><ret>const char *</ret><nametext>ei_thisalivename(ei_cnode *ec)</nametext></name>
      <fsummary>Retrieve some values.</fsummary>
      <desc>
        <p>Can be used to retrieve information about
          the C-node. These values are initially set with
          <c>ei_connect_init()</c> or
          <c>ei_connect_xinit()</c>.</p>
        <p>These function simply fetch the appropriate field from the
          <c>ec</c>
          structure. Read the field directly will probably be safe for
          a long time, so these functions are not really needed.</p>
      </desc>
    </func>

    <func>
      <name since=""><ret>int</ret><nametext>ei_unpublish(ei_cnode *ec)</nametext></name>
      <fsummary>Forcefully unpublish a node name.</fsummary>
      <desc>
        <p>Can be called by a process to unregister a
          specified node from EPMD on the local host. This is, however, usually
	  not allowed, unless EPMD was started with flag
          <c>-relaxed_command_check</c>, which it normally is not.</p>
        <p>To unregister a node you have published, you should
	  close the descriptor that was returned by
	  <c>ei_publish()</c>.</p>
        <warning>
          <p>This function is deprecated and will be removed in a future
	  release.</p>
        </warning>
        <p><c>ec</c> is the node structure of the node to
          unregister.</p>
        <p>If the node was successfully unregistered from EPMD, the
          function returns <c>0</c>. Otherwise, <c>-1</c> is returned and
          <c>erl_errno</c> is set to <c>EIO</c>.</p>
      </desc>
    </func>

    <func>
      <name since=""><ret>int</ret><nametext>ei_unpublish_tmo(ei_cnode *ec, unsigned timeout_ms)</nametext></name>
      <fsummary>Unpublish a node name with optional time-out.</fsummary>
      <desc>
        <p>Equivalent to
          <c>ei_unpublish</c> with an optional time-out argument,
          see the description at the beginning of this manual page.</p>
      </desc>
    </func>
  </funcs>

  <section>
    <marker id="debug_information"></marker>
    <title>Debug Information</title>
    <p>If a connection attempt fails, the following can be checked:</p>

    <list type="bulleted">
      <item><c>erl_errno</c>.</item>
      <item>That the correct cookie was used</item>
      <item>That EPMD is running</item>
      <item>That the remote Erlang node on the other side is running the
        same version of Erlang as the <c>ei</c> library</item>
      <item>That environment variable <c>ERL_EPMD_PORT</c>
        is set correctly</item>
    </list>

    <p>The connection attempt can be traced by setting a trace level by either
      using <c>ei_set_tracelevel</c> or by setting environment
      variable <c>EI_TRACELEVEL</c>.
      The trace levels have the following messages:</p>

    <list>
        <item>1: Verbose error messages</item>
        <item>2: Above messages and verbose warning messages</item>
        <item>3: Above messages and progress reports for connection handling
        </item>
        <item>4: Above messages and progress reports for communication</item>
        <item>5: Above messages and progress reports for data conversion</item>
    </list>
  </section>

</cref>