thodg/libgit2/src/streams/openssl_legacy.c

• Show log

  Commit

• Hash : 379c4646
  Author :
  Date : 2021-09-09T19:49:04
  

  Fix coding style for pointer Make some syntax change to follow coding style.

Download

• src/streams/openssl_legacy.c

• /*
   * Copyright (C) the libgit2 contributors. All rights reserved.
   *
   * This file is part of libgit2, distributed under the GNU GPL v2 with
   * a Linking Exception. For full terms see the included COPYING file.
   */
  
  #include "streams/openssl.h"
  #include "streams/openssl_legacy.h"
  
  #include "runtime.h"
  #include "git2/sys/openssl.h"
  
  #if defined(GIT_OPENSSL) && !defined(GIT_OPENSSL_DYNAMIC)
  # include <openssl/ssl.h>
  # include <openssl/err.h>
  # include <openssl/x509v3.h>
  # include <openssl/bio.h>
  #endif
  
  #if defined(GIT_OPENSSL_LEGACY) || defined(GIT_OPENSSL_DYNAMIC)
  
  /*
   * OpenSSL 1.1 made BIO opaque so we have to use functions to interact with it
   * which do not exist in previous versions. We define these inline functions so
   * we can program against the interface instead of littering the implementation
   * with ifdefs. We do the same for OPENSSL_init_ssl.
   */
  
  int OPENSSL_init_ssl__legacy(uint64_t opts, const void *settings)
  {
  	GIT_UNUSED(opts);
  	GIT_UNUSED(settings);
  	SSL_load_error_strings();
  	SSL_library_init();
  	return 0;
  }
  
  BIO_METHOD *BIO_meth_new__legacy(int type, const char *name)
  {
  	BIO_METHOD *meth = git__calloc(1, sizeof(BIO_METHOD));
  	if (!meth) {
  		return NULL;
  	}
  
  	meth->type = type;
  	meth->name = name;
  
  	return meth;
  }
  
  void BIO_meth_free__legacy(BIO_METHOD *biom)
  {
  	git__free(biom);
  }
  
  int BIO_meth_set_write__legacy(BIO_METHOD *biom, int (*write) (BIO *, const char *, int))
  {
  	biom->bwrite = write;
  	return 1;
  }
  
  int BIO_meth_set_read__legacy(BIO_METHOD *biom, int (*read) (BIO *, char *, int))
  {
  	biom->bread = read;
  	return 1;
  }
  
  int BIO_meth_set_puts__legacy(BIO_METHOD *biom, int (*puts) (BIO *, const char *))
  {
  	biom->bputs = puts;
  	return 1;
  }
  
  int BIO_meth_set_gets__legacy(BIO_METHOD *biom, int (*gets) (BIO *, char *, int))
  
  {
  	biom->bgets = gets;
  	return 1;
  }
  
  int BIO_meth_set_ctrl__legacy(BIO_METHOD *biom, long (*ctrl) (BIO *, int, long, void *))
  {
  	biom->ctrl = ctrl;
  	return 1;
  }
  
  int BIO_meth_set_create__legacy(BIO_METHOD *biom, int (*create) (BIO *))
  {
  	biom->create = create;
  	return 1;
  }
  
  int BIO_meth_set_destroy__legacy(BIO_METHOD *biom, int (*destroy) (BIO *))
  {
  	biom->destroy = destroy;
  	return 1;
  }
  
  int BIO_get_new_index__legacy(void)
  {
  	/* This exists as of 1.1 so before we'd just have 0 */
  	return 0;
  }
  
  void BIO_set_init__legacy(BIO *b, int init)
  {
  	b->init = init;
  }
  
  void BIO_set_data__legacy(BIO *a, void *ptr)
  {
  	a->ptr = ptr;
  }
  
  void *BIO_get_data__legacy(BIO *a)
  {
  	return a->ptr;
  }
  
  const unsigned char *ASN1_STRING_get0_data__legacy(const ASN1_STRING *x)
  {
  	return ASN1_STRING_data((ASN1_STRING *)x);
  }
  
  long SSL_CTX_set_options__legacy(SSL_CTX *ctx, long op)
  {
  	return SSL_CTX_ctrl(ctx, SSL_CTRL_OPTIONS, op, NULL);
  }
  
  # if defined(GIT_THREADS)
  static git_mutex *openssl_locks;
  
  static void openssl_locking_function(int mode, int n, const char *file, int line)
  {
  	int lock;
  
  	GIT_UNUSED(file);
  	GIT_UNUSED(line);
  
  	lock = mode & CRYPTO_LOCK;
  
  	if (lock)
  		(void)git_mutex_lock(&openssl_locks[n]);
  	else
  		git_mutex_unlock(&openssl_locks[n]);
  }
  
  static void shutdown_ssl_locking(void)
  {
  	int num_locks, i;
  
  	num_locks = CRYPTO_num_locks();
  	CRYPTO_set_locking_callback(NULL);
  
  	for (i = 0; i < num_locks; ++i)
  		git_mutex_free(&openssl_locks[i]);
  	git__free(openssl_locks);
  }
  
  static void threadid_cb(CRYPTO_THREADID *threadid)
  {
  	GIT_UNUSED(threadid);
  	CRYPTO_THREADID_set_numeric(threadid, git_thread_currentid());
  }
  
  int git_openssl_set_locking(void)
  {
  	int num_locks, i;
  
  #ifndef GIT_THREADS
  	git_error_set(GIT_ERROR_THREAD, "libgit2 was not built with threads");
  	return -1;
  #endif
  
  #ifdef GIT_OPENSSL_DYNAMIC
  	/*
  	 * This function is required on legacy versions of OpenSSL; when building
  	 * with dynamically-loaded OpenSSL, we detect whether we loaded it or not.
  	 */
  	if (!CRYPTO_set_locking_callback)
  		return 0;
  #endif
  
  	CRYPTO_THREADID_set_callback(threadid_cb);
  
  	num_locks = CRYPTO_num_locks();
  	openssl_locks = git__calloc(num_locks, sizeof(git_mutex));
  	GIT_ERROR_CHECK_ALLOC(openssl_locks);
  
  	for (i = 0; i < num_locks; i++) {
  		if (git_mutex_init(&openssl_locks[i]) != 0) {
  			git_error_set(GIT_ERROR_SSL, "failed to initialize openssl locks");
  			return -1;
  		}
  	}
  
  	CRYPTO_set_locking_callback(openssl_locking_function);
  	return git_runtime_shutdown_register(shutdown_ssl_locking);
  }
  #endif /* GIT_THREADS */
  
  #endif /* GIT_OPENSSL_LEGACY || GIT_OPENSSL_DYNAMIC */
  

Download