path: root/src/examples/ecore/efl_io_copier_example.c

#include <Efl_Net.h>
#include <Ecore_Getopt.h>
#include <fcntl.h>

static int retval = EXIT_SUCCESS;

/* NOTE: input events are only used as debug, you can omit these */

static void
_input_can_read_changed(void *data EINA_UNUSED, const Efl_Event *event)
{
   fprintf(stderr, "INFO: input can_read=%d\n",
           efl_io_reader_can_read_get(event->object));
}

static void
_input_eos(void *data EINA_UNUSED, const Efl_Event *event)
{
   fprintf(stderr, "INFO: input eos=%d\n",
           efl_io_reader_eos_get(event->object));
}

EFL_CALLBACKS_ARRAY_DEFINE(input_cbs,
                           { EFL_IO_READER_EVENT_CAN_READ_CHANGED, _input_can_read_changed },
                           { EFL_IO_READER_EVENT_EOS, _input_eos });


/* NOTE: output events are only used as debug, you can omit these */

static void
_output_can_write_changed(void *data EINA_UNUSED, const Efl_Event *event)
{
   fprintf(stderr, "INFO: output can_write=%d\n",
           efl_io_writer_can_write_get(event->object));
}

EFL_CALLBACKS_ARRAY_DEFINE(output_cbs,
                           { EFL_IO_WRITER_EVENT_CAN_WRITE_CHANGED, _output_can_write_changed });

static void
_output_buffer_reallocated(void *data EINA_UNUSED, const Efl_Event *event)
{
   Eina_Slice slice = efl_io_buffer_slice_get(event->object);

   fprintf(stderr, "INFO: output buffer reallocated=" EINA_SLICE_FMT "\n",
           EINA_SLICE_PRINT(slice));
}

EFL_CALLBACKS_ARRAY_DEFINE(output_buffer_cbs,
                           { EFL_IO_BUFFER_EVENT_REALLOCATED, _output_buffer_reallocated });


static void
_dialer_resolved(void *data EINA_UNUSED, const Efl_Event *event)
{
   fprintf(stderr, "INFO: dialer resolved '%s' to '%s'\n",
           efl_net_dialer_address_dial_get(event->object),
           efl_net_socket_address_remote_get(event->object));
}

static void
_dialer_error(void *data EINA_UNUSED, const Efl_Event *event)
{
   const Eina_Error *perr = event->info;
   fprintf(stderr, "INFO: error: %d '%s'\n", *perr, eina_error_msg_get(*perr));
   retval = EXIT_FAILURE;
   /* no need to quit as copier will get a "eos" event and emit "done" */
}

static void
_dialer_connected(void *data EINA_UNUSED, const Efl_Event *event)
{
   fprintf(stderr, "INFO: dialer connected to '%s' (%s)\n",
           efl_net_dialer_address_dial_get(event->object),
           efl_net_socket_address_remote_get(event->object));
}

EFL_CALLBACKS_ARRAY_DEFINE(dialer_cbs,
                           { EFL_NET_DIALER_EVENT_RESOLVED, _dialer_resolved },
                           { EFL_NET_DIALER_EVENT_ERROR, _dialer_error },
                           { EFL_NET_DIALER_EVENT_CONNECTED, _dialer_connected });

static void
_http_headers_done(void *data EINA_UNUSED, const Efl_Event *event)
{
   Eina_Iterator *itr;
   Efl_Net_Http_Header *h;
   Efl_Net_Http_Version ver = efl_net_dialer_http_version_get(event->object);
   const char *response_content_type;
   int64_t response_content_length;

   fprintf(stderr, "INFO: HTTP/%d.%d connected to '%s', code=%d, headers:\n",
           ver / 100, ver % 100,
           efl_net_dialer_address_dial_get(event->object),
           efl_net_dialer_http_response_status_get(event->object));

   /* this is only for the last request, if allow_redirects and you want
    * all of the headers, use efl_net_dialer_http_response_headers_all_get()
    */
   itr = efl_net_dialer_http_response_headers_get(event->object);

   EINA_ITERATOR_FOREACH(itr, h)
     fprintf(stderr, "INFO: Header '%s: %s'\n", h->key, h->value);

   eina_iterator_free(itr);

   /* be nice to memory, we do not need these anymore */
   efl_net_dialer_http_response_headers_clear(event->object);

   response_content_length = efl_net_dialer_http_response_content_length_get(event->object);
   response_content_type = efl_net_dialer_http_response_content_type_get(event->object);
   fprintf(stderr, "INFO: Download %" PRId64 " bytes of type %s\n",
           response_content_length, response_content_type);

   if (efl_net_dialer_http_primary_mode_get(event->object) == EFL_NET_DIALER_HTTP_PRIMARY_MODE_UPLOAD)
     {
        int64_t request_content_type = efl_net_dialer_http_request_content_length_get(event->object);
        fprintf(stderr, "INFO: Upload %" PRId64 " bytes\n",
                request_content_type);
     }
}

