curl_dl.cc

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
 
#include <curl/curl.h>
 
#include <dlfcn.h>
#include <pthread.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
 
/* The SONAME to load. Distributions which ship a differently named
 * libcurl (Debian's libcurl-gnutls.so.4) override it from cmake. */
#ifndef ZYPP_CURL_SONAME
#define ZYPP_CURL_SONAME "libcurl.so.4"
#endif
 
/* curl.h installs call-site typecheck macros for these */
#undef curl_easy_setopt
#undef curl_easy_getinfo
#undef curl_multi_setopt
#undef curl_share_setopt
 
namespace {
 
void * curl_dl_handle = nullptr;
char curl_dl_error[512];
pthread_once_t curl_dl_once = PTHREAD_ONCE_INIT;
 
extern "C" void curl_dl_open()
{
  curl_dl_handle = dlopen( ZYPP_CURL_SONAME, RTLD_LAZY | RTLD_LOCAL );
  if ( !curl_dl_handle )
  {
    // dlerror() is thread local and consumed by reading it, so keep the
    // message here: a thread which only waited on pthread_once would
    // otherwise have nothing to report.
    const char * err = dlerror();
    snprintf( curl_dl_error, sizeof(curl_dl_error), "%s", err ? err : "cannot load library" );
  }
}
 
/* A libcurl that cannot be loaded, or that lacks a symbol libzypp uses,
 * is fatal - exactly as it was while libcurl was a DT_NEEDED entry and
 * the dynamic loader refused to start the process. Reporting it through
 * a return value instead would push a null check into every call site
 * (curl_version_info() and curl_easy_init() are dereferenced directly
 * in several places), and a missed one turns a clear diagnostic into a
 * SIGSEGV. */
void * curl_dl_sym( const char * name )
{
  pthread_once( &curl_dl_once, curl_dl_open );
  if ( !curl_dl_handle )
  {
    fprintf( stderr, "libzypp: cannot load %s: %s\n", ZYPP_CURL_SONAME, curl_dl_error );
    abort();
  }
  void * sym = dlsym( curl_dl_handle, name );
  if ( !sym )
  {
    const char * err = dlerror();
    fprintf( stderr, "libzypp: %s lacks %s: %s\n",
             ZYPP_CURL_SONAME, name, err ? err : "symbol not found" );
    abort();
  }
  return sym;
}
 
} // namespace
 
/* These definitions must never be exported: an exported curl_easy_setopt
 * would interpose libcurl's own calls to it. -fvisibility=hidden already
 * does that, but say it here so it does not depend on a build option. */
#define CURL_DL_HIDDEN __attribute__((visibility("hidden")))
 
