int main (void) { (void) gl_sockets_startup (SOCKETS_1_1); /* Test behaviour for invalid file descriptors. */ { struct sockaddr_in addr; addr.sin_family = AF_INET; inet_pton (AF_INET, "127.0.0.1", &addr.sin_addr); addr.sin_port = htons (80); { errno = 0; ASSERT (connect (-1, (const struct sockaddr *) &addr, sizeof (addr)) == -1); ASSERT (errno == EBADF); } { errno = 0; ASSERT (connect (99, (const struct sockaddr *) &addr, sizeof (addr)) == -1); ASSERT (errno == EBADF); } } return 0; }
int main (void) { (void) gl_sockets_startup (SOCKETS_1_1); /* Test behaviour for invalid file descriptors. */ { struct sockaddr_in addr; socklen_t addrlen = sizeof (addr); errno = 0; ASSERT (getsockname (-1, (struct sockaddr *) &addr, &addrlen) == -1); ASSERT (errno == EBADF); } { struct sockaddr_in addr; socklen_t addrlen = sizeof (addr); errno = 0; ASSERT (getsockname (99, (struct sockaddr *) &addr, &addrlen) == -1); ASSERT (errno == EBADF); } return 0; }
static int use_win32_p (void) { static int done = 0; HMODULE h; if (done) return getaddrinfo_ptr ? 1 : 0; done = 1; h = GetModuleHandle ("ws2_32.dll"); if (h) { getaddrinfo_ptr = (getaddrinfo_func) GetProcAddress (h, "getaddrinfo"); freeaddrinfo_ptr = (freeaddrinfo_func) GetProcAddress (h, "freeaddrinfo"); getnameinfo_ptr = (getnameinfo_func) GetProcAddress (h, "getnameinfo"); } /* If either is missing, something is odd. */ if (!getaddrinfo_ptr || !freeaddrinfo_ptr || !getnameinfo_ptr) { getaddrinfo_ptr = NULL; freeaddrinfo_ptr = NULL; getnameinfo_ptr = NULL; return 0; } gl_sockets_startup (SOCKETS_1_1); return 1; }
int main (void) { (void) gl_sockets_startup (SOCKETS_1_1); /* Test behaviour for invalid file descriptors. */ { char byte; struct sockaddr_in addr; socklen_t addrlen = sizeof (addr); errno = 0; ASSERT (recvfrom (-1, &byte, 1, 0, (struct sockaddr *) &addr, &addrlen) == -1); ASSERT (errno == EBADF); } { char byte; struct sockaddr_in addr; socklen_t addrlen = sizeof (addr); close (99); errno = 0; ASSERT (recvfrom (99, &byte, 1, 0, (struct sockaddr *) &addr, &addrlen) == -1); ASSERT (errno == EBADF); } return 0; }
int main (void) { (void) gl_sockets_startup (SOCKETS_1_1); /* Test behaviour for invalid file descriptors. */ { int value = 1; errno = 0; ASSERT (setsockopt (-1, SOL_SOCKET, SO_REUSEADDR, &value, sizeof (value)) == -1); ASSERT (errno == EBADF); } { int value = 1; close (99); errno = 0; ASSERT (setsockopt (99, SOL_SOCKET, SO_REUSEADDR, &value, sizeof (value)) == -1); ASSERT (errno == EBADF); } return 0; }
int main (void) { (void) gl_sockets_startup (SOCKETS_1_1); /* Test behaviour for invalid file descriptors. */ { struct sockaddr_in addr; socklen_t addrlen = sizeof (addr); errno = 0; ASSERT (accept4 (-1, (struct sockaddr *) &addr, &addrlen, O_CLOEXEC | O_BINARY) == -1); ASSERT (errno == EBADF); } { struct sockaddr_in addr; socklen_t addrlen = sizeof (addr); close (99); errno = 0; ASSERT (accept4 (99, (struct sockaddr *) &addr, &addrlen, O_CLOEXEC | O_BINARY) == -1); ASSERT (errno == EBADF); } return 0; }
static int winsock_init (void) { int r; /* http://msdn2.microsoft.com/en-us/library/ms742213.aspx */ r = gl_sockets_startup (SOCKETS_2_2); return r == 0 ? 0 : -1; }
int rpl_gethostname (char *name, size_t len) { int r; if (len > INT_MAX) len = INT_MAX; gl_sockets_startup (SOCKETS_1_1); r = gethostname (name, (int) len); if (r < 0) set_winsock_errno (); return r; }
int main () { int result; gl_sockets_startup (SOCKETS_1_1); #ifdef INTERACTIVE printf ("Please press Enter\n"); test (test_tty, "TTY"); #endif result = test (test_connect_first, "Unconnected socket test"); result += test (test_socket_pair, "Connected sockets test"); result += test (test_accept_first, "General socket test with fork"); result += test (test_pipe, "Pipe test"); exit (result); }
int rpl_socket (int domain, int type, int protocol) { SOCKET fh; gl_sockets_startup (SOCKETS_1_1); /* We have to use WSASocket() to create non-overlapped IO sockets. Overlapped IO sockets cannot be used with read/write. */ fh = WSASocket (domain, type, protocol, NULL, 0, 0); if (fh == INVALID_SOCKET) { set_winsock_errno (); return -1; } else return SOCKET_TO_FD (fh); }
int main (void) { (void) gl_sockets_startup (SOCKETS_1_1); /* Test behaviour for invalid file descriptors. */ { errno = 0; ASSERT (shutdown (-1, SHUT_RD) == -1); ASSERT (errno == EBADF); } { close (99); errno = 0; ASSERT (shutdown (99, SHUT_RD) == -1); ASSERT (errno == EBADF); } return 0; }
int main (void) { gl_sockets_startup (SOCKETS_1_1); /* Test behaviour for invalid file descriptors. */ { char byte = 'x'; errno = 0; ASSERT (send (-1, &byte, 1, 0) == -1); ASSERT (errno == EBADF); } { char byte = 'x'; errno = 0; ASSERT (send (99, &byte, 1, 0) == -1); ASSERT (errno == EBADF); } return 0; }
int main (void) { (void) gl_sockets_startup (SOCKETS_1_1); /* Test behaviour for invalid file descriptors. */ { char byte; errno = 0; ASSERT (recv (-1, &byte, 1, 0) == -1); ASSERT (errno == EBADF); } { char byte; close (99); errno = 0; ASSERT (recv (99, &byte, 1, 0) == -1); ASSERT (errno == EBADF); } return 0; }
int main (void) { int err; err = gl_sockets_startup (SOCKETS_1_1); if (err != 0) { printf ("wsastartup failed %d\n", err); return 1; } err = gl_sockets_cleanup (); if (err != 0) { printf ("wsacleanup failed %d\n", err); return 1; } (void) gl_fd_to_handle (0); return 0; }
int main (int argc, char *argv[]) { Gsasl *ctx = NULL; int res; char *in; char *connect_hostname = NULL; char *connect_service = NULL; #ifdef HAVE_LIBGNUTLS gnutls_anon_client_credentials anoncred; gnutls_certificate_credentials x509cred; #endif set_program_name (argv[0]); setlocale (LC_ALL, ""); bindtextdomain (PACKAGE, LOCALEDIR); textdomain (PACKAGE); /* This is necessary for modern MinGW compilers that provide working getaddrinfo function, which results in gnulib not detecting that it is broken. The proper fix is for gnulib to wrap the getaddrinfo call and initialize Windows sockets in the wrapper. */ (void) gl_sockets_startup (SOCKETS_1_1); if (cmdline_parser (argc, argv, &args_info) != 0) return EXIT_FAILURE; if (args_info.version_given) { const char *p = PACKAGE_NAME; if (strcmp (gsasl_check_version (NULL), PACKAGE_VERSION) != 0) p = PACKAGE_STRING; version_etc (stdout, "gsasl", p, gsasl_check_version (NULL), "Simon Josefsson", (char *) NULL); return EXIT_SUCCESS; } if (args_info.help_given) usage (EXIT_SUCCESS); if (!(args_info.client_flag || args_info.client_given) && !args_info.server_given && !args_info.client_mechanisms_flag && !args_info.server_mechanisms_flag) { error (0, 0, _("missing argument")); usage (EXIT_FAILURE); } if ((args_info.x509_cert_file_arg && !args_info.x509_key_file_arg) || (!args_info.x509_cert_file_arg && args_info.x509_key_file_arg)) error (EXIT_FAILURE, 0, _("need both --x509-cert-file and --x509-key-file")); if (args_info.starttls_flag && args_info.no_starttls_flag) error (EXIT_FAILURE, 0, _("cannot use both --starttls and --no-starttls")); if (args_info.smtp_flag && args_info.imap_flag) error (EXIT_FAILURE, 0, _("cannot use both --smtp and --imap")); if (!args_info.connect_given && args_info.inputs_num == 0 && !args_info.client_given && !args_info.server_given && !args_info.client_mechanisms_flag && !args_info.server_mechanisms_flag) { cmdline_parser_print_help (); emit_bug_reporting_address (); return EXIT_SUCCESS; } if (args_info.connect_given) { if (strrchr (args_info.connect_arg, ':')) { connect_hostname = xstrdup (args_info.connect_arg); *strrchr (connect_hostname, ':') = '\0'; connect_service = xstrdup (strrchr (args_info.connect_arg, ':') + 1); } else { connect_hostname = xstrdup (args_info.connect_arg); if (args_info.smtp_flag) connect_service = xstrdup ("smtp"); else connect_service = xstrdup ("imap"); } } else if (args_info.inputs_num > 0) { connect_hostname = args_info.inputs[0]; if (args_info.inputs_num > 1) connect_service = args_info.inputs[1]; else if (args_info.smtp_flag) connect_service = xstrdup ("smtp"); else connect_service = xstrdup ("imap"); } if (connect_service && !args_info.smtp_flag && !args_info.imap_flag) { if (strcmp (connect_service, "25") == 0 || strcmp (connect_service, "smtp") == 0) args_info.smtp_flag = 1; else args_info.imap_flag = 1; } if (args_info.imap_flag && !args_info.service_given) args_info.service_arg = xstrdup ("imap"); if (args_info.smtp_flag && !args_info.service_given) args_info.service_arg = xstrdup ("smtp"); if (args_info.imap_flag || args_info.smtp_flag) args_info.no_client_first_flag = 1; if (connect_hostname && !args_info.hostname_arg) args_info.hostname_arg = xstrdup (connect_hostname); if (!isatty (STDOUT_FILENO)) setvbuf (stdout, NULL, _IOLBF, BUFSIZ); res = gsasl_init (&ctx); if (res != GSASL_OK) error (EXIT_FAILURE, 0, _("initialization failure: %s"), gsasl_strerror (res)); gsasl_callback_set (ctx, callback); if (args_info.client_mechanisms_flag || args_info.server_mechanisms_flag) { char *mechs; if (args_info.client_mechanisms_flag) res = gsasl_client_mechlist (ctx, &mechs); else res = gsasl_server_mechlist (ctx, &mechs); if (res != GSASL_OK) error (EXIT_FAILURE, 0, _("error listing mechanisms: %s"), gsasl_strerror (res)); if (!args_info.quiet_given) { if (args_info.client_mechanisms_flag) fprintf (stderr, _("This client supports the following mechanisms:\n")); else fprintf (stderr, _("This server supports the following mechanisms:\n")); } fprintf (stdout, "%s\n", mechs); free (mechs); return EXIT_SUCCESS; } if (args_info.connect_given || args_info.inputs_num > 0) { struct addrinfo hints; struct addrinfo *ai0, *ai; memset (&hints, 0, sizeof (hints)); hints.ai_flags = AI_CANONNAME; hints.ai_socktype = SOCK_STREAM; res = getaddrinfo (connect_hostname, connect_service, &hints, &ai0); if (res != 0) error (EXIT_FAILURE, 0, "%s: %s", connect_hostname, gai_strerror (res)); for (ai = ai0; ai; ai = ai->ai_next) { fprintf (stderr, "Trying %s...\n", quote (ai->ai_canonname ? ai->ai_canonname : connect_hostname)); sockfd = socket (ai->ai_family, ai->ai_socktype, ai->ai_protocol); if (sockfd < 0) { error (0, errno, "socket"); continue; } if (connect (sockfd, ai->ai_addr, ai->ai_addrlen) < 0) { int save_errno = errno; close (sockfd); sockfd = -1; error (0, save_errno, "connect"); continue; } break; } if (sockfd < 0) error (EXIT_FAILURE, errno, "socket"); freeaddrinfo (ai); } if (!greeting ()) return 1; #ifdef HAVE_LIBGNUTLS if (sockfd && !args_info.no_starttls_flag && (args_info.starttls_flag || has_starttls ())) { res = gnutls_global_init (); if (res < 0) error (EXIT_FAILURE, 0, _("GnuTLS global initialization failed: %s"), gnutls_strerror (res)); res = gnutls_init (&session, GNUTLS_CLIENT); if (res < 0) error (EXIT_FAILURE, 0, _("GnuTLS initialization failed: %s"), gnutls_strerror (res)); res = gnutls_set_default_priority (session); if (res < 0) error (EXIT_FAILURE, 0, _("setting GnuTLS defaults failed: %s"), gnutls_strerror (res)); res = gnutls_anon_allocate_client_credentials (&anoncred); if (res < 0) error (EXIT_FAILURE, 0, _("allocating anonymous GnuTLS credential: %s"), gnutls_strerror (res)); res = gnutls_credentials_set (session, GNUTLS_CRD_ANON, anoncred); if (res < 0) error (EXIT_FAILURE, 0, _("setting anonymous GnuTLS credential: %s"), gnutls_strerror (res)); res = gnutls_certificate_allocate_credentials (&x509cred); if (res < 0) error (EXIT_FAILURE, 0, _("allocating X.509 GnuTLS credential: %s"), gnutls_strerror (res)); if (args_info.x509_cert_file_arg && args_info.x509_key_file_arg) res = gnutls_certificate_set_x509_key_file (x509cred, args_info.x509_cert_file_arg, args_info.x509_key_file_arg, GNUTLS_X509_FMT_PEM); if (res != GNUTLS_E_SUCCESS) error (EXIT_FAILURE, 0, _("loading X.509 GnuTLS credential: %s"), gnutls_strerror (res)); if (args_info.x509_ca_file_arg) { res = gnutls_certificate_set_x509_trust_file (x509cred, args_info.x509_ca_file_arg, GNUTLS_X509_FMT_PEM); if (res < 0) error (EXIT_FAILURE, 0, _("no X.509 CAs found: %s"), gnutls_strerror (res)); if (res == 0) error (EXIT_FAILURE, 0, _("no X.509 CAs found")); } res = gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, x509cred); if (res < 0) error (EXIT_FAILURE, 0, _("setting X.509 GnuTLS credential: %s"), gnutls_strerror (res)); if (args_info.priority_arg) { const char *err_pos; res = gnutls_priority_set_direct (session, args_info.priority_arg, &err_pos); if (res < 0) error (EXIT_FAILURE, 0, _("setting GnuTLS cipher priority (%s): %s\n"), gnutls_strerror (res), err_pos); } gnutls_transport_set_ptr (session, (gnutls_transport_ptr) (unsigned long) sockfd); if (!starttls ()) return 1; res = gnutls_handshake (session); if (res < 0) error (EXIT_FAILURE, 0, _("GnuTLS handshake failed: %s"), gnutls_strerror (res)); if (args_info.x509_ca_file_arg) { unsigned int status; res = gnutls_certificate_verify_peers2 (session, &status); if (res < 0) error (EXIT_FAILURE, 0, _("verifying peer certificate: %s"), gnutls_strerror (res)); if (status & GNUTLS_CERT_INVALID) error (EXIT_FAILURE, 0, _("server certificate is not trusted")); if (status & GNUTLS_CERT_SIGNER_NOT_FOUND) error (EXIT_FAILURE, 0, _("server certificate hasn't got a known issuer")); if (status & GNUTLS_CERT_REVOKED) error (EXIT_FAILURE, 0, _("server certificate has been revoked")); if (status != 0) error (EXIT_FAILURE, 0, _("could not verify server certificate (rc=%d)"), status); } #if HAVE_GNUTLS_SESSION_CHANNEL_BINDING if (!args_info.no_cb_flag) { gnutls_datum cb; res = gnutls_session_channel_binding (session, GNUTLS_CB_TLS_UNIQUE, &cb); if (res != GNUTLS_E_SUCCESS) error (EXIT_FAILURE, 0, _("getting channel binding failed: %s"), gnutls_strerror (res)); res = gsasl_base64_to ((char *) cb.data, cb.size, &b64cbtlsunique, NULL); if (res != GSASL_OK) error (EXIT_FAILURE, 0, "%s", gsasl_strerror (res)); } #endif using_tls = true; } #endif if (args_info.client_flag || args_info.client_given || args_info.server_given) { char *out; char *b64output; size_t output_len; size_t b64output_len; const char *mech; Gsasl_session *xctx = NULL; if (!select_mechanism (&in)) return 1; mech = gsasl_client_suggest_mechanism (ctx, in); if (mech == NULL) { fprintf (stderr, _("Cannot find mechanism...\n")); return 0; } if (args_info.mechanism_arg) mech = args_info.mechanism_arg; if (!authenticate (mech)) return 1; /* Authenticate using mechanism */ if (args_info.server_flag) res = gsasl_server_start (ctx, mech, &xctx); else res = gsasl_client_start (ctx, mech, &xctx); if (res != GSASL_OK) error (EXIT_FAILURE, 0, _("mechanism unavailable: %s"), gsasl_strerror (res)); in = NULL; out = NULL; if (!args_info.server_flag && args_info.no_client_first_flag) { res = GSASL_NEEDS_MORE; goto no_client_first; } do { int res2; res = gsasl_step64 (xctx, in, &out); if (res != GSASL_NEEDS_MORE && res != GSASL_OK) break; if (!step_send (out)) return 1; no_client_first: if (!args_info.quiet_given && !args_info.imap_flag && !args_info.smtp_flag) { if (args_info.server_flag) fprintf (stderr, _("Enter base64 authentication data " "from client (press RET if none):\n")); else fprintf (stderr, _("Enter base64 authentication data " "from server (press RET if none):\n")); } /* Return 1 on token, 2 on protocol success, 3 on protocol fail, 0 on errors. */ res2 = step_recv (&in); if (!res2) return 1; if (res2 == 3) error (EXIT_FAILURE, 0, _("server error")); if (res2 == 2) break; } while (args_info.imap_flag || args_info.smtp_flag || res == GSASL_NEEDS_MORE); if (res != GSASL_OK) error (EXIT_FAILURE, 0, _("mechanism error: %s"), gsasl_strerror (res)); if (!args_info.quiet_given) { if (args_info.server_flag) fprintf (stderr, _("Server authentication " "finished (client trusted)...\n")); else fprintf (stderr, _("Client authentication " "finished (server trusted)...\n")); fflush (stderr); } /* Transfer application payload */ if (args_info.application_data_flag) { struct pollfd pfd[2]; char *sockbuf = NULL; /* we read chunks of 1000 bytes at a time */ size_t sockpos = 0, sockalloc = 0, sockalloc1 = 1000; /* Setup pollfd structs... */ pfd[0].fd = STDIN_FILENO; pfd[0].events = POLLIN; if (sockfd) { pfd[1].fd = sockfd; pfd[1].events = POLLIN; } if (!args_info.quiet_given) { fprintf (stderr, _("Enter application data (EOF to finish):\n")); fflush (stderr); } while (1) { int rc; pfd[0].revents = 0; pfd[1].revents = 0; rc = poll (pfd, sockfd ? 2 : 1, -1); if (rc < 0 && errno == EINTR) continue; /* Always check for errors */ if (rc < 0) error (EXIT_FAILURE, errno, "poll"); /* We got data to read from stdin.. */ if ((pfd[0].revents & (POLLIN | POLLERR)) == POLLIN) { char *line = NULL; size_t n; ssize_t len; len = getline (&line, &n, stdin); if (len <= 0) break; if (args_info.imap_flag || args_info.smtp_flag) { if (len < 2 || strcmp (&line[len - 2], "\r\n") != 0) { line = xrealloc (line, len + 2); line[len - 1] = '\r'; line[len] = '\n'; line[len + 1] = '\0'; len++; } } else { len--; line[len] = '\0'; } res = gsasl_encode (xctx, line, len, &out, &output_len); if (res != GSASL_OK) break; if (sockfd) { #ifdef HAVE_LIBGNUTLS if (using_tls) len = gnutls_record_send (session, out, output_len); else #endif len = write (sockfd, out, output_len); if (len != output_len) error (EXIT_FAILURE, errno, "write"); } else if (!(strlen (line) == output_len && memcmp (line, out, output_len) == 0)) { res = gsasl_base64_to (out, output_len, &b64output, &b64output_len); if (res != GSASL_OK) break; if (!args_info.quiet_given) fprintf (stderr, _("Base64 encoded application " "data to send:\n")); fprintf (stdout, "%s\n", b64output); free (b64output); } free (line); free (out); } /* If there was an error, quit. */ else if (pfd[0].revents & (POLLERR | POLLHUP)) { error (0, 0, "poll stdin"); break; } /* We got data to read from the socket.. */ if (sockfd && (pfd[1].revents & (POLLIN | POLLERR)) == POLLIN) { ssize_t len; if (sockalloc == sockpos) sockbuf = x2realloc (sockbuf, &sockalloc1); sockalloc = sockalloc1; #ifdef HAVE_LIBGNUTLS if (using_tls) len = gnutls_record_recv (session, &sockbuf[sockpos], sockalloc - sockpos); else #endif len = recv (sockfd, &sockbuf[sockpos], sockalloc - sockpos, 0); if (len <= 0) break; sockpos += len; res = gsasl_decode (xctx, sockbuf, sockpos, &out, &output_len); if (res == GSASL_NEEDS_MORE) { #define MAX_INPUT_SIZE 0x100000 if (sockpos > MAX_INPUT_SIZE) error (EXIT_FAILURE, 0, _("SASL record too large: %zu\n"), sockpos); continue; } if (res != GSASL_OK) break; free (sockbuf); sockbuf = NULL; sockpos = 0; sockalloc = 0; sockalloc1 = 1000; printf ("%.*s", (int) output_len, out); free (out); } /* If there was an error, quit. */ else if (pfd[1].revents & (POLLERR | POLLHUP)) { error (0, 0, "poll socket"); break; } } if (res != GSASL_OK) error (EXIT_FAILURE, 0, _("encoding error: %s"), gsasl_strerror (res)); } if (!args_info.quiet_given) fprintf (stderr, _("Session finished...\n")); if (!logout ()) return 1; gsasl_finish (xctx); } if (sockfd) { #ifdef HAVE_LIBGNUTLS if (using_tls) { res = gnutls_bye (session, GNUTLS_SHUT_RDWR); if (res < 0) error (EXIT_FAILURE, 0, _("terminating GnuTLS session failed: %s"), gnutls_strerror (res)); } #endif shutdown (sockfd, SHUT_RDWR); close (sockfd); } gsasl_done (ctx); #ifdef HAVE_LIBGNUTLS if (using_tls) { gnutls_deinit (session); gnutls_anon_free_client_credentials (anoncred); gnutls_certificate_free_credentials (x509cred); gnutls_global_deinit (); } #endif return 0; }
static Shishi * init_handle (int outputtype) { Shishi *handle; int rc; handle = xcalloc (1, sizeof (*handle)); shishi_error_set_outputtype (handle, outputtype); if (!shishi_check_version (SHISHI_VERSION)) { shishi_warn (handle, "Library and header version missmatch (%s vs %s).", shishi_check_version (NULL), SHISHI_VERSION); free (handle); return NULL; } rc = gl_sockets_startup (SOCKETS_2_1); if (rc) { shishi_warn (handle, "Failed to initialized Windows sockets (%d)", rc); free (handle); return NULL; } rc = _shishi_crypto_init (handle); if (rc != SHISHI_OK) { shishi_warn (handle, "Cannot initialize crypto library"); free (handle); return NULL; } #ifdef USE_STARTTLS rc = _shishi_tls_init (handle); if (rc != SHISHI_OK) { shishi_warn (handle, "Cannot initialize TLS library"); free (handle); return NULL; } #endif rc = _shishi_asn1_init (handle); if (rc != SHISHI_OK) { shishi_warn (handle, "%s", shishi_strerror (SHISHI_ASN1_ERROR)); free (handle); return NULL; } bindtextdomain (PACKAGE, LOCALEDIR); textdomain (PACKAGE); handle->kdctimeout = 5; handle->kdcretries = 3; handle->ticketlife = TICKETLIFE; handle->renewlife = RENEWLIFE; handle->nclientkdcetypes = 1; handle->clientkdcetypes = xmalloc (sizeof (*handle->clientkdcetypes) * handle->nclientkdcetypes); handle->clientkdcetypes[0] = SHISHI_AES256_CTS_HMAC_SHA1_96; handle->nauthorizationtypes = 1; handle->authorizationtypes = xmalloc (sizeof (*handle->authorizationtypes) * handle->nauthorizationtypes); handle->authorizationtypes[0] = SHISHI_AUTHORIZATION_BASIC; return handle; }
/** * gnutls_global_init: * * This function performs any required precalculations, detects * the supported CPU capabilities and initializes the underlying * cryptographic backend. In order to free any resources * taken by this call you should gnutls_global_deinit() * when gnutls usage is no longer needed. * * This function increments a global counter, so that * gnutls_global_deinit() only releases resources when it has been * called as many times as gnutls_global_init(). This is useful when * GnuTLS is used by more than one library in an application. This * function can be called many times, but will only do something the * first time. * * Note! This function is not thread safe. If two threads call this * function simultaneously, they can cause a race between checking * the global counter and incrementing it, causing both threads to * execute the library initialization code. That would lead to a * memory leak. To handle this, your application could invoke this * function after aquiring a thread mutex. To ignore the potential * memory leak is also an option. * * Returns: On success, %GNUTLS_E_SUCCESS (0) is returned, * otherwise a negative error code is returned. **/ int gnutls_global_init (void) { int result = 0; int res; if (_gnutls_init++) goto out; if (gl_sockets_startup (SOCKETS_1_1)) return gnutls_assert_val(GNUTLS_E_FILE_ERROR); bindtextdomain (PACKAGE, LOCALEDIR); res = gnutls_crypto_init (); if (res != 0) { gnutls_assert (); return GNUTLS_E_CRYPTO_INIT_FAILED; } _gnutls_register_accel_crypto(); /* initialize ASN.1 parser * This should not deal with files in the final * version. */ if (asn1_check_version (GNUTLS_MIN_LIBTASN1_VERSION) == NULL) { gnutls_assert (); _gnutls_debug_log ("Checking for libtasn1 failed: %s < %s\n", asn1_check_version (NULL), GNUTLS_MIN_LIBTASN1_VERSION); return GNUTLS_E_INCOMPATIBLE_LIBTASN1_LIBRARY; } res = asn1_array2tree (pkix_asn1_tab, &_gnutls_pkix1_asn, NULL); if (res != ASN1_SUCCESS) { result = _gnutls_asn2err (res); goto out; } res = asn1_array2tree (gnutls_asn1_tab, &_gnutls_gnutls_asn, NULL); if (res != ASN1_SUCCESS) { result = _gnutls_asn2err (res); goto out; } /* Initialize the random generator */ result = _gnutls_rnd_init (); if (result < 0) { gnutls_assert (); goto out; } /* Initialize the default TLS extensions */ result = _gnutls_ext_init (); if (result < 0) { gnutls_assert (); goto out; } result = gnutls_mutex_init(&_gnutls_file_mutex); if (result < 0) { gnutls_assert(); goto out; } result = gnutls_system_global_init (); if (result < 0) { gnutls_assert (); goto out; } #ifdef ENABLE_PKCS11 gnutls_pkcs11_init (GNUTLS_PKCS11_FLAG_AUTO, NULL); #endif _gnutls_cryptodev_init (); out: return result; }
/** * gnutls_global_init: * * This function initializes the global data to defaults. Every * gnutls application has a global data which holds common parameters * shared by gnutls session structures. You should call * gnutls_global_deinit() when gnutls usage is no longer needed * * Note that this function will also initialize libgcrypt, if it has * not been initialized before. Thus if you want to manually * initialize libgcrypt you must do it before calling this function. * This is useful in cases you want to disable libgcrypt's internal * lockings etc. * * This function increment a global counter, so that * gnutls_global_deinit() only releases resources when it has been * called as many times as gnutls_global_init(). This is useful when * GnuTLS is used by more than one library in an application. This * function can be called many times, but will only do something the * first time. * * Note! This function is not thread safe. If two threads call this * function simultaneously, they can cause a race between checking * the global counter and incrementing it, causing both threads to * execute the library initialization code. That would lead to a * memory leak. To handle this, your application could invoke this * function after aquiring a thread mutex. To ignore the potential * memory leak is also an option. * * Returns: On success, %GNUTLS_E_SUCCESS (zero) is returned, * otherwise an error code is returned. **/ int gnutls_global_init (void) { int result = 0; int res; if (_gnutls_init++) goto out; if (gl_sockets_startup (SOCKETS_1_1)) return GNUTLS_E_LIBRARY_VERSION_MISMATCH; bindtextdomain (PACKAGE, LOCALEDIR); /* Initialize libgcrypt if it hasn't already been initialized. */ if (gcry_control (GCRYCTL_ANY_INITIALIZATION_P) == 0) { const char *p; p = gcry_check_version (GNUTLS_MIN_LIBGCRYPT_VERSION); if (p == NULL) { gnutls_assert (); _gnutls_debug_log ("Checking for libgcrypt failed: %s < %s\n", gcry_check_version (NULL), GNUTLS_MIN_LIBGCRYPT_VERSION); return GNUTLS_E_INCOMPATIBLE_GCRYPT_LIBRARY; } /* for gcrypt in order to be able to allocate memory */ gcry_control (GCRYCTL_DISABLE_SECMEM, NULL, 0); gcry_control (GCRYCTL_INITIALIZATION_FINISHED, NULL, 0); } /* initialize ASN.1 parser * This should not deal with files in the final * version. */ if (asn1_check_version (GNUTLS_MIN_LIBTASN1_VERSION) == NULL) { gnutls_assert (); _gnutls_debug_log ("Checking for libtasn1 failed: %s < %s\n", asn1_check_version (NULL), GNUTLS_MIN_LIBTASN1_VERSION); return GNUTLS_E_INCOMPATIBLE_LIBTASN1_LIBRARY; } res = asn1_array2tree (pkix_asn1_tab, &_gnutls_pkix1_asn, NULL); if (res != ASN1_SUCCESS) { result = _gnutls_asn2err (res); goto out; } res = asn1_array2tree (gnutls_asn1_tab, &_gnutls_gnutls_asn, NULL); if (res != ASN1_SUCCESS) { asn1_delete_structure (&_gnutls_pkix1_asn); result = _gnutls_asn2err (res); goto out; } /* Initialize the random generator */ result = _gnutls_rnd_init (); if (result < 0) { gnutls_assert (); goto out; } /* Initialize the default TLS extensions */ result = _gnutls_ext_init (); if (result < 0) { gnutls_assert (); goto out; } _gnutls_cryptodev_init (); out: return result; }