static void
_http_closed(void *data EINA_UNUSED, const Efl_Event *event)
{
   uint64_t dn, dt, un, ut;

   efl_net_dialer_http_progress_download_get(event->object, &dn, &dt);
   efl_net_dialer_http_progress_upload_get(event->object, &un, &ut);
   fprintf(stderr, "INFO: http transfer info: "
           "download=%" PRIu64 "/%" PRIu64 " "
           "upload=%" PRIu64 "/%" PRIu64 "\n",
           dn, dt, un, ut);
}

EFL_CALLBACKS_ARRAY_DEFINE(http_cbs,
                           { EFL_NET_DIALER_HTTP_EVENT_HEADERS_DONE, _http_headers_done },
                           { EFL_IO_CLOSER_EVENT_CLOSED, _http_closed });

/* copier events are of interest, you should hook to at least "done"
 * and "error"
 */

static void
_copier_done(void *data EINA_UNUSED, const Efl_Event *event)
{
   Eo *destination = efl_io_copier_destination_get(event->object);

   if (!destination)
     {
        /* if :none: was used, you get Efl_Io_Copier to buffer all
         * source data up to efl_io_copier_buffer_limit_get().
         *
         * Then if it finished, you can steal the binbuf and do
         * something with that. It's a simple way to use
         * Efl_Io_Copier.
         */
        Eina_Binbuf *binbuf = efl_io_copier_binbuf_steal(event->object);

        fprintf(stderr,
                "INFO: :none: resulted in binbuf=%p, string=%p, size=%zd:"
                "\n--BEGIN DATA--\n"
                EINA_SLICE_STR_FMT
                "\n--END DATA--\n",
                binbuf,
                eina_binbuf_string_get(binbuf),
                eina_binbuf_length_get(binbuf),
                EINA_SLICE_STR_PRINT(eina_binbuf_slice_get(binbuf))
                );

        eina_binbuf_free(binbuf);
     }
   else if (efl_isa(destination, EFL_IO_BUFFER_CLASS))
     {
        /* if :memory: was used, then an Efl_Io_Buffer is created
         * implementing all the interfaces required by Efl_Io_Copier.
         *
         * This allows the buffer to be resized if source size is
         * known, avoiding realloc()s during execution.
         *
         * You can use:
         *
         *  - efl_io_buffer_slice_get() for a read-only view of that
         *    buffer,
         *
         * - efl_io_buffer_binbuf_steal() to take the buffer memory as
         *   an Eina_Binbuf, you own the ownership and must call
         *   eina_binbuf_free() to release it.
         */
        Eina_Slice slice = efl_io_buffer_slice_get(destination);
        fprintf(stderr,
                "INFO: :memory: resulted in slice=" EINA_SLICE_FMT ":"
                "\n--BEGIN DATA--\n"
                EINA_SLICE_STR_FMT
                "\n--END DATA--\n",
                EINA_SLICE_PRINT(slice), EINA_SLICE_STR_PRINT(slice));
     }

   fprintf(stderr, "INFO: done\n");
   efl_loop_quit(efl_loop_get(event->object), EINA_VALUE_EMPTY);
}

static void
_copier_error(void *data EINA_UNUSED, const Efl_Event *event)
{
   const Eina_Error *perr = event->info;
   fprintf(stderr, "INFO: error: %d '%s'\n", *perr, eina_error_msg_get(*perr));
   retval = EXIT_FAILURE;
   efl_loop_quit(efl_loop_get(event->object), EINA_VALUE_EMPTY);
}

static void
_copier_progress(void *data EINA_UNUSED, const Efl_Event *event)
{
   uint64_t r, w, t;

   efl_io_copier_progress_get(event->object, &r, &w, &t);
   /* if total is zero, that means the source object doesn't provide a
    * fixed size, consider it a "stream" such as a socket, a pipe,
    * stdin...
    */
   if (t == 0)
     fprintf(stderr, "INFO: read=%" PRIu64 ", written=%" PRIu64 "\n", r, w);
   else
     {
        fprintf(stderr,
                "INFO: read=%" PRIu64 ", written=%" PRIu64 ", total=%" PRIu64
                " (%4.1f%%/%4.1f%%)\n",
                r, w, t,
                (100.0 * r) / (double)t,
                (100.0 * w) / (double)t);
     }
}

static void
_copier_data(void *data EINA_UNUSED, const Efl_Event *event)
{
   const Eina_Slice *slice = event->info;
   /* a piece of data was processed, it's ready-only and will only be
    * good for immediate consumption.
    *
    * It's only usable inside this function as it may be gone (freed,
    * reallocated) once it return and more data is processed.
    *
    * Shall you want to take over the internal binbuf, use
    * efl_io_copier_binbuf_steal() and then stop event propagation
    * with efl_event_callback_stop().
    *
    * However be aware that other events will be dispatched with empty
    * slices, like if you steal the buffer here, _copier_line() will
    * get empty slice.
    */
   fprintf(stderr, "INFO: data: " EINA_SLICE_FMT "\n",
           EINA_SLICE_PRINT(*slice));
}

