Re: core dump on curl function call

From: treesa fairy joseph via curl-library <curl-library_at_lists.haxx.se>
Date: Mon, 28 Feb 2022 12:12:35 +0530

Hello Daniel,
Could not come back to this issue, for a while. Right now, back on this problem.
The below shows the sample program which also generates the seg flt



/***************************************************************************
 * _ _ ____ _
 * Project ___| | | | _ \| |
 * / __| | | | |_) | |
 * | (__| |_| | _ <| |___
 * \___|\___/|_| \_\_____|
 *
 * Copyright (C) 1998 - 2020, Daniel Stenberg, <daniel_at_haxx.se>, et al.
 *
 * This software is licensed as described in the file COPYING, which
 * you should have received as part of this distribution. The terms
 * are also available at https://curl.haxx.se/docs/copyright.html.
 *
 * You may opt to use, copy, modify, merge, publish, distribute and/or sell
 * copies of the Software, and permit persons to whom the Software is
 * furnished to do so, under the terms of the COPYING file.
 *
 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
 * KIND, either express or implied.
 *
 ***************************************************************************/
/* <DESC>
 * A multi-threaded example that uses pthreads to fetch several files at once
 * </DESC>
 */

#include <stdio.h>
#include <pthread.h>
#include <curl/curl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <curl/curl.h>
#include <openssl/x509v3.h>
#include <openssl/x509_vfy.h>
#include <openssl/crypto.h>
#include <openssl/lhash.h>
#include <openssl/objects.h>
#include <openssl/err.h>
#include <openssl/evp.h>
#include <openssl/x509.h>
#include <openssl/pkcs12.h>
#include <openssl/bio.h>
#include <openssl/ssl.h>
#include <openssl/ossl_typ.h>
//#include <crypto/internal/x509_int.h>
#include <crypto/include/internal/x509_int.h>

#define NUMT 1
typedef struct MemoryStruct
{
        unsigned char *memory;
        size_t size;
} memory_struct_t;
#define ZERO_NULL 0


typedef struct sslctxparm_st {
  unsigned char *p12file;
  const char *pst;
  PKCS12 *p12;
  EVP_PKEY *pkey;
  X509 *usercert;
  STACK_OF(X509) * ca;
  CURL *curl;
  BIO *errorbio;
  int accesstype;
  int verbose;

} sslctxparm;

/*
  List of URLs to fetch.

  If you intend to use a SSL-based protocol here you might need to setup TLS
  library mutex callbacks as described here:

  https://curl.haxx.se/libcurl/c/threadsafe.html

*/

/********************************************************************************
* Function Name : ipr_cwmp_WriteMemoryCallback
*
* Description :
*
*
* Returns :
*
*******************************************************************************/

size_t ipr_cwmp_WriteMemoryCallback(void *contents,
    size_t size,
    size_t nmemb,
    void *userp)
{
    size_t realsize = size * nmemb;
    struct MemoryStruct *mem = (struct MemoryStruct *)userp;
    mem->memory = realloc(mem->memory, mem->size + realsize + 1 );
    if (mem->memory == NULL)
    {
        /* out of memory! */
        printf("Exiting the function ipr_cwmp_WriteMemoryCallback 101 \n");
        exit(1);
    }
    memcpy(&(mem->memory[mem->size]), contents, realsize);
    mem->size += realsize;
    mem->memory[mem->size] = 0;
    printf("Exiting the function ipr_cwmp_WriteMemoryCallback 100 \n");
    return realsize;
}


