static int digest_init(EVP_MD_CTX *ctx) { struct digest_ctx *digest_ctx = (struct digest_ctx *)EVP_MD_CTX_md_data(ctx); const struct digest_data_st *digest_d = get_digest_data(EVP_MD_CTX_type(ctx)); if (digest_ctx->init == 0 && (digest_ctx->cfd = open("/dev/crypto", O_RDWR, 0)) < 0) { SYSerr(SYS_F_OPEN, errno); return 0; } digest_ctx->init = 1; memset(&digest_ctx->sess, 0, sizeof(digest_ctx->sess)); digest_ctx->sess.mac = digest_d->devcryptoid; if (ioctl(digest_ctx->cfd, CIOCGSESSION, &digest_ctx->sess) < 0) { SYSerr(SYS_F_IOCTL, errno); close(digest_ctx->cfd); return 0; } return 1; }
static int cipher_init(EVP_CIPHER_CTX *ctx, const unsigned char *key, const unsigned char *iv, int enc) { struct cipher_ctx *cipher_ctx = (struct cipher_ctx *)EVP_CIPHER_CTX_get_cipher_data(ctx); const struct cipher_data_st *cipher_d = get_cipher_data(EVP_CIPHER_CTX_nid(ctx)); if ((cipher_ctx->cfd = open("/dev/crypto", O_RDWR, 0)) < 0) { SYSerr(SYS_F_OPEN, errno); return 0; } memset(&cipher_ctx->sess, 0, sizeof(cipher_ctx->sess)); cipher_ctx->sess.cipher = cipher_d->devcryptoid; cipher_ctx->sess.keylen = cipher_d->keylen; cipher_ctx->sess.key = (void *)key; cipher_ctx->op = enc ? COP_ENCRYPT : COP_DECRYPT; if (ioctl(cipher_ctx->cfd, CIOCGSESSION, &cipher_ctx->sess) < 0) { SYSerr(SYS_F_IOCTL, errno); close(cipher_ctx->cfd); return 0; } return 1; }
int BIO_sock_init(void) { #ifdef OPENSSL_SYS_WINDOWS static struct WSAData wsa_state; if (!wsa_init_done) { int err; #ifdef SIGINT signal(SIGINT,(void (*)(int))BIO_sock_cleanup); #endif wsa_init_done=1; memset(&wsa_state,0,sizeof(wsa_state)); if (WSAStartup(0x0101,&wsa_state)!=0) { err=WSAGetLastError(); SYSerr(SYS_F_WSASTARTUP,err); BIOerr(BIO_F_BIO_SOCK_INIT,BIO_R_WSASTARTUP); return(-1); } } #endif /* OPENSSL_SYS_WINDOWS */ #ifdef WATT32 extern int _watt_do_exit; _watt_do_exit = 0; /* don't make sock_init() call exit() */ if (sock_init()) return (-1); #endif #if defined(OPENSSL_SYS_NETWARE) && !defined(NETWARE_BSDSOCK) WORD wVerReq; WSADATA wsaData; int err; if (!wsa_init_done) { # ifdef SIGINT signal(SIGINT,(void (*)(int))BIO_sock_cleanup); # endif wsa_init_done=1; wVerReq = MAKEWORD( 2, 0 ); err = WSAStartup(wVerReq,&wsaData); if (err != 0) { SYSerr(SYS_F_WSASTARTUP,err); BIOerr(BIO_F_BIO_SOCK_INIT,BIO_R_WSASTARTUP); return(-1); } } #endif return(1); }
int BIO_sock_init(void) { #ifdef OPENSSL_SYS_WINDOWS static struct WSAData wsa_state; if (!wsa_init_done) { int err; wsa_init_done=1; memset(&wsa_state,0,sizeof(wsa_state)); /* Not making wsa_state available to the rest of the * code is formally wrong. But the structures we use * are [beleived to be] invariable among Winsock DLLs, * while API availability is [expected to be] probed * at run-time with DSO_global_lookup. */ if (WSAStartup(0x0202,&wsa_state)!=0) { err=WSAGetLastError(); SYSerr(SYS_F_WSASTARTUP,err); BIOerr(BIO_F_BIO_SOCK_INIT,BIO_R_WSASTARTUP); return(-1); } } #endif /* OPENSSL_SYS_WINDOWS */ #ifdef WATT32 extern int _watt_do_exit; _watt_do_exit = 0; /* don't make sock_init() call exit() */ if (sock_init()) return (-1); #endif #if defined(OPENSSL_SYS_NETWARE) && !defined(NETWARE_BSDSOCK) WORD wVerReq; WSADATA wsaData; int err; if (!wsa_init_done) { wsa_init_done=1; wVerReq = MAKEWORD( 2, 0 ); err = WSAStartup(wVerReq,&wsaData); if (err != 0) { SYSerr(SYS_F_WSASTARTUP,err); BIOerr(BIO_F_BIO_SOCK_INIT,BIO_R_WSASTARTUP); return(-1); } } #endif return(1); }
static int digest_final(EVP_MD_CTX *ctx, unsigned char *md) { struct digest_ctx *digest_ctx = (struct digest_ctx *)EVP_MD_CTX_md_data(ctx); if (digest_op(digest_ctx, NULL, 0, md, COP_FLAG_FINAL) < 0) { SYSerr(SYS_F_IOCTL, errno); return 0; } if (ioctl(digest_ctx->cfd, CIOCFSESSION, &digest_ctx->sess) < 0) { SYSerr(SYS_F_IOCTL, errno); return 0; } return 1; }
static int cipher_cleanup(EVP_CIPHER_CTX *ctx) { struct cipher_ctx *cipher_ctx = (struct cipher_ctx *)EVP_CIPHER_CTX_get_cipher_data(ctx); if (ioctl(cipher_ctx->cfd, CIOCFSESSION, &cipher_ctx->sess) < 0) { SYSerr(SYS_F_IOCTL, errno); return 0; } if (close(cipher_ctx->cfd) < 0) { SYSerr(SYS_F_CLOSE, errno); return 0; } return 1; }
/* * Check whether included path is a directory. * Returns next BIO to process and in case of a directory * also an opened directory context and the include path. */ static BIO *process_include(char *include, OPENSSL_DIR_CTX **dirctx, char **dirpath) { struct stat st = { 0 }; BIO *next; if (stat(include, &st) < 0) { SYSerr(SYS_F_STAT, errno); ERR_add_error_data(1, include); /* missing include file is not fatal error */ return NULL; } if (S_ISDIR(st.st_mode)) { if (*dirctx != NULL) { CONFerr(CONF_F_PROCESS_INCLUDE, CONF_R_RECURSIVE_DIRECTORY_INCLUDE); ERR_add_error_data(1, include); return NULL; } /* a directory, load its contents */ if ((next = get_next_file(include, dirctx)) != NULL) *dirpath = include; return next; } next = BIO_new_file(include, "r"); return next; }
BIO *BIO_new_file(const char *filename, const char *mode) { BIO *ret; FILE *file; if ((file=fopen(filename,mode)) == NULL) { SYSerr(SYS_F_FOPEN,get_last_sys_error()); ERR_add_error_data(5,"fopen('",filename,"','",mode,"')"); if (errno == ENOENT) BIOerr(BIO_F_BIO_NEW_FILE,BIO_R_NO_SUCH_FILE); else BIOerr(BIO_F_BIO_NEW_FILE,ERR_R_SYS_LIB); return(NULL); } if ((ret=BIO_new(BIO_s_file_internal())) == NULL) { fclose(file); return(NULL); } BIO_clear_flags(ret,BIO_FLAGS_UPLINK); /* we did fopen -> we disengage UPLINK */ BIO_set_fp(ret,file,BIO_CLOSE); return(ret); }
static int cipher_init(EVP_CIPHER_CTX *ctx, const unsigned char *key, const unsigned char *iv, int enc) { struct cipher_ctx *cipher_ctx = (struct cipher_ctx *)EVP_CIPHER_CTX_get_cipher_data(ctx); const struct cipher_data_st *cipher_d = get_cipher_data(EVP_CIPHER_CTX_nid(ctx)); /* cleanup a previous session */ if (cipher_ctx->sess.ses != 0 && clean_devcrypto_session(&cipher_ctx->sess) == 0) return 0; cipher_ctx->sess.cipher = cipher_d->devcryptoid; cipher_ctx->sess.keylen = cipher_d->keylen; cipher_ctx->sess.key = (void *)key; cipher_ctx->op = enc ? COP_ENCRYPT : COP_DECRYPT; cipher_ctx->mode = cipher_d->flags & EVP_CIPH_MODE; cipher_ctx->blocksize = cipher_d->blocksize; if (ioctl(cfd, CIOCGSESSION, &cipher_ctx->sess) < 0) { SYSerr(SYS_F_IOCTL, errno); return 0; } return 1; }
/*- * addr_strings - helper function to get host and service names * @ap: the BIO_ADDR that has the input info * @numeric: 0 if actual names should be returned, 1 if the numeric * representation should be returned. * @hostname: a pointer to a pointer to a memory area to store the * host name or numeric representation. Unused if NULL. * @service: a pointer to a pointer to a memory area to store the * service name or numeric representation. Unused if NULL. * * The return value is 0 on failure, with the error code in the error * stack, and 1 on success. */ static int addr_strings(const BIO_ADDR *ap, int numeric, char **hostname, char **service) { if (BIO_sock_init() != 1) return 0; if (1) { #ifdef AI_PASSIVE int ret = 0; char host[NI_MAXHOST] = "", serv[NI_MAXSERV] = ""; int flags = 0; if (numeric) flags |= NI_NUMERICHOST | NI_NUMERICSERV; if ((ret = getnameinfo(BIO_ADDR_sockaddr(ap), BIO_ADDR_sockaddr_size(ap), host, sizeof(host), serv, sizeof(serv), flags)) != 0) { # ifdef EAI_SYSTEM if (ret == EAI_SYSTEM) { SYSerr(SYS_F_GETNAMEINFO, get_last_socket_error()); BIOerr(BIO_F_ADDR_STRINGS, ERR_R_SYS_LIB); } else # endif { BIOerr(BIO_F_ADDR_STRINGS, ERR_R_SYS_LIB); ERR_add_error_data(1, gai_strerror(ret)); } return 0; } /* VMS getnameinfo() has a bug, it doesn't fill in serv, which * leaves it with whatever garbage that happens to be there. * However, we initialise serv with the empty string (serv[0] * is therefore NUL), so it gets real easy to detect when things * didn't go the way one might expect. */ if (serv[0] == '\0') { BIO_snprintf(serv, sizeof(serv), "%d", ntohs(BIO_ADDR_rawport(ap))); } if (hostname) *hostname = OPENSSL_strdup(host); if (service) *service = OPENSSL_strdup(serv); } else { #endif if (hostname) *hostname = OPENSSL_strdup(inet_ntoa(ap->s_in.sin_addr)); if (service) { char serv[6]; /* port is 16 bits => max 5 decimal digits */ BIO_snprintf(serv, sizeof(serv), "%d", ntohs(ap->s_in.sin_port)); *service = OPENSSL_strdup(serv); } } return 1; }
int BIO_sock_init(void) { # ifdef OPENSSL_SYS_WINDOWS static struct WSAData wsa_state; if (!wsa_init_done) { int err; wsa_init_done = 1; memset(&wsa_state, 0, sizeof(wsa_state)); /* * Not making wsa_state available to the rest of the code is formally * wrong. But the structures we use are [believed to be] invariable * among Winsock DLLs, while API availability is [expected to be] * probed at run-time with DSO_global_lookup. */ if (WSAStartup(0x0202, &wsa_state) != 0) { err = WSAGetLastError(); SYSerr(SYS_F_WSASTARTUP, err); BIOerr(BIO_F_BIO_SOCK_INIT, BIO_R_WSASTARTUP); return (-1); } } # endif /* OPENSSL_SYS_WINDOWS */ # ifdef WATT32 extern int _watt_do_exit; _watt_do_exit = 0; /* don't make sock_init() call exit() */ if (sock_init()) return (-1); # endif return (1); }
int BIO_accept(int sock, char **ip_port) { BIO_ADDR res; int ret = -1; ret = BIO_accept_ex(sock, &res, 0); if (ret == (int)INVALID_SOCKET) { if (BIO_sock_should_retry(ret)) { ret = -2; goto end; } SYSerr(SYS_F_ACCEPT, get_last_socket_error()); BIOerr(BIO_F_BIO_ACCEPT, BIO_R_ACCEPT_ERROR); goto end; } if (ip_port != NULL) { char *host = BIO_ADDR_hostname_string(&res, 1); char *port = BIO_ADDR_service_string(&res, 1); *ip_port = OPENSSL_zalloc(strlen(host) + strlen(port) + 2); strcpy(*ip_port, host); strcat(*ip_port, ":"); strcat(*ip_port, port); OPENSSL_free(host); OPENSSL_free(port); } end: return ret; }
/*- * BIO_accept_ex - Accept new incoming connections * @sock: the listening socket * @addr: the BIO_ADDR to store the peer address in * @options: BIO socket options, applied on the accepted socket. * */ int BIO_accept_ex(int accept_sock, BIO_ADDR *addr_, int options) { socklen_t len; int accepted_sock; BIO_ADDR locaddr; BIO_ADDR *addr = addr_ == NULL ? &locaddr : addr_; len = sizeof(*addr); accepted_sock = accept(accept_sock, BIO_ADDR_sockaddr_noconst(addr), &len); if (accepted_sock == -1) { if (!BIO_sock_should_retry(accepted_sock)) { SYSerr(SYS_F_ACCEPT, get_last_socket_error()); BIOerr(BIO_F_BIO_ACCEPT_EX, BIO_R_ACCEPT_ERROR); } return INVALID_SOCKET; } if (!BIO_socket_nbio(accepted_sock, (options & BIO_SOCK_NONBLOCK) != 0)) { closesocket(accepted_sock); return INVALID_SOCKET; } return accepted_sock; }
int BIO_sock_info(int sock, enum BIO_sock_info_type type, union BIO_sock_info_u *info) { switch (type) { case BIO_SOCK_INFO_ADDRESS: { socklen_t addr_len; int ret = 0; addr_len = sizeof(*info->addr); ret = getsockname(sock, BIO_ADDR_sockaddr_noconst(info->addr), &addr_len); if (ret == -1) { SYSerr(SYS_F_GETSOCKNAME, get_last_socket_error()); BIOerr(BIO_F_BIO_SOCK_INFO, BIO_R_GETSOCKNAME_ERROR); return 0; } if ((size_t)addr_len > sizeof(*info->addr)) { BIOerr(BIO_F_BIO_SOCK_INFO, BIO_R_GETSOCKNAME_TRUNCATED_ADDRESS); return 0; } } break; default: BIOerr(BIO_F_BIO_SOCK_INFO, BIO_R_UNKNOWN_INFO_TYPE); return 0; } return 1; }
BIO *BIO_new_file(const char *filename, const char *mode) { BIO *ret; FILE *file = openssl_fopen(filename, mode); int fp_flags = BIO_CLOSE; if (strchr(mode, 'b') == NULL) fp_flags |= BIO_FP_TEXT; if (file == NULL) { SYSerr(SYS_F_FOPEN, get_last_sys_error()); ERR_add_error_data(5, "fopen('", filename, "','", mode, "')"); if (errno == ENOENT # ifdef ENXIO || errno == ENXIO # endif ) BIOerr(BIO_F_BIO_NEW_FILE, BIO_R_NO_SUCH_FILE); else BIOerr(BIO_F_BIO_NEW_FILE, ERR_R_SYS_LIB); return NULL; } if ((ret = BIO_new(BIO_s_file())) == NULL) { fclose(file); return NULL; } BIO_clear_flags(ret, BIO_FLAGS_UPLINK); /* we did fopen -> we disengage * UPLINK */ BIO_set_fp(ret, file, fp_flags); return ret; }
BIO * BIO_new_file(const char *filename, const char *mode) { BIO *ret; FILE *file = NULL; file = fopen(filename, mode); if (file == NULL) { SYSerr(SYS_F_FOPEN, errno); ERR_asprintf_error_data("fopen('%s', '%s')", filename, mode); if (errno == ENOENT) BIOerr(BIO_F_BIO_NEW_FILE, BIO_R_NO_SUCH_FILE); else BIOerr(BIO_F_BIO_NEW_FILE, ERR_R_SYS_LIB); return (NULL); } if ((ret = BIO_new(BIO_s_file())) == NULL) { fclose(file); return (NULL); } BIO_set_fp(ret, file, BIO_CLOSE); return (ret); }
static int clean_devcrypto_session(struct session_op *sess) { if (ioctl(cfd, CIOCFSESSION, &sess->ses) < 0) { SYSerr(SYS_F_IOCTL, errno); return 0; } memset(sess, 0, sizeof(struct session_op)); return 1; }
int BIO_get_port(const char *str, unsigned short *port_ptr) { int i; struct servent *s; if (str == NULL) { BIOerr(BIO_F_BIO_GET_PORT,BIO_R_NO_PORT_DEFINED); return(0); } i=atoi(str); if (i != 0) *port_ptr=(unsigned short)i; else { CRYPTO_w_lock(CRYPTO_LOCK_GETSERVBYNAME); /* Note: under VMS with SOCKETSHR, it seems like the first * parameter is 'char *', instead of 'const char *' */ s=getservbyname( #ifndef CONST_STRICT (char *) #endif str,"tcp"); if(s != NULL) *port_ptr=ntohs((unsigned short)s->s_port); CRYPTO_w_unlock(CRYPTO_LOCK_GETSERVBYNAME); if(s == NULL) { if (strcmp(str,"http") == 0) *port_ptr=80; else if (strcmp(str,"telnet") == 0) *port_ptr=23; else if (strcmp(str,"socks") == 0) *port_ptr=1080; else if (strcmp(str,"https") == 0) *port_ptr=443; else if (strcmp(str,"ssl") == 0) *port_ptr=443; else if (strcmp(str,"ftp") == 0) *port_ptr=21; else if (strcmp(str,"gopher") == 0) *port_ptr=70; #if 0 else if (strcmp(str,"wais") == 0) *port_ptr=21; #endif else { SYSerr(SYS_F_GETSERVBYNAME,get_last_socket_error()); ERR_add_error_data(3,"service='",str,"'"); return(0); } } } return(1); }
int BIO_socket_ioctl(int fd, long type, void *arg) { int ret; ret = ioctl(fd, type, arg); if (ret < 0) SYSerr(SYS_F_IOCTLSOCKET, errno); return (ret); }
int BIO_socket_nbio(int s, int mode) { int ret = -1; int l; l = mode; # ifdef FIONBIO l = mode; ret = BIO_socket_ioctl(s, FIONBIO, &l); # elif defined(F_GETFL) && defined(F_SETFL) && (defined(O_NONBLOCK) || defined(FNDELAY)) /* make sure this call always pushes an error level; BIO_socket_ioctl() does so, so we do too. */ l = fcntl(s, F_GETFL, 0); if (l == -1) { SYSerr(SYS_F_FCNTL, get_last_rtl_error()); ret = -1; } else { # if defined(O_NONBLOCK) l &= ~O_NONBLOCK; # else l &= ~FNDELAY; /* BSD4.x */ # endif if (mode) { # if defined(O_NONBLOCK) l |= O_NONBLOCK; # else l |= FNDELAY; /* BSD4.x */ # endif } ret = fcntl(s, F_SETFL, l); if (ret < 0) { SYSerr(SYS_F_FCNTL, get_last_rtl_error()); } } # else /* make sure this call always pushes an error level; BIO_socket_ioctl() does so, so we do too. */ BIOerr(BIO_F_BIO_SOCKET_NBIO, ERR_R_PASSED_INVALID_ARGUMENT); # endif return (ret == 0); }
int BIO_socket_ioctl(int fd, long type, void *arg) { int i; # define ARG arg i = ioctl(fd, type, ARG); if (i < 0) SYSerr(SYS_F_IOCTLSOCKET, errno); return (i); }
static int digest_cleanup(EVP_MD_CTX *ctx) { struct digest_ctx *digest_ctx = (struct digest_ctx *)EVP_MD_CTX_md_data(ctx); if (close(digest_ctx->cfd) < 0) { SYSerr(SYS_F_CLOSE, errno); return 0; } return 1; }
/*- * BIO_connect - connect to an address * @sock: the socket to connect with * @addr: the address to connect to * @options: BIO socket options * * Connects to the address using the given socket and options. * * Options can be a combination of the following: * - BIO_SOCK_KEEPALIVE: enable regularly sending keep-alive messages. * - BIO_SOCK_NONBLOCK: Make the socket non-blocking. * - BIO_SOCK_NODELAY: don't delay small messages. * * options holds BIO socket options that can be used * You should call this for every address returned by BIO_lookup * until the connection is successful. * * Returns 1 on success or 0 on failure. On failure errno is set * and an error status is added to the OpenSSL error stack. */ int BIO_connect(int sock, const BIO_ADDR *addr, int options) { const int on = 1; if (sock == -1) { BIOerr(BIO_F_BIO_CONNECT, BIO_R_INVALID_SOCKET); return 0; } if (!BIO_socket_nbio(sock, (options & BIO_SOCK_NONBLOCK) != 0)) return 0; if (options & BIO_SOCK_KEEPALIVE) { if (setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE, (const void *)&on, sizeof(on)) != 0) { SYSerr(SYS_F_SETSOCKOPT, get_last_socket_error()); BIOerr(BIO_F_BIO_CONNECT, BIO_R_UNABLE_TO_KEEPALIVE); return 0; } } if (options & BIO_SOCK_NODELAY) { if (setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, (const void *)&on, sizeof(on)) != 0) { SYSerr(SYS_F_SETSOCKOPT, get_last_socket_error()); BIOerr(BIO_F_BIO_CONNECT, BIO_R_UNABLE_TO_NODELAY); return 0; } } if (connect(sock, BIO_ADDR_sockaddr(addr), BIO_ADDR_sockaddr_size(addr)) == -1) { if (!BIO_sock_should_retry(-1)) { SYSerr(SYS_F_CONNECT, get_last_socket_error()); BIOerr(BIO_F_BIO_CONNECT, BIO_R_CONNECT_ERROR); } return 0; } return 1; }
static int cipher_do_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, size_t inl) { struct cipher_ctx *cipher_ctx = (struct cipher_ctx *)EVP_CIPHER_CTX_get_cipher_data(ctx); struct crypt_op cryp; #if !defined(COP_FLAG_WRITE_IV) unsigned char saved_iv[EVP_MAX_IV_LENGTH]; #endif memset(&cryp, 0, sizeof(cryp)); cryp.ses = cipher_ctx->sess.ses; cryp.len = inl; cryp.src = (void *)in; cryp.dst = (void *)out; cryp.iv = (void *)EVP_CIPHER_CTX_iv_noconst(ctx); cryp.op = cipher_ctx->op; #if !defined(COP_FLAG_WRITE_IV) cryp.flags = 0; if (EVP_CIPHER_CTX_iv_length(ctx) > 0) { assert(inl >= EVP_CIPHER_CTX_iv_length(ctx)); if (!EVP_CIPHER_CTX_encrypting(ctx)) { unsigned char *ivptr = in + inl - EVP_CIPHER_CTX_iv_length(ctx); memcpy(saved_iv, ivptr, EVP_CIPHER_CTX_iv_length(ctx)); } } #else cryp.flags = COP_FLAG_WRITE_IV; #endif if (ioctl(cipher_ctx->cfd, CIOCCRYPT, &cryp) < 0) { SYSerr(SYS_F_IOCTL, errno); return 0; } #if !defined(COP_FLAG_WRITE_IV) if (EVP_CIPHER_CTX_iv_length(ctx) > 0) { unsigned char *ivptr = saved_iv; assert(inl >= EVP_CIPHER_CTX_iv_length(ctx)); if (!EVP_CIPHER_CTX_encrypting(ctx)) ivptr = out + inl - EVP_CIPHER_CTX_iv_length(ctx); memcpy(EVP_CIPHER_CTX_iv_noconst(ctx), ivptr, EVP_CIPHER_CTX_iv_length(ctx)); } #endif return 1; }
int BIO_socket_ioctl(int fd, long type, void *arg) { int i; #if (defined(__DJGPP__) || defined(OPENSSL_SYS_VXWORKS)) i=ioctlsocket(fd,type,(char *)arg); #else i=ioctlsocket(fd,type,arg); #endif /* __DJGPP__ */ if (i < 0) SYSerr(SYS_F_IOCTLSOCKET,get_last_socket_error()); return(i); }
int BIO_socket_ioctl(int fd, long type, void *arg) { int i; #ifdef __DJGPP__ i=ioctlsocket(fd,type,(char *)arg); #else i=ioctlsocket(fd,type,arg); #endif /* __DJGPP__ */ if (i < 0) SYSerr(SYS_F_IOCTLSOCKET,get_last_socket_error()); return(i); }
static int digest_update(EVP_MD_CTX *ctx, const void *data, size_t count) { struct digest_ctx *digest_ctx = (struct digest_ctx *)EVP_MD_CTX_md_data(ctx); if (count == 0) return 1; if (digest_op(digest_ctx, data, count, NULL, COP_FLAG_UPDATE) < 0) { SYSerr(SYS_F_IOCTL, errno); return 0; } return 1; }
static int file_read(BIO *b, char *out, int outl) { int ret = 0; if (b->init && (out != NULL)) { ret = fread(out, 1,(int)outl,(FILE *)b->ptr); if (ret == 0 && ferror((FILE *)b->ptr)) { SYSerr(SYS_F_FREAD, errno); BIOerr(BIO_F_FILE_READ, ERR_R_SYS_LIB); ret = -1; } } return (ret); }
static int digest_copy(EVP_MD_CTX *to, const EVP_MD_CTX *from) { struct digest_ctx *digest_from = (struct digest_ctx *)EVP_MD_CTX_md_data(from); struct digest_ctx *digest_to = (struct digest_ctx *)EVP_MD_CTX_md_data(to); struct cphash_op cphash; if (digest_from == NULL || digest_from->init_called != 1) return 1; if (!digest_init(to)) { SYSerr(SYS_F_IOCTL, errno); return 0; } cphash.src_ses = digest_from->sess.ses; cphash.dst_ses = digest_to->sess.ses; if (ioctl(cfd, CIOCCPHASH, &cphash) < 0) { SYSerr(SYS_F_IOCTL, errno); return 0; } return 1; }
/*- * addr_strings - helper function to get host and service names * @ap: the BIO_ADDR that has the input info * @numeric: 0 if actual names should be returned, 1 if the numeric * representation should be returned. * @hostname: a pointer to a pointer to a memory area to store the * host name or numeric representation. Unused if NULL. * @service: a pointer to a pointer to a memory area to store the * service name or numeric representation. Unused if NULL. * * The return value is 0 on failure, with the error code in the error * stack, and 1 on success. */ static int addr_strings(const BIO_ADDR *ap, int numeric, char **hostname, char **service) { if (BIO_sock_init() != 1) return 0; if (1) { #ifdef AI_PASSIVE int ret = 0; char host[NI_MAXHOST], serv[NI_MAXSERV]; int flags = 0; if (numeric) flags |= NI_NUMERICHOST | NI_NUMERICSERV; if ((ret = getnameinfo(BIO_ADDR_sockaddr(ap), BIO_ADDR_sockaddr_size(ap), host, sizeof(host), serv, sizeof(serv), flags)) != 0) { # ifdef EAI_SYSTEM if (ret == EAI_SYSTEM) { SYSerr(SYS_F_GETNAMEINFO, get_last_socket_error()); BIOerr(BIO_F_ADDR_STRINGS, ERR_R_SYS_LIB); } else # endif { BIOerr(BIO_F_ADDR_STRINGS, ERR_R_SYS_LIB); ERR_add_error_data(1, gai_strerror(ret)); } return 0; } if (hostname) *hostname = OPENSSL_strdup(host); if (service) *service = OPENSSL_strdup(serv); } else { #endif if (hostname) *hostname = OPENSSL_strdup(inet_ntoa(ap->sin.sin_addr)); if (service) { char serv[6]; /* port is 16 bits => max 5 decimal digits */ BIO_snprintf(serv, sizeof(serv), "%d", ntohs(ap->sin.sin_port)); *service = OPENSSL_strdup(serv); } } return 1; }