static void
_copier_line(void *data EINA_UNUSED, const Efl_Event *event)
{
   const Eina_Slice *slice = event->info;

   /* a line_delimiter was provided and a line was processed, it's
    * ready-only and will only be good for immediate consumption.
    *
    * It's only usable inside this function as it may be gone (freed,
    * reallocated) once it return and more data is processed.
    *
    * The line may not contain the line delimiter in the following
    * cases:
    *
    * - efl_io_copier_buffer_limit_set() was used and limit was
    *   reached.
    *
    * - source reached end-of-stream and pending data was there.
    *
    * Shall you want to take over the internal binbuf, use
    * efl_io_copier_binbuf_steal() and then stop event propagation
    * with efl_event_callback_stop().
    */

   fprintf(stderr, "INFO: line: " EINA_SLICE_STR_FMT "\n",
           EINA_SLICE_STR_PRINT(*slice));
}

EFL_CALLBACKS_ARRAY_DEFINE(copier_cbs,
                           { EFL_IO_COPIER_EVENT_DONE, _copier_done },
                           { EFL_IO_COPIER_EVENT_ERROR, _copier_error },
                           { EFL_IO_COPIER_EVENT_PROGRESS, _copier_progress },
                           { EFL_IO_COPIER_EVENT_DATA, _copier_data},
                           { EFL_IO_COPIER_EVENT_LINE, _copier_line});


static const Ecore_Getopt options = {
  "efl_io_copier_example", /* program name */
  NULL, /* usage line */
  "1", /* version */
  "(C) 2016 Enlightenment Project", /* copyright */
  "BSD 2-Clause", /* license */
  /* long description, may be multiline and contain \n */
  "Example of Efl_Io_Copier usage.\n"
  "\n"
  "This example copies from an Efl_Io_Reader to an Efl_Io_Writer, listening"
  "for events and showing progress.",
  EINA_FALSE,
  {
    ECORE_GETOPT_STORE_STR('d', "line-delimiter",
                           "If set will define a line delimiter for copy operation, instead of a fixed chunk size. This will trigger line events."),
    ECORE_GETOPT_STORE_ULONG('l', "buffer-limit",
                             "If set will limit buffer size to this limit of bytes. If used alongside with --line-delimiter and that delimiter was not found but bffer limit was reached, the line event will be triggered without the delimiter at the end."),
    ECORE_GETOPT_STORE_ULONG('c', "read-chunk-size",
                             "If set will change the base chunk size used while reading."),
    ECORE_GETOPT_STORE_DOUBLE('t', "inactivity-timeout",
                              "If greater than zero, specifies the number of seconds without any reads or writes that the copier will be timed out."),

    ECORE_GETOPT_STORE_FALSE(0, "no-ssl-verify",
                             "Disables SSL verify, to use with self-signed certificates and the likes"),

    ECORE_GETOPT_VERSION('V', "version"),
    ECORE_GETOPT_COPYRIGHT('C', "copyright"),
    ECORE_GETOPT_LICENSE('L', "license"),
    ECORE_GETOPT_HELP('h', "help"),

    ECORE_GETOPT_STORE_METAVAR_STR(0, NULL,
                                   "The input file name or:\n"
                                   ":stdin: to read from stdin.\n"
                                   "tcp://IP:PORT to connect using TCP and an IPv4 (A.B.C.D:PORT) or IPv6 ([A:B:C:D::E]:PORT).\n"
                                   "http://address to do a GET request\n"
                                   "ws://address or wss:// to do WebSocket request (must send some data once connected)\n"
                                   "udp://IP:PORT to bind using UDP and an IPv4 (A.B.C.D:PORT) or IPv6 ([A:B:C:D::E]:PORT).\n"
#ifdef EFL_NET_DIALER_WINDOWS_CLASS
                                   "windows://path to connect to an Windows NamedPipe server. It will have '\\\\.pipe\\' prepended.\n"
#endif
#ifdef EFL_NET_DIALER_UNIX_CLASS
                                   "unix://path to connect to an AF_UNIX server. For Linux one can create abstract sockets with unix://abstract:name.\n"
#endif
                                   "ssl://IP:PORT to connect using TCP+SSL and an IPv4 (A.B.C.D:PORT) or IPv6 ([A:B:C:D::E]:PORT).\n"
                                   "",
                                   "input-file"),
    ECORE_GETOPT_STORE_METAVAR_STR(0, NULL,
                                   "The output file name or:\n"
                                   ":stdout: to write to stdout.\n"
                                   ":stderr: to write to stderr.\n"
                                   ":memory: to write to a memory buffer.\n"
                                   ":none: to not use a destination object.\n"
                                   "tcp://IP:PORT to connect using TCP and an IPv4 (A.B.C.D:PORT) or IPv6 ([A:B:C:D::E]:PORT).\n"
                                   "http://address to do a PUT request\n"
                                   "ws://address or wss:// to do WebSocket request\n"
                                   "udp://IP:PORT to connect using UDP and an IPv4 (A.B.C.D:PORT) or IPv6 ([A:B:C:D::E]:PORT).\n"
#ifdef EFL_NET_DIALER_WINDOWS_CLASS
                                   "windows://path to connect to an Windows NamedPipe server. It will have '\\\\.pipe\\' prepended.\n"
#endif
#ifdef EFL_NET_SERVER_UNIX_CLASS
                                   "unix://path to connect to an AF_UNIX server. For Linux one can create abstract sockets with unix://abstract:name.\n"
#endif
                                   "ssl://IP:PORT to connect using TCP+SSL and an IPv4 (A.B.C.D:PORT) or IPv6 ([A:B:C:D::E]:PORT).\n"
                                   "",
                                   "output-file"),
    ECORE_GETOPT_SENTINEL
  }
};