/* This is an application verification call back, it does not
   perform any addition verification but tries to find a URL
   in the presented certificate. If found, this will become
   the URL to be used in the POST.
*/
static int ssl_app_verify_callback(X509_STORE_CTX *ctx, void *arg)
{
    sslctxparm * p = (sslctxparm *) arg;
    int ok;

    if(p->verbose > 2)
        BIO_printf(p->errorbio, "entering ssl_app_verify_callback\n");

    ok = X509_verify_cert(ctx);
    if(ok && ctx->cert) {
        unsigned char *accessinfo;
        if(p->verbose > 1)
            X509_print_ex(p->errorbio, ctx->cert, 0, 0);

// accessinfo = my_get_ext(ctx->cert, p->accesstype, NID_sinfo_access);
// if(accessinfo) {
// if(p->verbose)
// BIO_printf(p->errorbio, "Setting URL from SIA to:
%s\n", accessinfo);
//
// curl_easy_setopt(p->curl, CURLOPT_URL, accessinfo);
// }
// else if(accessinfo = my_get_ext(ctx->cert, p->accesstype,
// NID_info_access)) {
// if(p->verbose)
// BIO_printf(p->errorbio, "Setting URL from AIA to:
%s\n", accessinfo);
//
// curl_easy_setopt(p->curl, CURLOPT_URL, accessinfo);
// }
    }
    if(p->verbose > 2)
        BIO_printf(p->errorbio, "leaving ssl_app_verify_callback with
%d\n", ok);

    return ok;
}

/*************************************************************************************************
* Function Name : ipr_cwmp_sslctxfun
*
* Description : This is an example of an curl SSL initialisation
call back. The callback sets:
* a private key and certificate
* a trusted ca certificate
* a preferred cipherlist
* an application verification callback (the function above)
* Returns : CURLcode
*
***************************************************************************************************/

static CURLcode ipr_cwmp_sslctxfun(void* sslctx, void* parm)
{
    SSL_CTX* ctx = (SSL_CTX *) sslctx ;
    SSL_CTX_set_cert_verify_callback(ctx, ssl_app_verify_callback, parm);
    //SSL_CTX_set_cert_verify_callback(ctx,
ipr_cwmp_ssl_app_verify_callback, parm);
    //changed this to supress the warning for ssl prototype of this function
    return CURLE_OK ;
}
/***************************************************************************************************/


const char * const urls[NUMT]= {
  "https://192.168.66.116:8443/acs/AcsServlet"
  //"https://192.168.16.233:8443/acs/AcsServlet",
  //"ftp://cool.haxx.se/",
  //"https://www.cag.se/",
  //"www.haxx.se"
};
//curl_easy_setopt(curl, CURLOPT_SSLCERT,"client-2048.crt");
//curl_easy_setopt(curl, CURLOPT_SSLKEY,"client-2048.key");

static void *pull_one_url(void *url)
{
    struct MemoryStruct header_chunk = {0};
    struct curl_slist *slist = NULL;
  static const char *msg = "Field=1&Field=2&Field=3";
    CURL *curl;
    struct MemoryStruct chunk = {0};
    /*SPR 17929 changes start*/
    char * str = NULL;
    char arr[512];
    memset(arr, '\0', 512);
    char * token = NULL;
    /*SPR 17929 changes end*/

    chunk.memory = NULL; /* will be grown as needed by the realloc above */
    chunk.size = 0;

    curl = curl_easy_init();
    curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 10);
    //curl_easy_setopt(curl,CURLOPT_RESOLVE, host);
    curl_easy_setopt(curl, CURLOPT_URL, url);
    curl_easy_setopt(curl, CURLOPT_FAILONERROR, 1L);
    /* get verbose debug output please */
    curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
    curl_easy_setopt(curl, CURLOPT_POST, 1);
    curl_easy_setopt(curl, CURLOPT_POSTFIELDS,(char *)msg);

    slist = NULL;
    slist = curl_slist_append(NULL, "Content-Type: text/xml;
UInt8set=utf-8\nSOAPAction:");
    curl_easy_setopt(curl, CURLOPT_COOKIEFILE, "cookie.txt");
    curl_easy_setopt(curl, CURLOPT_COOKIE, "cookie.txt");
    if (header_chunk.size)
    {
        str = strstr((char *)header_chunk.memory, "JSESSIONID=");
        printf("Extracted JSESSIONID \n");
    }

    if ((header_chunk.size) && (str!= NULL))
    {
        token = strtok(str + 11, ";");
        memset(arr,0x00,512);
        sprintf(arr, "Cookie: JSESSIONID=%s",token);
        printf("Token has value %s \n",arr);
        slist = curl_slist_append(slist,arr);
        printf("Added httpHeader \n");
    }
    curl_easy_setopt(curl, CURLOPT_HTTPHEADER, slist);
    if(0 == header_chunk.size)
    {
        curl_easy_setopt(curl, CURLOPT_HEADERDATA,(void *)&header_chunk);
    }

    curl_easy_setopt(curl, CURLOPT_SSL_CTX_FUNCTION, ipr_cwmp_sslctxfun);
    //curl_easy_setopt(curl, CURLOPT_SSL_CTX_FUNCTION, sslctxfun);
    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, ipr_cwmp_WriteMemoryCallback);
    /* we pass our 'chunk' struct to the callback function */
    //coverity fix
    curl_easy_setopt(curl, CURLOPT_WRITEDATA,(void *)&chunk);
    curl_easy_setopt(curl, CURLOPT_SSLKEY,"./tls_files/enodeb-new.key.pem");
    curl_easy_setopt(curl, CURLOPT_SSLCERT,"./tls_files/enodeb.cert.pem");
    //curl_easy_setopt(curl, CURLOPT_SSLKEY, g_ipr_cwmp_pClientKeyFile);
    /* set the file with the certs vaildating the server */
    //curl_easy_setopt(curl, CURLOPT_SSLCERT, g_ipr_cwmp_pClientCertFile);
    /* disconnect if we can't validate server's cert */
    curl_easy_setopt(curl,CURLOPT_SSL_VERIFYPEER,1L);
    curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0L);
    curl_easy_setopt(curl,CURLOPT_CAINFO,"./tls_files/ca-chain.cert.pem");
    curl_easy_setopt(curl,CURLOPT_FOLLOWLOCATION,1L);
    curl_easy_setopt(curl,CURLOPT_MAXREDIRS,5L);
    curl_easy_setopt(curl,CURLOPT_POSTREDIR,CURL_REDIR_POST_ALL);
    curl_easy_setopt(curl, CURLOPT_POST, 1);

    //coverity fix
    //curl_easy_setopt(curl, CURLOPT_POSTFIELDS,(char *)msg);
    //curl_easy_setopt(curl, CURLOPT_COOKIEFILE, "cookie.txt");
    //curl_easy_setopt(curl, CURLOPT_COOKIE, "cookie.txt");
    curl_easy_setopt(curl, CURLOPT_HTTPAUTH, CURLAUTH_BASIC|CURLAUTH_DIGEST);
    curl_easy_setopt (curl, CURLOPT_USERNAME
,"BaseStationClass-002488-1114B00001");
    curl_easy_setopt (curl, CURLOPT_PASSWORD ,"abcd1234");
    // curl_easy_setopt(curl, CURLOPT_SSL_CTX_FUNCTION,