/* Wrapper for a non-variadic function returning a value. */
#define CURL_DL_FN( ret, name, proto, args )            \
CURL_DL_HIDDEN ret name proto                           \
{                                                       \
  static ret (*fn) proto;                               \
  if ( !fn )                                            \
    *(void **)&fn = curl_dl_sym( #name );               \
  return fn args;                                       \
}
 
/* Wrapper for a non-variadic function returning void. */
#define CURL_DL_FN_VOID( name, proto, args )            \
CURL_DL_HIDDEN void name proto                          \
{                                                       \
  static void (*fn) proto;                              \
  if ( !fn )                                            \
    *(void **)&fn = curl_dl_sym( #name );               \
  fn args;                                              \
}
 
CURL_DL_FN( CURLcode, curl_global_init, (long flags), (flags) )
 
CURL_DL_FN( CURL *, curl_easy_init, (void), () )
CURL_DL_FN_VOID( curl_easy_cleanup, (CURL *handle), (handle) )
CURL_DL_FN_VOID( curl_easy_reset, (CURL *handle), (handle) )
CURL_DL_FN( const char *, curl_easy_strerror, (CURLcode code), (code) )
 
CURL_DL_FN_VOID( curl_free, (void *p), (p) )
CURL_DL_FN( char *, curl_unescape, (const char *str, int length), (str, length) )
CURL_DL_FN( curl_version_info_data *, curl_version_info, (CURLversion age), (age) )
 
CURL_DL_FN( struct curl_slist *, curl_slist_append, (struct curl_slist *list, const char *str), (list, str) )
CURL_DL_FN_VOID( curl_slist_free_all, (struct curl_slist *list), (list) )
 
CURL_DL_FN( CURLM *, curl_multi_init, (void), () )
CURL_DL_FN( CURLMcode, curl_multi_cleanup, (CURLM *multi), (multi) )
CURL_DL_FN( CURLMcode, curl_multi_add_handle, (CURLM *multi, CURL *handle), (multi, handle) )
CURL_DL_FN( CURLMcode, curl_multi_remove_handle, (CURLM *multi, CURL *handle), (multi, handle) )
CURL_DL_FN( CURLMsg *, curl_multi_info_read, (CURLM *multi, int *msgs_in_queue), (multi, msgs_in_queue) )
CURL_DL_FN( CURLMcode, curl_multi_socket_action, (CURLM *multi, curl_socket_t s, int ev_bitmask, int *running_handles), (multi, s, ev_bitmask, running_handles) )
CURL_DL_FN( const char *, curl_multi_strerror, (CURLMcode code), (code) )
 
/* The variadic trio. Forward through a variadic-typed pointer so the
 * call uses the variadic ABI (%al on x86-64). */
 
CURL_DL_HIDDEN CURLcode curl_easy_getinfo( CURL *handle, CURLINFO info, ... )
{
  static CURLcode (*fn)( CURL *, CURLINFO, ... );
  va_list ap;
  void *arg;
  if ( !fn )
    *(void **)&fn = curl_dl_sym( "curl_easy_getinfo" );
  va_start( ap, info );
  arg = va_arg( ap, void * );   /* always a pointer out-arg */
  va_end( ap );
  return fn( handle, info, arg );
}
 
CURL_DL_HIDDEN CURLcode curl_easy_setopt( CURL *handle, CURLoption option, ... )
{
  static CURLcode (*fn)( CURL *, CURLoption, ... );
  va_list ap;
  CURLcode ret;
  if ( !fn )
    *(void **)&fn = curl_dl_sym( "curl_easy_setopt" );
  va_start( ap, option );
  if ( option < CURLOPTTYPE_OBJECTPOINT )               /* long */
    ret = fn( handle, option, va_arg( ap, long ) );
  else if ( option < CURLOPTTYPE_OFF_T )                /* object/function pointer */
    ret = fn( handle, option, va_arg( ap, void * ) );
  else if ( option < CURLOPTTYPE_BLOB )                 /* curl_off_t */
    ret = fn( handle, option, va_arg( ap, curl_off_t ) );
  else                                                  /* blob pointer */
    ret = fn( handle, option, va_arg( ap, void * ) );
  va_end( ap );
  return ret;
}
 
CURL_DL_HIDDEN CURLMcode curl_multi_setopt( CURLM *multi, CURLMoption option, ... )
{
  static CURLMcode (*fn)( CURLM *, CURLMoption, ... );
  va_list ap;
  CURLMcode ret;
  if ( !fn )
    *(void **)&fn = curl_dl_sym( "curl_multi_setopt" );
  va_start( ap, option );
  if ( option < CURLOPTTYPE_OBJECTPOINT )
    ret = fn( multi, option, va_arg( ap, long ) );
  else if ( option < CURLOPTTYPE_OFF_T )
    ret = fn( multi, option, va_arg( ap, void * ) );
  else if ( option < CURLOPTTYPE_BLOB )
    ret = fn( multi, option, va_arg( ap, curl_off_t ) );
  else
    ret = fn( multi, option, va_arg( ap, void * ) );
  va_end( ap );
  return ret;
}