static Eo *copier = NULL;

EAPI_MAIN void
efl_pause(void *data EINA_UNUSED,
          const Efl_Event *ev EINA_UNUSED)
{
}

EAPI_MAIN void
efl_resume(void *data EINA_UNUSED,
           const Efl_Event *ev EINA_UNUSED)
{
}

EAPI_MAIN void
efl_terminate(void *data EINA_UNUSED,
              const Efl_Event *ev EINA_UNUSED)
{
   /* FIXME: For the moment the main loop doesn't get
      properly destroyed on shutdown which disallow
      relying on parent destroying their children */
   if (copier)
     {
        efl_io_closer_close(copier);
        efl_del(copier);
     }
   copier = NULL;
}

EAPI_MAIN void
efl_main(void *data EINA_UNUSED,
         const Efl_Event *ev)
{
   char *input_fname = NULL;
   char *output_fname = NULL;
   char *line_delimiter = NULL;
   unsigned long buffer_limit = 0;
   unsigned long read_chunk_size = 0;
   double timeout = 0.0;
   Eina_Bool ssl_verify = EINA_TRUE;
   Eina_Bool quit_option = EINA_FALSE;
   Ecore_Getopt_Value values[] = {
     ECORE_GETOPT_VALUE_STR(line_delimiter),
     ECORE_GETOPT_VALUE_ULONG(buffer_limit),
     ECORE_GETOPT_VALUE_ULONG(read_chunk_size),
     ECORE_GETOPT_VALUE_DOUBLE(timeout),

     ECORE_GETOPT_VALUE_BOOL(ssl_verify),

     /* standard block to provide version, copyright, license and help */
     ECORE_GETOPT_VALUE_BOOL(quit_option), /* -V/--version quits */
     ECORE_GETOPT_VALUE_BOOL(quit_option), /* -C/--copyright quits */
     ECORE_GETOPT_VALUE_BOOL(quit_option), /* -L/--license quits */
     ECORE_GETOPT_VALUE_BOOL(quit_option), /* -h/--help quits */

     /* positional argument */
     ECORE_GETOPT_VALUE_STR(input_fname),
     ECORE_GETOPT_VALUE_STR(output_fname),

     ECORE_GETOPT_VALUE_NONE /* sentinel */
   };
   int args;
   Eo *input, *output;
   Eina_Slice line_delm_slice = EINA_SLICE_STR_LITERAL("");

   args = ecore_getopt_parse(&options, values, 0, NULL);
   if (args < 0)
     {
        fputs("ERROR: Could not parse command line options.\n", stderr);
        retval = EXIT_FAILURE;
        goto end;
     }

   if (quit_option) goto end;

   args = ecore_getopt_parse_positional(&options, values, 0, NULL, args);
   if (args < 0)
     {
        fputs("ERROR: Could not parse positional arguments.\n", stderr);
        retval = EXIT_FAILURE;
        goto end;
     }

   /* Efl_Io_Copier works with any object that implements
    * Efl_Io_Reader and Efl_Io_Writer interfaces. Here we create
    * couple of different objects to showcase that.
    *
    * Note that input_cbs(), output_cbs() are OPTIONAL, here are only
    * used to print out how each object behaves.
    */

   if (strcmp(input_fname, ":stdin:") == 0)
     {
        input = efl_add_ref(EFL_IO_STDIN_CLASS, NULL,
                        efl_event_callback_array_add(efl_added, input_cbs(), NULL));
        if (!input)
          {
             fprintf(stderr, "ERROR: could not open stdin.\n");
             retval = EXIT_FAILURE;
             goto end;
          }
     }
   else if (strncmp(input_fname, "tcp://", strlen("tcp://")) == 0)
     {
        /*
         * Since Efl.Net.Socket implements the required interfaces,
         * they can be used here as well.
         */
        const char *address = input_fname + strlen("tcp://");
        Eina_Error err;
        input = efl_add(EFL_NET_DIALER_TCP_CLASS, ev->object,
                        efl_event_callback_array_add(efl_added, input_cbs(), NULL), /* optional */
                        efl_event_callback_array_add(efl_added, dialer_cbs(), NULL) /* optional */
                        );
        if (!input)
          {
             fprintf(stderr, "ERROR: could not create TCP Dialer.\n");
             retval = EXIT_FAILURE;
             goto end;
          }

        err = efl_net_dialer_dial(input, address);
        if (err)
          {
             fprintf(stderr, "ERROR: could not TCP dial %s: %s\n",
                     address, eina_error_msg_get(err));
             goto end_input;
          }
     }
   else if (strncmp(input_fname, "http://", strlen("http://")) == 0 ||
            strncmp(input_fname, "https://", strlen("https://")) == 0)
     {
        Eina_Error err;

        input = efl_add(EFL_NET_DIALER_HTTP_CLASS, ev->object,
                        efl_net_dialer_http_method_set(efl_added, "GET"),
                        efl_event_callback_array_add(efl_added, input_cbs(), NULL), /* optional */
                        efl_event_callback_array_add(efl_added, dialer_cbs(), NULL), /* optional */
                        efl_event_callback_array_add(efl_added, http_cbs(), NULL) /* optional */
                        );
        if (!input)
          {
             fprintf(stderr, "ERROR: could not create HTTP Dialer.\n");
             retval = EXIT_FAILURE;
             goto end;
          }

        err = efl_net_dialer_dial(input, input_fname);
        if (err)
          {
             fprintf(stderr, "ERROR: could not HTTP dial %s: %s\n",
                     input_fname, eina_error_msg_get(err));
             goto end_input;
          }
     }
   else if (strncmp(input_fname, "ws://", strlen("ws://")) == 0 ||
            strncmp(input_fname, "wss://", strlen("wss://")) == 0)
     {
        Eina_Error err;

        input = efl_add(EFL_NET_DIALER_WEBSOCKET_CLASS, ev->object,
                         efl_net_dialer_websocket_streaming_mode_set(efl_added, EFL_NET_DIALER_WEBSOCKET_STREAMING_MODE_TEXT),
                        efl_event_callback_array_add(efl_added, input_cbs(), NULL), /* optional */
                        efl_event_callback_array_add(efl_added, dialer_cbs(), NULL) /* optional */
                        );
        if (!input)
          {
             fprintf(stderr, "ERROR: could not create WebSocket Dialer.\n");
             retval = EXIT_FAILURE;
             goto end;
          }

        err = efl_net_dialer_dial(input, input_fname);
        if (err)
          {
             fprintf(stderr, "ERROR: could not WebSocket dial %s: %s\n",
                     input_fname, eina_error_msg_get(err));
             goto end_input;
          }
     }
   else if (strncmp(input_fname, "udp://", strlen("udp://")) == 0)
     {
        /*
         * Since Efl.Net.Socket implements the required interfaces,
         * they can be used here as well.
         */
        const char *bind_address = input_fname + strlen("udp://");
        const char *address;
        Eina_Error err;
        input = efl_add(EFL_NET_DIALER_UDP_CLASS, ev->object,
                        efl_net_socket_udp_bind_set(efl_added, bind_address), /* use the address as the bind, so we can get data at it */
                        efl_event_callback_array_add(efl_added, input_cbs(), NULL), /* optional */
                        efl_event_callback_array_add(efl_added, dialer_cbs(), NULL) /* optional */
                        );
        if (!input)
          {
             fprintf(stderr, "ERROR: could not create UDP Dialer.\n");
             retval = EXIT_FAILURE;
             goto end;
          }

        if (bind_address[0] == '[') address = "[::]";
        else address = "0.0.0.0";

        err = efl_net_dialer_dial(input, address);
        if (err)
          {
             fprintf(stderr, "ERROR: could not UDP dial %s: %s\n",
                     address, eina_error_msg_get(err));
             goto end_input;
          }
     }
#ifdef EFL_NET_DIALER_UNIX_CLASS
   else if (strncmp(input_fname, "unix://", strlen("unix://")) == 0)
     {
        /*
         * Since Efl.Net.Socket implements the required interfaces,
         * they can be used here as well.
         */
        const char *address = input_fname + strlen("unix://");
        Eina_Error err;
        input = efl_add(EFL_NET_DIALER_UNIX_CLASS, ev->object,
                        efl_event_callback_array_add(efl_added, input_cbs(), NULL), /* optional */
                        efl_event_callback_array_add(efl_added, dialer_cbs(), NULL) /* optional */
                        );
        if (!input)
          {
             fprintf(stderr, "ERROR: could not create AF_UNIX Dialer.\n");
             retval = EXIT_FAILURE;
             goto end;
          }

        err = efl_net_dialer_dial(input, address);
        if (err)
          {
             fprintf(stderr, "ERROR: could not AF_UNIX dial %s: %s\n",
                     address, eina_error_msg_get(err));
             goto end_input;
          }
     }
#endif
#ifdef EFL_NET_DIALER_WINDOWS_CLASS
   else if (strncmp(input_fname, "windows://", strlen("windows://")) == 0)
     {
        /*
         * Since Efl.Net.Socket implements the required interfaces,
         * they can be used here as well.
         */
        const char *address = input_fname + strlen("windows://");
        Eina_Error err;
        input = efl_add(EFL_NET_DIALER_WINDOWS_CLASS, ev->object,
                        efl_event_callback_array_add(efl_added, input_cbs(), NULL), /* optional */
                        efl_event_callback_array_add(efl_added, dialer_cbs(), NULL) /* optional */
                        );
        if (!input)
          {
             fprintf(stderr, "ERROR: could not create Windows NamedPipe Dialer.\n");
             retval = EXIT_FAILURE;
             goto end;
          }

        err = efl_net_dialer_dial(input, address);
        if (err)
          {
             fprintf(stderr, "ERROR: could not Windows NamedPipe dial %s: %s\n",
                     address, eina_error_msg_get(err));
             goto end_input;
          }
     }
#endif
   else if (strncmp(input_fname, "ssl://", strlen("ssl://")) == 0)
     {
        /*
         * Since Efl.Net.Socket implements the required interfaces,
         * they can be used here as well.
         */
        const char *address = input_fname + strlen("ssl://");
        Eina_Error err;
        input = efl_add(EFL_NET_DIALER_SSL_CLASS, ev->object,
                        efl_event_callback_array_add(efl_added, input_cbs(), NULL), /* optional */
                        efl_event_callback_array_add(efl_added, dialer_cbs(), NULL) /* optional */
                        );
        if (!input)
          {
             fprintf(stderr, "ERROR: could not create SSL Dialer.\n");
             retval = EXIT_FAILURE;
             goto end;
          }

        efl_net_socket_ssl_verify_mode_set(input, ssl_verify ? EFL_NET_SSL_VERIFY_MODE_REQUIRED : EFL_NET_SSL_VERIFY_MODE_NONE);
        efl_net_socket_ssl_hostname_verify_set(input, ssl_verify);

        err = efl_net_dialer_dial(input, address);
        if (err)
          {
             fprintf(stderr, "ERROR: could not SSL dial %s: %s\n",
                     address, eina_error_msg_get(err));
             goto end_input;
          }
     }
   else
     {
        /* regular file, open with flags: read-only and close-on-exec */
        input = efl_add_ref(EFL_IO_FILE_CLASS, NULL,
                        efl_file_set(efl_added, input_fname, NULL), /* mandatory */
                        efl_io_file_flags_set(efl_added, O_RDONLY), /* default */
                        efl_io_closer_close_on_exec_set(efl_added, EINA_TRUE), /* recommended, set *after* flags, or include O_CLOEXEC in flags -- be careful with _WIN32 that doesn't support it. */
                        efl_event_callback_array_add(efl_added, input_cbs(), NULL) /* optional */
                        );
        if (!input)
          {
             fprintf(stderr, "ERROR: could not open '%s' for read.\n",
                     input_fname);
             retval = EXIT_FAILURE;
             goto end;
          }
     }

   if (strcmp(output_fname, ":stdout:") == 0)
     {
        output = efl_add_ref(EFL_IO_STDOUT_CLASS, NULL,
                         efl_event_callback_array_add(efl_added, output_cbs(), NULL) /* optional */
                         );
        if (!output)
          {
             fprintf(stderr, "ERROR: could not open stdout.\n");
             retval = EXIT_FAILURE;
             goto end_input;
          }
     }
   else if (strcmp(output_fname, ":stderr:") == 0)
     {
        output = efl_add_ref(EFL_IO_STDERR_CLASS, NULL,
                         efl_event_callback_array_add(efl_added, output_cbs(), NULL) /* optional */
                         );
        if (!output)
          {
             fprintf(stderr, "ERROR: could not open stderr.\n");
             retval = EXIT_FAILURE;
             goto end_input;
          }
     }
   else if (strcmp(output_fname, ":memory:") == 0)
     {
        /*
         * This uses a memory destination, then the process will
         * result in that object holding all the memory.
         *
         * One can use things like efl_io_buffer_limit_set() to limit
         * it's size.
         *
         * If the source object provides a size (ie: a file), then
         * this buffer will be resized only once at the start, saving
         * reallocs. Otherwise it will grow as needed.  Contrast this
         * with ":none:" method below, that always resize.
         *
         * When finished get the efl_io_buffer_slice_get(), see
         * _copier_done().
         */
        output = efl_add_ref(EFL_IO_BUFFER_CLASS, NULL,
                         efl_event_callback_array_add(efl_added, output_cbs(), NULL), /* optional */
                         efl_event_callback_array_add(efl_added, output_buffer_cbs(), NULL) /* optional */
                         );
        if (!output)
          {
             fprintf(stderr, "ERROR: could not open memory buffer.\n");
             retval = EXIT_FAILURE;
             goto end_input;
          }
     }
   else if (strcmp(output_fname, ":none:") == 0)
     {
        /*
         * No output means that the Efl_Io_Copier will cache
         * internally up to efl_io_copier_buffer_limit_set().
         *
         * When finished you can steal copier's buffer in order to use
         * that yourself. See _copier_done().
         */
        output = NULL;
     }
   else if (strncmp(output_fname, "tcp://", strlen("tcp://")) == 0)
     {
        /*
         * Since Efl.Net.Socket implements the required interfaces,
         * they can be used here as well.
         */
        const char *address = output_fname + strlen("tcp://");
        Eina_Error err;
        output = efl_add(EFL_NET_DIALER_TCP_CLASS, ev->object,
                         efl_event_callback_array_add(efl_added, output_cbs(), NULL), /* optional */
                         efl_event_callback_array_add(efl_added, dialer_cbs(), NULL) /* optional */
                         );
        if (!output)
          {
             fprintf(stderr, "ERROR: could not create TCP Dialer.\n");
             retval = EXIT_FAILURE;
             goto end_input;
          }

        err = efl_net_dialer_dial(output, address);
        if (err)
          {
             fprintf(stderr, "ERROR: could not TCP dial %s: %s\n",
                     address, eina_error_msg_get(err));
             goto end_output;
          }
     }
   else if (strncmp(output_fname, "http://", strlen("http://")) == 0 ||
            strncmp(output_fname, "https://", strlen("https://")) == 0)
     {
        Eina_Error err;

        output = efl_add(EFL_NET_DIALER_HTTP_CLASS, ev->object,
                         efl_net_dialer_http_method_set(efl_added, "PUT"),
                         efl_event_callback_array_add(efl_added, output_cbs(), NULL), /* optional */
                         efl_event_callback_array_add(efl_added, dialer_cbs(), NULL), /* optional */
                         efl_event_callback_array_add(efl_added, http_cbs(), NULL) /* optional */
                         );
        if (!output)
          {
             fprintf(stderr, "ERROR: could not create HTTP Dialer.\n");
             retval = EXIT_FAILURE;
             goto end_input;
          }

        err = efl_net_dialer_dial(output, output_fname);
        if (err)
          {
             fprintf(stderr, "ERROR: could not HTTP dial %s: %s\n",
                     output_fname, eina_error_msg_get(err));
             goto end_output;
          }
     }
   else if (strncmp(output_fname, "ws://", strlen("ws://")) == 0 ||
            strncmp(output_fname, "wss://", strlen("wss://")) == 0)
     {
        Eina_Error err;

        output = efl_add(EFL_NET_DIALER_WEBSOCKET_CLASS, ev->object,
                         efl_net_dialer_websocket_streaming_mode_set(efl_added, EFL_NET_DIALER_WEBSOCKET_STREAMING_MODE_TEXT),
                         efl_event_callback_array_add(efl_added, output_cbs(), NULL), /* optional */
                         efl_event_callback_array_add(efl_added, dialer_cbs(), NULL) /* optional */
                         );
        if (!output)
          {
             fprintf(stderr, "ERROR: could not create WebSocket Dialer.\n");
             retval = EXIT_FAILURE;
             goto end_input;
          }

        err = efl_net_dialer_dial(output, output_fname);
        if (err)
          {
             fprintf(stderr, "ERROR: could not WebSocket dial %s: %s\n",
                     output_fname, eina_error_msg_get(err));
             goto end_output;
          }
     }
   else if (strncmp(output_fname, "udp://", strlen("udp://")) == 0)
     {
        /*
         * Since Efl.Net.Socket implements the required interfaces,
         * they can be used here as well.
         */
        const char *address = output_fname + strlen("udp://");
        Eina_Error err;
        output = efl_add(EFL_NET_DIALER_UDP_CLASS, ev->object,
                         efl_event_callback_array_add(efl_added, output_cbs(), NULL), /* optional */
                         efl_event_callback_array_add(efl_added, dialer_cbs(), NULL) /* optional */
                         );
        if (!output)
          {
             fprintf(stderr, "ERROR: could not create UDP Dialer.\n");
             retval = EXIT_FAILURE;
             goto end_input;
          }

        err = efl_net_dialer_dial(output, address);
        if (err)
          {
             fprintf(stderr, "ERROR: could not UDP dial %s: %s\n",
                     address, eina_error_msg_get(err));
             goto end_output;
          }
     }
#ifdef EFL_NET_DIALER_UNIX_CLASS
   else if (strncmp(output_fname, "unix://", strlen("unix://")) == 0)
     {
        /*
         * Since Efl.Net.Socket implements the required interfaces,
         * they can be used here as well.
         */
        const char *address = output_fname + strlen("unix://");
        Eina_Error err;
        output = efl_add(EFL_NET_DIALER_UNIX_CLASS, ev->object,
                         efl_event_callback_array_add(efl_added, output_cbs(), NULL), /* optional */
                         efl_event_callback_array_add(efl_added, dialer_cbs(), NULL) /* optional */
                         );
        if (!output)
          {
             fprintf(stderr, "ERROR: could not create AF_UNIX Dialer.\n");
             retval = EXIT_FAILURE;
             goto end_input;
          }

        err = efl_net_dialer_dial(output, address);
        if (err)
          {
             fprintf(stderr, "ERROR: could not AF_UNIX dial %s: %s\n",
                     address, eina_error_msg_get(err));
             goto end_output;
          }
     }
#endif
#ifdef EFL_NET_DIALER_WINDOWS_CLASS
   else if (strncmp(output_fname, "windows://", strlen("windows://")) == 0)
     {
        /*
         * Since Efl.Net.Socket implements the required interfaces,
         * they can be used here as well.
         */
        const char *address = output_fname + strlen("windows://");
        Eina_Error err;
        output = efl_add(EFL_NET_DIALER_WINDOWS_CLASS, ev->object,
                         efl_event_callback_array_add(efl_added, output_cbs(), NULL), /* optional */
                         efl_event_callback_array_add(efl_added, dialer_cbs(), NULL) /* optional */
                         );
        if (!output)
          {
             fprintf(stderr, "ERROR: could not create Windows NamedPipe Dialer.\n");
             retval = EXIT_FAILURE;
             goto end_input;
          }

        err = efl_net_dialer_dial(output, address);
        if (err)
          {
             fprintf(stderr, "ERROR: could not Windows NamedPipe dial %s: %s\n",
                     address, eina_error_msg_get(err));
             goto end_output;
          }
     }
#endif
   else if (strncmp(output_fname, "ssl://", strlen("ssl://")) == 0)
     {
        /*
         * Since Efl.Net.Socket implements the required interfaces,
         * they can be used here as well.
         */
        const char *address = output_fname + strlen("ssl://");
        Eina_Error err;
        output = efl_add(EFL_NET_DIALER_SSL_CLASS, ev->object,
                         efl_event_callback_array_add(efl_added, output_cbs(), NULL), /* optional */
                         efl_event_callback_array_add(efl_added, dialer_cbs(), NULL) /* optional */
                         );
        if (!output)
          {
             fprintf(stderr, "ERROR: could not create SSL Dialer.\n");
             retval = EXIT_FAILURE;
             goto end_input;
          }

        efl_net_socket_ssl_verify_mode_set(output, ssl_verify ? EFL_NET_SSL_VERIFY_MODE_REQUIRED : EFL_NET_SSL_VERIFY_MODE_NONE);
        efl_net_socket_ssl_hostname_verify_set(output, ssl_verify);

        err = efl_net_dialer_dial(output, address);
        if (err)
          {
             fprintf(stderr, "ERROR: could not SSL dial %s: %s\n",
                     address, eina_error_msg_get(err));
             goto end_output;
          }
     }
   else
     {
        /* regular file, open with flags: write-only, close-on-exec,
         * create if did not exist and truncate if exist.
         */
        output = efl_add_ref(EFL_IO_FILE_CLASS, NULL,
                         efl_file_set(efl_added, output_fname, NULL), /* mandatory */
                         efl_io_file_flags_set(efl_added, O_WRONLY | O_CREAT | O_TRUNC), /* mandatory for write */
                         efl_io_closer_close_on_exec_set(efl_added, EINA_TRUE), /* recommended, set *after* flags, or include O_CLOEXEC in flags -- be careful with _WIN32 that doesn't support it. */
                         efl_io_file_mode_set(efl_added, 0644), /* mandatory for write */
                         efl_event_callback_array_add(efl_added, output_cbs(), NULL) /* optional */
                         );
        if (!output)
          {
             fprintf(stderr, "ERROR: could not open '%s' for write.\n",
                     output_fname);
             retval = EXIT_FAILURE;
             goto end_input;
          }
     }

   /* A delimiter is optional, if empty or unset, copier will execute
    * writes based on read_chunk_size and only event "data" is emitted.
    *
    * If a line delimiter is set, copier will hold writes until the
    * delimiter is found, source reached End-of-Stream (eos) or the
    * copier buffer limit is reached. The "line" event is emitted.
    */
   if (line_delimiter)
     line_delm_slice = (Eina_Slice)EINA_SLICE_STR(line_delimiter);

   copier = efl_add(EFL_IO_COPIER_CLASS, ev->object,
                    efl_io_copier_source_set(efl_added, input), /* mandatory */
                    efl_io_copier_destination_set(efl_added, output), /* optional, see :none: */
                    efl_io_copier_line_delimiter_set(efl_added, line_delm_slice), /* optional */
                    efl_io_copier_buffer_limit_set(efl_added, buffer_limit), /* optional, defaults to unlimited */
                    efl_io_copier_read_chunk_size_set(efl_added, read_chunk_size), /* optional, defaults to 4096 */
                    efl_io_copier_timeout_inactivity_set(efl_added, timeout), /* optional, defaults to 0.0 (disabled) */
                    efl_event_callback_array_add(efl_added, copier_cbs(), NULL) /* recommended, at least EFL_IO_COPIER_EVENT_DONE. */
                    );
   if (!copier)
     {
        fprintf(stderr, "ERROR: could not create copier.\n");
        retval = EXIT_FAILURE;
        goto end_output;
     }

   fprintf(stderr, "INFO: copy source=%p (%s) to destination=%p (%s)\n",
           input,
           efl_class_name_get(efl_class_get(input)),
           output,
           output ? efl_class_name_get(efl_class_get(output)) : ":none:");

   return ;

 end_output:
   if (output)
     {
        efl_unref(output);
        output = NULL;
     }
 end_input:
   efl_unref(input);
   input = NULL;

 end:

   efl_loop_quit(ev->object, eina_value_int_init(retval));
}

EFL_MAIN_EX();