ipr_cwmp_sslctxfun) ;



    curl_easy_perform(curl); /* ignores error */
    curl_easy_cleanup(curl);

    return NULL;
}


/*
   int pthread_create(pthread_t *new_thread_ID,
   const pthread_attr_t *attr,
   void * (*start_func)(void *), void *arg);
*/

int main(int argc, char **argv)
{
  pthread_t tid[NUMT];
  int i;

  /* Must initialize libcurl before any threads are started */
  curl_global_init(CURL_GLOBAL_ALL);

  for(i = 0; i< NUMT; i++) {
    int error = pthread_create(&tid[i],
                               NULL, /* default attributes please */
                               pull_one_url,
                               (void *)urls[i]);
    if(0 != error)
      fprintf(stderr, "Couldn't run thread number %d, errno %d\n", i, error);
    else
      fprintf(stderr, "Thread %d, gets %s\n", i, urls[i]);
  }

  /* now wait for all threads to terminate */
  for(i = 0; i< NUMT; i++) {
    pthread_join(tid[i], NULL);
    fprintf(stderr, "Thread %d terminated\n", i);
  }
  curl_global_cleanup();
  return 0;
}


On Fri, Oct 1, 2021 at 8:29 PM Daniel Stenberg <daniel_at_haxx.se> wrote:
>
> On Fri, 1 Oct 2021, treesa fairy joseph wrote:
>
> > #0 0x00000000005377c4 in Curl_hash_clean_with_criterium (h=0xffff7c0a4d50,
> > user=0xffff8b28d970,
> > comp=0x4ba604 <hostcache_timestamp_remove>) at hash.c:243
> > 243 hash.c: No such file or directory.
> > (gdb) bt
> > #0 0x00000000005377c4 in Curl_hash_clean_with_criterium (h=0xffff7c0a4d50,
> > user=0xffff8b28d970,
> > comp=0x4ba604 <hostcache_timestamp_remove>) at hash.c:243
>
> This issue shows the typical signs of a threading problem. Make sure that
> your application and threading follow the advice here:
>
> https://curl.se/libcurl/c/threadsafe.html
>
> In particular the dont-use-the-same-handle-twice rule.
>
> If that doesn't help, then I'd advice you to start trying to create a separate
> stand-alone example code that reproduces the problem that you can share with
> us.
>
> --
>
> / daniel.haxx.se
> | Commercial curl support up to 24x7 is available!
> | Private help, bug fixes, support, ports, new features
> | https://curl.se/support.html

-- 
Unsubscribe: https://lists.haxx.se/listinfo/curl-library
Etiquette:   https://curl.haxx.se/mail/etiquette.html

Received on 2022-02-28