From bb63ff2d125e51688213d0af9e4f785cf3865063 Mon Sep 17 00:00:00 2001 From: jsing <> Date: Tue, 15 Apr 2014 16:37:22 +0000 Subject: First pass at applying KNF to the OpenSSL code, which almost makes it readable. This pass is whitespace only and can readily be verified using tr and md5. --- src/lib/libcrypto/bio/b_dump.c | 171 ++--- src/lib/libcrypto/bio/b_print.c | 1149 ++++++++++++++--------------- src/lib/libcrypto/bio/b_sock.c | 1025 +++++++++++++------------ src/lib/libcrypto/bio/bf_buff.c | 629 ++++++++-------- src/lib/libcrypto/bio/bf_lbuf.c | 378 +++++----- src/lib/libcrypto/bio/bf_nbio.c | 235 +++--- src/lib/libcrypto/bio/bf_null.c | 167 +++-- src/lib/libcrypto/bio/bio.h | 165 +++-- src/lib/libcrypto/bio/bio_cb.c | 78 +- src/lib/libcrypto/bio/bio_err.c | 155 ++-- src/lib/libcrypto/bio/bio_lib.c | 748 ++++++++++--------- src/lib/libcrypto/bio/bss_acpt.c | 455 ++++++------ src/lib/libcrypto/bio/bss_bio.c | 546 +++++++------- src/lib/libcrypto/bio/bss_conn.c | 651 ++++++++-------- src/lib/libcrypto/bio/bss_dgram.c | 1114 ++++++++++++++-------------- src/lib/libcrypto/bio/bss_fd.c | 221 +++--- src/lib/libcrypto/bio/bss_file.c | 418 +++++------ src/lib/libcrypto/bio/bss_log.c | 186 ++--- src/lib/libcrypto/bio/bss_mem.c | 264 +++---- src/lib/libcrypto/bio/bss_null.c | 102 +-- src/lib/libcrypto/bio/bss_rtcp.c | 294 ++++---- src/lib/libcrypto/bio/bss_sock.c | 194 ++--- src/lib/libssl/src/crypto/bio/b_dump.c | 171 ++--- src/lib/libssl/src/crypto/bio/b_print.c | 1149 ++++++++++++++--------------- src/lib/libssl/src/crypto/bio/b_sock.c | 1025 +++++++++++++------------ src/lib/libssl/src/crypto/bio/bf_buff.c | 629 ++++++++-------- src/lib/libssl/src/crypto/bio/bf_lbuf.c | 378 +++++----- src/lib/libssl/src/crypto/bio/bf_nbio.c | 235 +++--- src/lib/libssl/src/crypto/bio/bf_null.c | 167 +++-- src/lib/libssl/src/crypto/bio/bio.h | 165 +++-- src/lib/libssl/src/crypto/bio/bio_cb.c | 78 +- src/lib/libssl/src/crypto/bio/bio_err.c | 155 ++-- src/lib/libssl/src/crypto/bio/bio_lib.c | 748 ++++++++++--------- src/lib/libssl/src/crypto/bio/bss_acpt.c | 455 ++++++------ src/lib/libssl/src/crypto/bio/bss_bio.c | 546 +++++++------- src/lib/libssl/src/crypto/bio/bss_conn.c | 651 ++++++++-------- src/lib/libssl/src/crypto/bio/bss_dgram.c | 1114 ++++++++++++++-------------- src/lib/libssl/src/crypto/bio/bss_fd.c | 221 +++--- src/lib/libssl/src/crypto/bio/bss_file.c | 418 +++++------ src/lib/libssl/src/crypto/bio/bss_log.c | 186 ++--- src/lib/libssl/src/crypto/bio/bss_mem.c | 264 +++---- src/lib/libssl/src/crypto/bio/bss_null.c | 102 +-- src/lib/libssl/src/crypto/bio/bss_rtcp.c | 294 ++++---- src/lib/libssl/src/crypto/bio/bss_sock.c | 194 ++--- 44 files changed, 9352 insertions(+), 9338 deletions(-) (limited to 'src/lib') diff --git a/src/lib/libcrypto/bio/b_dump.c b/src/lib/libcrypto/bio/b_dump.c index 492ee09275..bea94969a2 100644 --- a/src/lib/libcrypto/bio/b_dump.c +++ b/src/lib/libcrypto/bio/b_dump.c @@ -66,122 +66,125 @@ #define TRUNCATE #define DUMP_WIDTH 16 -#define DUMP_WIDTH_LESS_INDENT(i) (DUMP_WIDTH-((i-(i>6?6:i)+3)/4)) +#define DUMP_WIDTH_LESS_INDENT(i) (DUMP_WIDTH - ((i - (i > 6 ? 6 : i) + 3) / 4)) -int BIO_dump_cb(int (*cb)(const void *data, size_t len, void *u), - void *u, const char *s, int len) - { +int +BIO_dump_cb(int (*cb)(const void *data, size_t len, void *u), + void *u, const char *s, int len) +{ return BIO_dump_indent_cb(cb, u, s, len, 0); - } +} -int BIO_dump_indent_cb(int (*cb)(const void *data, size_t len, void *u), - void *u, const char *s, int len, int indent) - { - int ret=0; - char buf[288+1],tmp[20],str[128+1]; - int i,j,rows,trc; +int +BIO_dump_indent_cb(int (*cb)(const void *data, size_t len, void *u), + void *u, const char *s, int len, int indent) +{ + int ret = 0; + char buf[288 + 1], tmp[20], str[128 + 1]; + int i, j, rows, trc; unsigned char ch; int dump_width; - trc=0; + trc = 0; #ifdef TRUNCATE - for(; (len > 0) && ((s[len-1] == ' ') || (s[len-1] == '\0')); len--) + for (; (len > 0) && ((s[len - 1] == ' ') || (s[len - 1] == '\0')); len--) trc++; #endif if (indent < 0) indent = 0; - if (indent) - { - if (indent > 128) indent=128; - memset(str,' ',indent); - } - str[indent]='\0'; + if (indent) { + if (indent > 128) + indent = 128; + memset(str, ' ', indent); + } + str[indent] = '\0'; - dump_width=DUMP_WIDTH_LESS_INDENT(indent); - rows=(len/dump_width); - if ((rows*dump_width)=len) - { - BUF_strlcat(buf," ",sizeof buf); - } - else - { - ch=((unsigned char)*(s+i*dump_width+j)) & 0xff; - (void) snprintf(tmp,sizeof tmp,"%02x%c",ch, - j==7?'-':' '); - BUF_strlcat(buf,tmp,sizeof buf); - } + for (i = 0; i < rows; i++) { + buf[0] = '\0'; /* start with empty string */ + BUF_strlcpy(buf, str, sizeof buf); + (void) snprintf(tmp, sizeof tmp, "%04x - ", i*dump_width); + BUF_strlcat(buf, tmp, sizeof buf); + for (j = 0; j < dump_width; j++) { + if (((i*dump_width) + j) >= len) { + BUF_strlcat(buf, " ", sizeof buf); + } else { + ch = ((unsigned char)*(s + i*dump_width + j)) & 0xff; + (void) snprintf(tmp, sizeof tmp, "%02x%c", ch, + j == 7 ? '-' : ' '); + BUF_strlcat(buf, tmp, sizeof buf); } - BUF_strlcat(buf," ",sizeof buf); - for(j=0;j=len) + } + BUF_strlcat(buf, " ", sizeof buf); + for (j = 0; j < dump_width; j++) { + if (((i*dump_width) + j) >= len) break; - ch=((unsigned char)*(s+i*dump_width+j)) & 0xff; + ch = ((unsigned char)*(s + i * dump_width + j)) & 0xff; #ifndef CHARSET_EBCDIC - (void) snprintf(tmp,sizeof tmp,"%c", - ((ch>=' ')&&(ch<='~'))?ch:'.'); + (void) snprintf(tmp, sizeof tmp, "%c", + ((ch >= ' ') && (ch <= '~')) ? ch : '.'); #else - (void) snprintf(tmp,sizeof tmp,"%c", - ((ch>=os_toascii[' '])&&(ch<=os_toascii['~'])) - ? os_toebcdic[ch] - : '.'); + (void) snprintf(tmp, sizeof tmp, "%c", + ((ch >= os_toascii[' ']) && (ch <= os_toascii['~'])) + ? os_toebcdic[ch] : '.'); #endif - BUF_strlcat(buf,tmp,sizeof buf); - } - BUF_strlcat(buf,"\n",sizeof buf); + BUF_strlcat(buf, tmp, sizeof buf); + } + BUF_strlcat(buf, "\n", sizeof buf); /* if this is the last call then update the ddt_dump thing so * that we will move the selection point in the debug window */ - ret+=cb((void *)buf,strlen(buf),u); - } + ret += cb((void *)buf, strlen(buf), u); + } #ifdef TRUNCATE - if (trc > 0) - { - (void) snprintf(buf,sizeof buf,"%s%04x - \n",str, - len+trc); - ret+=cb((void *)buf,strlen(buf),u); - } -#endif - return(ret); + if (trc > 0) { + (void) snprintf(buf, sizeof buf, "%s%04x - \n", + str, len + trc); + ret += cb((void *)buf, strlen(buf), u); } +#endif + return (ret); +} #ifndef OPENSSL_NO_FP_API -static int write_fp(const void *data, size_t len, void *fp) - { +static int +write_fp(const void *data, size_t len, void *fp) +{ return UP_fwrite(data, len, 1, fp); - } -int BIO_dump_fp(FILE *fp, const char *s, int len) - { +} + +int +BIO_dump_fp(FILE *fp, const char *s, int len) +{ return BIO_dump_cb(write_fp, fp, s, len); - } -int BIO_dump_indent_fp(FILE *fp, const char *s, int len, int indent) - { +} + +int +BIO_dump_indent_fp(FILE *fp, const char *s, int len, int indent) +{ return BIO_dump_indent_cb(write_fp, fp, s, len, indent); - } +} #endif -static int write_bio(const void *data, size_t len, void *bp) - { +static int +write_bio(const void *data, size_t len, void *bp) +{ return BIO_write((BIO *)bp, (const char *)data, len); - } -int BIO_dump(BIO *bp, const char *s, int len) - { +} + +int +BIO_dump(BIO *bp, const char *s, int len) +{ return BIO_dump_cb(write_bio, bp, s, len); - } -int BIO_dump_indent(BIO *bp, const char *s, int len, int indent) - { - return BIO_dump_indent_cb(write_bio, bp, s, len, indent); - } +} +int +BIO_dump_indent(BIO *bp, const char *s, int len, int indent) +{ + return BIO_dump_indent_cb(write_bio, bp, s, len, indent); +} diff --git a/src/lib/libcrypto/bio/b_print.c b/src/lib/libcrypto/bio/b_print.c index 143a7cfefa..b3b0d45ee6 100644 --- a/src/lib/libcrypto/bio/b_print.c +++ b/src/lib/libcrypto/bio/b_print.c @@ -125,16 +125,15 @@ #define LLONG long #endif -static void fmtstr (char **, char **, size_t *, size_t *, - const char *, int, int, int); -static void fmtint (char **, char **, size_t *, size_t *, - LLONG, int, int, int, int); -static void fmtfp (char **, char **, size_t *, size_t *, - LDOUBLE, int, int, int); -static void doapr_outch (char **, char **, size_t *, size_t *, int); -static void _dopr(char **sbuffer, char **buffer, - size_t *maxlen, size_t *retlen, int *truncated, - const char *format, va_list args); +static void fmtstr(char **, char **, size_t *, size_t *, const char *, + int, int, int); +static void fmtint(char **, char **, size_t *, size_t *, LLONG, int, + int, int, int); +static void fmtfp(char **, char **, size_t *, size_t *, LDOUBLE, + int, int, int); +static void doapr_outch(char **, char **, size_t *, size_t *, int); +static void _dopr(char **sbuffer, char **buffer, size_t *maxlen, + size_t *retlen, int *truncated, const char *format, va_list args); /* format read states */ #define DP_S_DEFAULT 0 @@ -166,607 +165,576 @@ static void _dopr(char **sbuffer, char **buffer, #define OSSL_MAX(p,q) ((p >= q) ? p : q) static void -_dopr( - char **sbuffer, - char **buffer, - size_t *maxlen, - size_t *retlen, - int *truncated, - const char *format, - va_list args) +_dopr(char **sbuffer, char **buffer, size_t *maxlen, size_t *retlen, + int *truncated, const char *format, va_list args) { - char ch; - LLONG value; - LDOUBLE fvalue; - char *strvalue; - int min; - int max; - int state; - int flags; - int cflags; - size_t currlen; - - state = DP_S_DEFAULT; - flags = currlen = cflags = min = 0; - max = -1; - ch = *format++; - - while (state != DP_S_DONE) { - if (ch == '\0' || (buffer == NULL && currlen >= *maxlen)) - state = DP_S_DONE; - - switch (state) { - case DP_S_DEFAULT: - if (ch == '%') - state = DP_S_FLAGS; - else - doapr_outch(sbuffer,buffer, &currlen, maxlen, ch); - ch = *format++; - break; - case DP_S_FLAGS: - switch (ch) { - case '-': - flags |= DP_F_MINUS; - ch = *format++; - break; - case '+': - flags |= DP_F_PLUS; - ch = *format++; - break; - case ' ': - flags |= DP_F_SPACE; - ch = *format++; - break; - case '#': - flags |= DP_F_NUM; - ch = *format++; - break; - case '0': - flags |= DP_F_ZERO; - ch = *format++; - break; - default: - state = DP_S_MIN; - break; - } - break; - case DP_S_MIN: - if (isdigit((unsigned char)ch)) { - min = 10 * min + char_to_int(ch); - ch = *format++; - } else if (ch == '*') { - min = va_arg(args, int); - ch = *format++; - state = DP_S_DOT; - } else - state = DP_S_DOT; - break; - case DP_S_DOT: - if (ch == '.') { - state = DP_S_MAX; - ch = *format++; - } else - state = DP_S_MOD; - break; - case DP_S_MAX: - if (isdigit((unsigned char)ch)) { - if (max < 0) - max = 0; - max = 10 * max + char_to_int(ch); - ch = *format++; - } else if (ch == '*') { - max = va_arg(args, int); - ch = *format++; - state = DP_S_MOD; - } else - state = DP_S_MOD; - break; - case DP_S_MOD: - switch (ch) { - case 'h': - cflags = DP_C_SHORT; - ch = *format++; - break; - case 'l': - if (*format == 'l') { - cflags = DP_C_LLONG; - format++; - } else - cflags = DP_C_LONG; - ch = *format++; - break; - case 'q': - cflags = DP_C_LLONG; - ch = *format++; - break; - case 'L': - cflags = DP_C_LDOUBLE; - ch = *format++; - break; - default: - break; - } - state = DP_S_CONV; - break; - case DP_S_CONV: - switch (ch) { - case 'd': - case 'i': - switch (cflags) { - case DP_C_SHORT: - value = (short int)va_arg(args, int); - break; - case DP_C_LONG: - value = va_arg(args, long int); - break; - case DP_C_LLONG: - value = va_arg(args, LLONG); - break; - default: - value = va_arg(args, int); - break; - } - fmtint(sbuffer, buffer, &currlen, maxlen, - value, 10, min, max, flags); - break; - case 'X': - flags |= DP_F_UP; - /* FALLTHROUGH */ - case 'x': - case 'o': - case 'u': - flags |= DP_F_UNSIGNED; - switch (cflags) { - case DP_C_SHORT: - value = (unsigned short int)va_arg(args, unsigned int); - break; - case DP_C_LONG: - value = (LLONG) va_arg(args, - unsigned long int); - break; - case DP_C_LLONG: - value = va_arg(args, unsigned LLONG); - break; - default: - value = (LLONG) va_arg(args, - unsigned int); - break; - } - fmtint(sbuffer, buffer, &currlen, maxlen, value, - ch == 'o' ? 8 : (ch == 'u' ? 10 : 16), - min, max, flags); - break; - case 'f': - if (cflags == DP_C_LDOUBLE) - fvalue = va_arg(args, LDOUBLE); - else - fvalue = va_arg(args, double); - fmtfp(sbuffer, buffer, &currlen, maxlen, - fvalue, min, max, flags); - break; - case 'E': - flags |= DP_F_UP; - case 'e': - if (cflags == DP_C_LDOUBLE) - fvalue = va_arg(args, LDOUBLE); - else - fvalue = va_arg(args, double); - break; - case 'G': - flags |= DP_F_UP; - case 'g': - if (cflags == DP_C_LDOUBLE) - fvalue = va_arg(args, LDOUBLE); - else - fvalue = va_arg(args, double); - break; - case 'c': - doapr_outch(sbuffer, buffer, &currlen, maxlen, - va_arg(args, int)); - break; - case 's': - strvalue = va_arg(args, char *); - if (max < 0) { - if (buffer) - max = INT_MAX; - else - max = *maxlen; + char ch; + LLONG value; + LDOUBLE fvalue; + char *strvalue; + int min; + int max; + int state; + int flags; + int cflags; + size_t currlen; + + state = DP_S_DEFAULT; + flags = currlen = cflags = min = 0; + max = -1; + ch = *format++; + + while (state != DP_S_DONE) { + if (ch == '\0' || (buffer == NULL && currlen >= *maxlen)) + state = DP_S_DONE; + + switch (state) { + case DP_S_DEFAULT: + if (ch == '%') + state = DP_S_FLAGS; + else + doapr_outch(sbuffer, buffer, &currlen, maxlen, ch); + ch = *format++; + break; + case DP_S_FLAGS: + switch (ch) { + case '-': + flags |= DP_F_MINUS; + ch = *format++; + break; + case '+': + flags |= DP_F_PLUS; + ch = *format++; + break; + case ' ': + flags |= DP_F_SPACE; + ch = *format++; + break; + case '#': + flags |= DP_F_NUM; + ch = *format++; + break; + case '0': + flags |= DP_F_ZERO; + ch = *format++; + break; + default: + state = DP_S_MIN; + break; + } + break; + case DP_S_MIN: + if (isdigit((unsigned char)ch)) { + min = 10 * min + char_to_int(ch); + ch = *format++; + } else if (ch == '*') { + min = va_arg(args, int); + ch = *format++; + state = DP_S_DOT; + } else + state = DP_S_DOT; + break; + case DP_S_DOT: + if (ch == '.') { + state = DP_S_MAX; + ch = *format++; + } else + state = DP_S_MOD; + break; + case DP_S_MAX: + if (isdigit((unsigned char)ch)) { + if (max < 0) + max = 0; + max = 10 * max + char_to_int(ch); + ch = *format++; + } else if (ch == '*') { + max = va_arg(args, int); + ch = *format++; + state = DP_S_MOD; + } else + state = DP_S_MOD; + break; + case DP_S_MOD: + switch (ch) { + case 'h': + cflags = DP_C_SHORT; + ch = *format++; + break; + case 'l': + if (*format == 'l') { + cflags = DP_C_LLONG; + format++; + } else + cflags = DP_C_LONG; + ch = *format++; + break; + case 'q': + cflags = DP_C_LLONG; + ch = *format++; + break; + case 'L': + cflags = DP_C_LDOUBLE; + ch = *format++; + break; + default: + break; + } + state = DP_S_CONV; + break; + case DP_S_CONV: + switch (ch) { + case 'd': + case 'i': + switch (cflags) { + case DP_C_SHORT: + value = (short int)va_arg(args, int); + break; + case DP_C_LONG: + value = va_arg(args, long int); + break; + case DP_C_LLONG: + value = va_arg(args, LLONG); + break; + default: + value = va_arg(args, int); + break; + } + fmtint(sbuffer, buffer, &currlen, maxlen, + value, 10, min, max, flags); + break; + case 'X': + flags |= DP_F_UP; + /* FALLTHROUGH */ + case 'x': + case 'o': + case 'u': + flags |= DP_F_UNSIGNED; + switch (cflags) { + case DP_C_SHORT: + value = (unsigned short int)va_arg( + args, unsigned int); + break; + case DP_C_LONG: + value = (LLONG)va_arg(args, + unsigned long int); + break; + case DP_C_LLONG: + value = va_arg(args, unsigned LLONG); + break; + default: + value = (LLONG)va_arg(args, + unsigned int); + break; + } + fmtint(sbuffer, buffer, &currlen, maxlen, value, + ch == 'o' ? 8 : (ch == 'u' ? 10 : 16), + min, max, flags); + break; + case 'f': + if (cflags == DP_C_LDOUBLE) + fvalue = va_arg(args, LDOUBLE); + else + fvalue = va_arg(args, double); + fmtfp(sbuffer, buffer, &currlen, maxlen, + fvalue, min, max, flags); + break; + case 'E': + flags |= DP_F_UP; + case 'e': + if (cflags == DP_C_LDOUBLE) + fvalue = va_arg(args, LDOUBLE); + else + fvalue = va_arg(args, double); + break; + case 'G': + flags |= DP_F_UP; + case 'g': + if (cflags == DP_C_LDOUBLE) + fvalue = va_arg(args, LDOUBLE); + else + fvalue = va_arg(args, double); + break; + case 'c': + doapr_outch(sbuffer, buffer, &currlen, maxlen, + va_arg(args, int)); + break; + case 's': + strvalue = va_arg(args, char *); + if (max < 0) { + if (buffer) + max = INT_MAX; + else + max = *maxlen; + } + fmtstr(sbuffer, buffer, &currlen, maxlen, + strvalue, flags, min, max); + break; + case 'p': + value = (long)va_arg(args, void *); + fmtint(sbuffer, buffer, &currlen, maxlen, + value, 16, min, max, flags|DP_F_NUM); + break; + case 'n': /* XXX */ + if (cflags == DP_C_SHORT) { + short int *num; + num = va_arg(args, short int *); + *num = currlen; + } else if (cflags == DP_C_LONG) { /* XXX */ + long int *num; + num = va_arg(args, long int *); + *num = (long int) currlen; + } else if (cflags == DP_C_LLONG) { /* XXX */ + LLONG *num; + num = va_arg(args, LLONG *); + *num = (LLONG) currlen; + } else { + int *num; + num = va_arg(args, int *); + *num = currlen; + } + break; + case '%': + doapr_outch(sbuffer, buffer, &currlen, maxlen, ch); + break; + case 'w': + /* not supported yet, treat as next char */ + ch = *format++; + break; + default: + /* unknown, skip */ + break; + } + ch = *format++; + state = DP_S_DEFAULT; + flags = cflags = min = 0; + max = -1; + break; + case DP_S_DONE: + break; + default: + break; } - fmtstr(sbuffer, buffer, &currlen, maxlen, strvalue, - flags, min, max); - break; - case 'p': - value = (long)va_arg(args, void *); - fmtint(sbuffer, buffer, &currlen, maxlen, - value, 16, min, max, flags|DP_F_NUM); - break; - case 'n': /* XXX */ - if (cflags == DP_C_SHORT) { - short int *num; - num = va_arg(args, short int *); - *num = currlen; - } else if (cflags == DP_C_LONG) { /* XXX */ - long int *num; - num = va_arg(args, long int *); - *num = (long int) currlen; - } else if (cflags == DP_C_LLONG) { /* XXX */ - LLONG *num; - num = va_arg(args, LLONG *); - *num = (LLONG) currlen; - } else { - int *num; - num = va_arg(args, int *); - *num = currlen; - } - break; - case '%': - doapr_outch(sbuffer, buffer, &currlen, maxlen, ch); - break; - case 'w': - /* not supported yet, treat as next char */ - ch = *format++; - break; - default: - /* unknown, skip */ - break; - } - ch = *format++; - state = DP_S_DEFAULT; - flags = cflags = min = 0; - max = -1; - break; - case DP_S_DONE: - break; - default: - break; - } - } - *truncated = (currlen > *maxlen - 1); - if (*truncated) - currlen = *maxlen - 1; - doapr_outch(sbuffer, buffer, &currlen, maxlen, '\0'); - *retlen = currlen - 1; - return; + } + *truncated = (currlen > *maxlen - 1); + if (*truncated) + currlen = *maxlen - 1; + doapr_outch(sbuffer, buffer, &currlen, maxlen, '\0'); + *retlen = currlen - 1; + return; } static void -fmtstr( - char **sbuffer, - char **buffer, - size_t *currlen, - size_t *maxlen, - const char *value, - int flags, - int min, - int max) +fmtstr(char **sbuffer, char **buffer, size_t *currlen, size_t *maxlen, + const char *value, int flags, int min, int max) { - int padlen, strln; - int cnt = 0; - - if (value == 0) - value = ""; - for (strln = 0; value[strln]; ++strln) - ; - padlen = min - strln; - if (padlen < 0) - padlen = 0; - if (flags & DP_F_MINUS) - padlen = -padlen; - - while ((padlen > 0) && (cnt < max)) { - doapr_outch(sbuffer, buffer, currlen, maxlen, ' '); - --padlen; - ++cnt; - } - while (*value && (cnt < max)) { - doapr_outch(sbuffer, buffer, currlen, maxlen, *value++); - ++cnt; - } - while ((padlen < 0) && (cnt < max)) { - doapr_outch(sbuffer, buffer, currlen, maxlen, ' '); - ++padlen; - ++cnt; - } + int padlen, strln; + int cnt = 0; + + if (value == 0) + value = ""; + for (strln = 0; value[strln]; ++strln) + ; + padlen = min - strln; + if (padlen < 0) + padlen = 0; + if (flags & DP_F_MINUS) + padlen = -padlen; + + while ((padlen > 0) && (cnt < max)) { + doapr_outch(sbuffer, buffer, currlen, maxlen, ' '); + --padlen; + ++cnt; + } + while (*value && (cnt < max)) { + doapr_outch(sbuffer, buffer, currlen, maxlen, *value++); + ++cnt; + } + while ((padlen < 0) && (cnt < max)) { + doapr_outch(sbuffer, buffer, currlen, maxlen, ' '); + ++padlen; + ++cnt; + } } static void -fmtint( - char **sbuffer, - char **buffer, - size_t *currlen, - size_t *maxlen, - LLONG value, - int base, - int min, - int max, - int flags) +fmtint(char **sbuffer, char **buffer, size_t *currlen, size_t *maxlen, + LLONG value, int base, int min, int max, int flags) { - int signvalue = 0; - const char *prefix = ""; - unsigned LLONG uvalue; - char convert[DECIMAL_SIZE(value)+3]; - int place = 0; - int spadlen = 0; - int zpadlen = 0; - int caps = 0; - - if (max < 0) - max = 0; - uvalue = value; - if (!(flags & DP_F_UNSIGNED)) { - if (value < 0) { - signvalue = '-'; - uvalue = -value; - } else if (flags & DP_F_PLUS) - signvalue = '+'; - else if (flags & DP_F_SPACE) - signvalue = ' '; - } - if (flags & DP_F_NUM) { - if (base == 8) prefix = "0"; - if (base == 16) prefix = "0x"; - } - if (flags & DP_F_UP) - caps = 1; - do { - convert[place++] = - (caps ? "0123456789ABCDEF" : "0123456789abcdef") - [uvalue % (unsigned) base]; - uvalue = (uvalue / (unsigned) base); - } while (uvalue && (place < (int)sizeof(convert))); - if (place == sizeof(convert)) - place--; - convert[place] = 0; - - zpadlen = max - place; - spadlen = min - OSSL_MAX(max, place) - (signvalue ? 1 : 0) - strlen(prefix); - if (zpadlen < 0) - zpadlen = 0; - if (spadlen < 0) - spadlen = 0; - if (flags & DP_F_ZERO) { - zpadlen = OSSL_MAX(zpadlen, spadlen); - spadlen = 0; - } - if (flags & DP_F_MINUS) - spadlen = -spadlen; - - /* spaces */ - while (spadlen > 0) { - doapr_outch(sbuffer, buffer, currlen, maxlen, ' '); - --spadlen; - } - - /* sign */ - if (signvalue) - doapr_outch(sbuffer, buffer, currlen, maxlen, signvalue); - - /* prefix */ - while (*prefix) { - doapr_outch(sbuffer, buffer, currlen, maxlen, *prefix); - prefix++; - } - - /* zeros */ - if (zpadlen > 0) { - while (zpadlen > 0) { - doapr_outch(sbuffer, buffer, currlen, maxlen, '0'); - --zpadlen; - } - } - /* digits */ - while (place > 0) - doapr_outch(sbuffer, buffer, currlen, maxlen, convert[--place]); - - /* left justified spaces */ - while (spadlen < 0) { - doapr_outch(sbuffer, buffer, currlen, maxlen, ' '); - ++spadlen; - } - return; + int signvalue = 0; + const char *prefix = ""; + unsigned LLONG uvalue; + char convert[DECIMAL_SIZE(value) + 3]; + int place = 0; + int spadlen = 0; + int zpadlen = 0; + int caps = 0; + + if (max < 0) + max = 0; + uvalue = value; + if (!(flags & DP_F_UNSIGNED)) { + if (value < 0) { + signvalue = '-'; + uvalue = -value; + } else if (flags & DP_F_PLUS) + signvalue = '+'; + else if (flags & DP_F_SPACE) + signvalue = ' '; + } + if (flags & DP_F_NUM) { + if (base == 8) + prefix = "0"; + if (base == 16) + prefix = "0x"; + } + if (flags & DP_F_UP) + caps = 1; + do { + convert[place++] = (caps ? "0123456789ABCDEF" : + "0123456789abcdef")[uvalue % (unsigned) base]; + uvalue = (uvalue / (unsigned) base); + } while (uvalue && (place < (int)sizeof(convert))); + if (place == sizeof(convert)) + place--; + convert[place] = 0; + + zpadlen = max - place; + spadlen = min - OSSL_MAX(max, place) - (signvalue ? 1 : 0) - + strlen(prefix); + if (zpadlen < 0) + zpadlen = 0; + if (spadlen < 0) + spadlen = 0; + if (flags & DP_F_ZERO) { + zpadlen = OSSL_MAX(zpadlen, spadlen); + spadlen = 0; + } + if (flags & DP_F_MINUS) + spadlen = -spadlen; + + /* spaces */ + while (spadlen > 0) { + doapr_outch(sbuffer, buffer, currlen, maxlen, ' '); + --spadlen; + } + + /* sign */ + if (signvalue) + doapr_outch(sbuffer, buffer, currlen, maxlen, signvalue); + + /* prefix */ + while (*prefix) { + doapr_outch(sbuffer, buffer, currlen, maxlen, *prefix); + prefix++; + } + + /* zeros */ + if (zpadlen > 0) { + while (zpadlen > 0) { + doapr_outch(sbuffer, buffer, currlen, maxlen, '0'); + --zpadlen; + } + } + /* digits */ + while (place > 0) + doapr_outch(sbuffer, buffer, currlen, maxlen, convert[--place]); + + /* left justified spaces */ + while (spadlen < 0) { + doapr_outch(sbuffer, buffer, currlen, maxlen, ' '); + ++spadlen; + } + return; } static LDOUBLE abs_val(LDOUBLE value) { - LDOUBLE result = value; - if (value < 0) - result = -value; - return result; + LDOUBLE result = value; + if (value < 0) + result = -value; + return result; } static LDOUBLE pow_10(int in_exp) { - LDOUBLE result = 1; - while (in_exp) { - result *= 10; - in_exp--; - } - return result; + LDOUBLE result = 1; + while (in_exp) { + result *= 10; + in_exp--; + } + return result; } static long roundv(LDOUBLE value) { - long intpart; - intpart = (long) value; - value = value - intpart; - if (value >= 0.5) - intpart++; - return intpart; + long intpart; + intpart = (long) value; + value = value - intpart; + if (value >= 0.5) + intpart++; + return intpart; } static void -fmtfp( - char **sbuffer, - char **buffer, - size_t *currlen, - size_t *maxlen, - LDOUBLE fvalue, - int min, - int max, - int flags) +fmtfp(char **sbuffer, char **buffer, size_t *currlen, size_t *maxlen, + LDOUBLE fvalue, int min, int max, int flags) { - int signvalue = 0; - LDOUBLE ufvalue; - char iconvert[20]; - char fconvert[20]; - int iplace = 0; - int fplace = 0; - int padlen = 0; - int zpadlen = 0; - int caps = 0; - long intpart; - long fracpart; - long max10; - - if (max < 0) - max = 6; - ufvalue = abs_val(fvalue); - if (fvalue < 0) - signvalue = '-'; - else if (flags & DP_F_PLUS) - signvalue = '+'; - else if (flags & DP_F_SPACE) - signvalue = ' '; - - intpart = (long)ufvalue; - - /* sorry, we only support 9 digits past the decimal because of our - conversion method */ - if (max > 9) - max = 9; - - /* we "cheat" by converting the fractional part to integer by - multiplying by a factor of 10 */ - max10 = roundv(pow_10(max)); - fracpart = roundv(pow_10(max) * (ufvalue - intpart)); - - if (fracpart >= max10) { - intpart++; - fracpart -= max10; - } - - /* convert integer part */ - do { - iconvert[iplace++] = - (caps ? "0123456789ABCDEF" - : "0123456789abcdef")[intpart % 10]; - intpart = (intpart / 10); - } while (intpart && (iplace < (int)sizeof(iconvert))); - if (iplace == sizeof iconvert) - iplace--; - iconvert[iplace] = 0; - - /* convert fractional part */ - do { - fconvert[fplace++] = - (caps ? "0123456789ABCDEF" - : "0123456789abcdef")[fracpart % 10]; - fracpart = (fracpart / 10); - } while (fplace < max); - if (fplace == sizeof fconvert) - fplace--; - fconvert[fplace] = 0; - - /* -1 for decimal point, another -1 if we are printing a sign */ - padlen = min - iplace - max - 1 - ((signvalue) ? 1 : 0); - zpadlen = max - fplace; - if (zpadlen < 0) - zpadlen = 0; - if (padlen < 0) - padlen = 0; - if (flags & DP_F_MINUS) - padlen = -padlen; - - if ((flags & DP_F_ZERO) && (padlen > 0)) { - if (signvalue) { - doapr_outch(sbuffer, buffer, currlen, maxlen, signvalue); - --padlen; - signvalue = 0; - } - while (padlen > 0) { - doapr_outch(sbuffer, buffer, currlen, maxlen, '0'); - --padlen; - } - } - while (padlen > 0) { - doapr_outch(sbuffer, buffer, currlen, maxlen, ' '); - --padlen; - } - if (signvalue) - doapr_outch(sbuffer, buffer, currlen, maxlen, signvalue); - - while (iplace > 0) - doapr_outch(sbuffer, buffer, currlen, maxlen, iconvert[--iplace]); - - /* - * Decimal point. This should probably use locale to find the correct - * char to print out. - */ - if (max > 0 || (flags & DP_F_NUM)) { - doapr_outch(sbuffer, buffer, currlen, maxlen, '.'); - - while (fplace > 0) - doapr_outch(sbuffer, buffer, currlen, maxlen, fconvert[--fplace]); - } - while (zpadlen > 0) { - doapr_outch(sbuffer, buffer, currlen, maxlen, '0'); - --zpadlen; - } - - while (padlen < 0) { - doapr_outch(sbuffer, buffer, currlen, maxlen, ' '); - ++padlen; - } + int signvalue = 0; + LDOUBLE ufvalue; + char iconvert[20]; + char fconvert[20]; + int iplace = 0; + int fplace = 0; + int padlen = 0; + int zpadlen = 0; + int caps = 0; + long intpart; + long fracpart; + long max10; + + if (max < 0) + max = 6; + ufvalue = abs_val(fvalue); + if (fvalue < 0) + signvalue = '-'; + else if (flags & DP_F_PLUS) + signvalue = '+'; + else if (flags & DP_F_SPACE) + signvalue = ' '; + + intpart = (long)ufvalue; + + /* sorry, we only support 9 digits past the decimal because of our + conversion method */ + if (max > 9) + max = 9; + + /* we "cheat" by converting the fractional part to integer by + multiplying by a factor of 10 */ + max10 = roundv(pow_10(max)); + fracpart = roundv(pow_10(max) * (ufvalue - intpart)); + + if (fracpart >= max10) { + intpart++; + fracpart -= max10; + } + + /* convert integer part */ + do { + iconvert[iplace++] = (caps ? "0123456789ABCDEF" : + "0123456789abcdef")[intpart % 10]; + intpart = (intpart / 10); + } while (intpart && (iplace < (int)sizeof(iconvert))); + if (iplace == sizeof iconvert) + iplace--; + iconvert[iplace] = 0; + + /* convert fractional part */ + do { + fconvert[fplace++] = (caps ? "0123456789ABCDEF" : + "0123456789abcdef")[fracpart % 10]; + fracpart = (fracpart / 10); + } while (fplace < max); + if (fplace == sizeof fconvert) + fplace--; + fconvert[fplace] = 0; + + /* -1 for decimal point, another -1 if we are printing a sign */ + padlen = min - iplace - max - 1 - ((signvalue) ? 1 : 0); + zpadlen = max - fplace; + if (zpadlen < 0) + zpadlen = 0; + if (padlen < 0) + padlen = 0; + if (flags & DP_F_MINUS) + padlen = -padlen; + + if ((flags & DP_F_ZERO) && (padlen > 0)) { + if (signvalue) { + doapr_outch(sbuffer, buffer, currlen, maxlen, signvalue); + --padlen; + signvalue = 0; + } + while (padlen > 0) { + doapr_outch(sbuffer, buffer, currlen, maxlen, '0'); + --padlen; + } + } + while (padlen > 0) { + doapr_outch(sbuffer, buffer, currlen, maxlen, ' '); + --padlen; + } + if (signvalue) + doapr_outch(sbuffer, buffer, currlen, maxlen, signvalue); + + while (iplace > 0) + doapr_outch(sbuffer, buffer, currlen, maxlen, iconvert[--iplace]); + + /* + * Decimal point. This should probably use locale to find the correct + * char to print out. + */ + if (max > 0 || (flags & DP_F_NUM)) { + doapr_outch(sbuffer, buffer, currlen, maxlen, '.'); + + while (fplace > 0) + doapr_outch(sbuffer, buffer, currlen, maxlen, fconvert[--fplace]); + } + while (zpadlen > 0) { + doapr_outch(sbuffer, buffer, currlen, maxlen, '0'); + --zpadlen; + } + + while (padlen < 0) { + doapr_outch(sbuffer, buffer, currlen, maxlen, ' '); + ++padlen; + } } static void -doapr_outch( - char **sbuffer, - char **buffer, - size_t *currlen, - size_t *maxlen, +doapr_outch(char **sbuffer, char **buffer, size_t *currlen, size_t *maxlen, int c) { - /* If we haven't at least one buffer, someone has doe a big booboo */ - assert(*sbuffer != NULL || buffer != NULL); - - if (buffer) { - while (*currlen >= *maxlen) { - if (*buffer == NULL) { - if (*maxlen == 0) - *maxlen = 1024; - *buffer = OPENSSL_malloc(*maxlen); - if (*currlen > 0) { - assert(*sbuffer != NULL); - memcpy(*buffer, *sbuffer, *currlen); + /* If we haven't at least one buffer, someone has doe a big booboo */ + assert(*sbuffer != NULL || buffer != NULL); + + if (buffer) { + while (*currlen >= *maxlen) { + if (*buffer == NULL) { + if (*maxlen == 0) + *maxlen = 1024; + *buffer = OPENSSL_malloc(*maxlen); + if (*currlen > 0) { + assert(*sbuffer != NULL); + memcpy(*buffer, *sbuffer, *currlen); + } + *sbuffer = NULL; + } else { + *maxlen += 1024; + *buffer = OPENSSL_realloc(*buffer, *maxlen); + } } - *sbuffer = NULL; - } else { - *maxlen += 1024; - *buffer = OPENSSL_realloc(*buffer, *maxlen); - } + /* What to do if *buffer is NULL? */ + assert(*sbuffer != NULL || *buffer != NULL); } - /* What to do if *buffer is NULL? */ - assert(*sbuffer != NULL || *buffer != NULL); - } - if (*currlen < *maxlen) { - if (*sbuffer) - (*sbuffer)[(*currlen)++] = (char)c; - else - (*buffer)[(*currlen)++] = (char)c; - } + if (*currlen < *maxlen) { + if (*sbuffer) + (*sbuffer)[(*currlen)++] = (char)c; + else + (*buffer)[(*currlen)++] = (char)c; + } - return; + return; } /***************************************************************************/ int BIO_printf (BIO *bio, const char *format, ...) - { +{ va_list args; int ret; @@ -775,15 +743,15 @@ int BIO_printf (BIO *bio, const char *format, ...) ret = BIO_vprintf(bio, format, args); va_end(args); - return(ret); - } + return (ret); +} int BIO_vprintf (BIO *bio, const char *format, va_list args) - { +{ int ret; size_t retlen; char hugebuf[1024*2]; /* Was previously 10k, which is unreasonable - in small-stack environments, like threads + in small - stack environments, like threads or DOS programs. */ char *hugebufp = hugebuf; size_t hugebufsize = sizeof(hugebuf); @@ -792,27 +760,25 @@ int BIO_vprintf (BIO *bio, const char *format, va_list args) dynbuf = NULL; CRYPTO_push_info("doapr()"); - _dopr(&hugebufp, &dynbuf, &hugebufsize, - &retlen, &ignored, format, args); - if (dynbuf) - { - ret=BIO_write(bio, dynbuf, (int)retlen); + _dopr(&hugebufp, &dynbuf, &hugebufsize, &retlen, &ignored, + format, args); + if (dynbuf) { + ret = BIO_write(bio, dynbuf, (int)retlen); OPENSSL_free(dynbuf); - } - else - { - ret=BIO_write(bio, hugebuf, (int)retlen); - } - CRYPTO_pop_info(); - return(ret); + } else { + ret = BIO_write(bio, hugebuf, (int)retlen); } + CRYPTO_pop_info(); + return (ret); +} /* As snprintf is not available everywhere, we provide our own implementation. * This function has nothing to do with BIOs, but it's closely related * to BIO_printf, and we need *some* name prefix ... * (XXX the function should be renamed, but to what?) */ -int BIO_snprintf(char *buf, size_t n, const char *format, ...) - { +int +BIO_snprintf(char *buf, size_t n, const char *format, ...) +{ va_list args; int ret; @@ -821,11 +787,12 @@ int BIO_snprintf(char *buf, size_t n, const char *format, ...) ret = BIO_vsnprintf(buf, n, format, args); va_end(args); - return(ret); - } + return (ret); +} -int BIO_vsnprintf(char *buf, size_t n, const char *format, va_list args) - { +int +BIO_vsnprintf(char *buf, size_t n, const char *format, va_list args) +{ size_t retlen; int truncated; @@ -839,4 +806,4 @@ int BIO_vsnprintf(char *buf, size_t n, const char *format, va_list args) return -1; else return (retlen <= INT_MAX) ? (int)retlen : -1; - } +} diff --git a/src/lib/libcrypto/bio/b_sock.c b/src/lib/libcrypto/bio/b_sock.c index bd43307456..d739452580 100644 --- a/src/lib/libcrypto/bio/b_sock.c +++ b/src/lib/libcrypto/bio/b_sock.c @@ -85,7 +85,7 @@ NETDB_DEFINE_CONTEXT #endif #if defined(OPENSSL_SYS_WINDOWS) || (defined(OPENSSL_SYS_NETWARE) && !defined(NETWARE_BSDSOCK)) -static int wsa_init_done=0; +static int wsa_init_done = 0; #endif /* @@ -100,36 +100,36 @@ static int wsa_init_done=0; #endif #if 0 -static unsigned long BIO_ghbn_hits=0L; -static unsigned long BIO_ghbn_miss=0L; +static unsigned long BIO_ghbn_hits = 0L; +static unsigned long BIO_ghbn_miss = 0L; #define GHBN_NUM 4 -static struct ghbn_cache_st - { +static struct ghbn_cache_st { char name[129]; struct hostent *ent; unsigned long order; - } ghbn_cache[GHBN_NUM]; +} ghbn_cache[GHBN_NUM]; #endif -static int get_ip(const char *str,unsigned char *ip); +static int get_ip(const char *str, unsigned char *ip); #if 0 static void ghbn_free(struct hostent *a); static struct hostent *ghbn_dup(struct hostent *a); #endif -int BIO_get_host_ip(const char *str, unsigned char *ip) - { + +int +BIO_get_host_ip(const char *str, unsigned char *ip) +{ int i; int err = 1; int locked = 0; struct hostent *he; - i=get_ip(str,ip); - if (i < 0) - { - BIOerr(BIO_F_BIO_GET_HOST_IP,BIO_R_INVALID_IP_ADDRESS); + i = get_ip(str, ip); + if (i < 0) { + BIOerr(BIO_F_BIO_GET_HOST_IP, BIO_R_INVALID_IP_ADDRESS); goto err; - } + } /* At this point, we have something that is most probably correct in some way, so let's init the socket. */ @@ -138,172 +138,169 @@ int BIO_get_host_ip(const char *str, unsigned char *ip) /* If the string actually contained an IP address, we need not do anything more */ - if (i > 0) return(1); + if (i > 0) + return (1); /* do a gethostbyname */ CRYPTO_w_lock(CRYPTO_LOCK_GETHOSTBYNAME); locked = 1; - he=BIO_gethostbyname(str); - if (he == NULL) - { - BIOerr(BIO_F_BIO_GET_HOST_IP,BIO_R_BAD_HOSTNAME_LOOKUP); + he = BIO_gethostbyname(str); + if (he == NULL) { + BIOerr(BIO_F_BIO_GET_HOST_IP, BIO_R_BAD_HOSTNAME_LOOKUP); goto err; - } + } /* cast to short because of win16 winsock definition */ - if ((short)he->h_addrtype != AF_INET) - { - BIOerr(BIO_F_BIO_GET_HOST_IP,BIO_R_GETHOSTBYNAME_ADDR_IS_NOT_AF_INET); + if ((short)he->h_addrtype != AF_INET) { + BIOerr(BIO_F_BIO_GET_HOST_IP, BIO_R_GETHOSTBYNAME_ADDR_IS_NOT_AF_INET); goto err; - } - for (i=0; i<4; i++) - ip[i]=he->h_addr_list[0][i]; + } + for (i = 0; i < 4; i++) + ip[i] = he->h_addr_list[0][i]; err = 0; - err: +err: if (locked) CRYPTO_w_unlock(CRYPTO_LOCK_GETHOSTBYNAME); - if (err) - { - ERR_add_error_data(2,"host=",str); + if (err) { + ERR_add_error_data(2, "host=", str); return 0; - } - else + } else return 1; - } +} -int BIO_get_port(const char *str, unsigned short *port_ptr) - { +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 (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 - { + *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 *' */ #ifndef CONST_STRICT - s=getservbyname((char *)str,"tcp"); + s = getservbyname((char *)str, "tcp"); #else - s=getservbyname(str,"tcp"); + s = getservbyname(str, "tcp"); #endif - if(s != NULL) - *port_ptr=ntohs((unsigned short)s->s_port); + 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 (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,errno); - ERR_add_error_data(3,"service='",str,"'"); - return(0); - } + else if (strcmp(str, "wais") == 0) + *port_ptr = 21; +#endif + else { + SYSerr(SYS_F_GETSERVBYNAME, errno); + ERR_add_error_data(3, "service = '", str, "'"); + return (0); } } - return(1); } + return (1); +} -int BIO_sock_error(int sock) - { - int j,i; +int +BIO_sock_error(int sock) +{ + int j, i; int size; - + #if defined(OPENSSL_SYS_BEOS_R5) return 0; #endif - - size=sizeof(int); + + size = sizeof(int); /* Note: under Windows the third parameter is of type (char *) * whereas under other systems it is (void *) if you don't have * a cast it will choke the compiler: if you do have a cast then * you can either go for (char *) or (void *). */ - i=getsockopt(sock,SOL_SOCKET,SO_ERROR,(void *)&j,(void *)&size); + i = getsockopt(sock, SOL_SOCKET, SO_ERROR,(void *)&j,(void *)&size); if (i < 0) - return(1); + return (1); else - return(j); - } + return (j); +} #if 0 -long BIO_ghbn_ctrl(int cmd, int iarg, char *parg) - { +long +BIO_ghbn_ctrl(int cmd, int iarg, char *parg) +{ int i; char **p; - switch (cmd) - { + switch (cmd) { case BIO_GHBN_CTRL_HITS: - return(BIO_ghbn_hits); + return (BIO_ghbn_hits); /* break; */ case BIO_GHBN_CTRL_MISSES: - return(BIO_ghbn_miss); + return (BIO_ghbn_miss); /* break; */ case BIO_GHBN_CTRL_CACHE_SIZE: - return(GHBN_NUM); + return (GHBN_NUM); /* break; */ case BIO_GHBN_CTRL_GET_ENTRY: - if ((iarg >= 0) && (iarg 0)) - { - p=(char **)parg; - if (p == NULL) return(0); - *p=ghbn_cache[iarg].name; - ghbn_cache[iarg].name[128]='\0'; - return(1); - } - return(0); + if ((iarg >= 0) && (iarg < GHBN_NUM) && + (ghbn_cache[iarg].order > 0)) { + p = (char **)parg; + if (p == NULL) + return (0); + *p = ghbn_cache[iarg].name; + ghbn_cache[iarg].name[128] = '\0'; + return (1); + } + return (0); /* break; */ case BIO_GHBN_CTRL_FLUSH: - for (i=0; ih_aliases[i] != NULL; i++) + for (i = 0; a->h_aliases[i] != NULL; i++) ; i++; ret->h_aliases = (char **)OPENSSL_malloc(i*sizeof(char *)); @@ -311,69 +308,66 @@ static struct hostent *ghbn_dup(struct hostent *a) goto err; memset(ret->h_aliases, 0, i*sizeof(char *)); - for (i=0; a->h_addr_list[i] != NULL; i++) + for (i = 0; a->h_addr_list[i] != NULL; i++) ; i++; - ret->h_addr_list=(char **)OPENSSL_malloc(i*sizeof(char *)); + ret->h_addr_list = (char **)OPENSSL_malloc(i*sizeof(char *)); if (ret->h_addr_list == NULL) goto err; memset(ret->h_addr_list, 0, i*sizeof(char *)); - j=strlen(a->h_name)+1; - if ((ret->h_name=OPENSSL_malloc(j)) == NULL) goto err; - memcpy((char *)ret->h_name,a->h_name,j); - for (i=0; a->h_aliases[i] != NULL; i++) - { - j=strlen(a->h_aliases[i])+1; - if ((ret->h_aliases[i]=OPENSSL_malloc(j)) == NULL) goto err; - memcpy(ret->h_aliases[i],a->h_aliases[i],j); - } - ret->h_length=a->h_length; - ret->h_addrtype=a->h_addrtype; - for (i=0; a->h_addr_list[i] != NULL; i++) - { - if ((ret->h_addr_list[i]=OPENSSL_malloc(a->h_length)) == NULL) + j = strlen(a->h_name) + 1; + if ((ret->h_name = OPENSSL_malloc(j)) == NULL) goto err; + memcpy((char *)ret->h_name, a->h_name, j); + for (i = 0; a->h_aliases[i] != NULL; i++) { + j = strlen(a->h_aliases[i]) + 1; + if ((ret->h_aliases[i] = OPENSSL_malloc(j)) == NULL) goto err; + memcpy(ret->h_aliases[i], a->h_aliases[i], j); + } + ret->h_length = a->h_length; + ret->h_addrtype = a->h_addrtype; + for (i = 0; a->h_addr_list[i] != NULL; i++) { + if ((ret->h_addr_list[i] = OPENSSL_malloc(a->h_length)) == NULL) goto err; - memcpy(ret->h_addr_list[i],a->h_addr_list[i],a->h_length); - } - if (0) - { -err: + memcpy(ret->h_addr_list[i], a->h_addr_list[i], a->h_length); + } + if (0) { +err: if (ret != NULL) ghbn_free(ret); - ret=NULL; - } - MemCheck_on(); - return(ret); + ret = NULL; } + MemCheck_on(); + return (ret); +} -static void ghbn_free(struct hostent *a) - { +static void +ghbn_free(struct hostent *a) +{ int i; - if(a == NULL) - return; + if (a == NULL) + return; - if (a->h_aliases != NULL) - { - for (i=0; a->h_aliases[i] != NULL; i++) + if (a->h_aliases != NULL) { + for (i = 0; a->h_aliases[i] != NULL; i++) OPENSSL_free(a->h_aliases[i]); OPENSSL_free(a->h_aliases); - } - if (a->h_addr_list != NULL) - { - for (i=0; a->h_addr_list[i] != NULL; i++) + } + if (a->h_addr_list != NULL) { + for (i = 0; a->h_addr_list[i] != NULL; i++) OPENSSL_free(a->h_addr_list[i]); OPENSSL_free(a->h_addr_list); - } - if (a->h_name != NULL) OPENSSL_free(a->h_name); - OPENSSL_free(a); } + if (a->h_name != NULL) + OPENSSL_free(a->h_name); + OPENSSL_free(a); +} #endif -struct hostent *BIO_gethostbyname(const char *name) - { +struct hostent +*BIO_gethostbyname(const char *name) { #if 1 /* Caching gethostbyname() results forever is wrong, * so we have to let the true gethostbyname() worry about this */ @@ -384,8 +378,8 @@ struct hostent *BIO_gethostbyname(const char *name) #endif #else struct hostent *ret; - int i,lowi=0,j; - unsigned long low= (unsigned long)-1; + int i, lowi = 0, j; + unsigned long low = (unsigned long) - 1; # if 0 @@ -395,42 +389,37 @@ struct hostent *BIO_gethostbyname(const char *name) */ CRYPTO_w_lock(CRYPTO_LOCK_GETHOSTBYNAME); # endif - j=strlen(name); - if (j < 128) - { - for (i=0; i ghbn_cache[i].order) - { - low=ghbn_cache[i].order; - lowi=i; - } - if (ghbn_cache[i].order > 0) - { - if (strncmp(name,ghbn_cache[i].name,128) == 0) + j = strlen(name); + if (j < 128) { + for (i = 0; i < GHBN_NUM; i++) { + if (low > ghbn_cache[i].order) { + low = ghbn_cache[i].order; + lowi = i; + } + if (ghbn_cache[i].order > 0) { + if (strncmp(name, ghbn_cache[i].name, 128) == 0) break; - } } } - else - i=GHBN_NUM; + } else + i = GHBN_NUM; if (i == GHBN_NUM) /* no hit*/ - { + { BIO_ghbn_miss++; /* Note: under VMS with SOCKETSHR, it seems like the first * parameter is 'char *', instead of 'const char *' */ # ifndef CONST_STRICT - ret=gethostbyname((char *)name); + ret = gethostbyname((char *)name); # else - ret=gethostbyname(name); + ret = gethostbyname(name); # endif if (ret == NULL) goto end; if (j > 128) /* too big to cache */ - { + { # if 0 /* If we were trying to make this function thread-safe (which * is bound to fail), we'd have to give up in this case @@ -438,118 +427,113 @@ struct hostent *BIO_gethostbyname(const char *name) ret = NULL; # endif goto end; - } + } /* else add to cache */ if (ghbn_cache[lowi].ent != NULL) ghbn_free(ghbn_cache[lowi].ent); /* XXX not thread-safe */ ghbn_cache[lowi].name[0] = '\0'; - if((ret=ghbn_cache[lowi].ent=ghbn_dup(ret)) == NULL) - { - BIOerr(BIO_F_BIO_GETHOSTBYNAME,ERR_R_MALLOC_FAILURE); + if ((ret = ghbn_cache[lowi].ent = ghbn_dup(ret)) == NULL) { + BIOerr(BIO_F_BIO_GETHOSTBYNAME, ERR_R_MALLOC_FAILURE); goto end; - } - strncpy(ghbn_cache[lowi].name,name,128); - ghbn_cache[lowi].order=BIO_ghbn_miss+BIO_ghbn_hits; } - else - { + strncpy(ghbn_cache[lowi].name, name, 128); + ghbn_cache[lowi].order = BIO_ghbn_miss + BIO_ghbn_hits; + } else { BIO_ghbn_hits++; - ret= ghbn_cache[i].ent; - ghbn_cache[i].order=BIO_ghbn_miss+BIO_ghbn_hits; - } + ret = ghbn_cache[i].ent; + ghbn_cache[i].order = BIO_ghbn_miss + BIO_ghbn_hits; + } end: # if 0 CRYPTO_w_unlock(CRYPTO_LOCK_GETHOSTBYNAME); # endif - return(ret); + return (ret); #endif - } +} -int BIO_sock_init(void) - { +int +BIO_sock_init(void) +{ #ifdef OPENSSL_SYS_WINDOWS static struct WSAData wsa_state; - if (!wsa_init_done) - { + if (!wsa_init_done) { int err; - - wsa_init_done=1; - memset(&wsa_state,0,sizeof(wsa_state)); + + 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); - } + 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() */ + _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); - } + 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); - } + return (1); +} -void BIO_sock_cleanup(void) - { +void +BIO_sock_cleanup(void) +{ #ifdef OPENSSL_SYS_WINDOWS - if (wsa_init_done) - { - wsa_init_done=0; + if (wsa_init_done) { + wsa_init_done = 0; #if 0 /* this call is claimed to be non-present in Winsock2 */ WSACancelBlockingCall(); #endif WSACleanup(); - } + } #elif defined(OPENSSL_SYS_NETWARE) && !defined(NETWARE_BSDSOCK) - if (wsa_init_done) - { - wsa_init_done=0; - WSACleanup(); - } -#endif + if (wsa_init_done) { + wsa_init_done = 0; + WSACleanup(); } +#endif +} #if !defined(OPENSSL_SYS_VMS) || __VMS_VER >= 70000000 -int BIO_socket_ioctl(int fd, long type, void *arg) - { +int +BIO_socket_ioctl(int fd, long type, void *arg) +{ int i; #ifdef __DJGPP__ - i=ioctl(fd,type,(char *)arg); + i = ioctl(fd, type,(char *)arg); #else # if defined(OPENSSL_SYS_VMS) /* 2011-02-18 SMS. @@ -574,402 +558,399 @@ int BIO_socket_ioctl(int fd, long type, void *arg) # define ARG arg # endif /* defined(OPENSSL_SYS_VMS) [else] */ - i=ioctl(fd,type,ARG); + i = ioctl(fd, type, ARG); #endif /* __DJGPP__ */ if (i < 0) - SYSerr(SYS_F_IOCTLSOCKET,errno); - return(i); - } + SYSerr(SYS_F_IOCTLSOCKET, errno); + return (i); +} #endif /* __VMS_VER */ /* The reason I have implemented this instead of using sscanf is because * Visual C 1.52c gives an unresolved external when linking a DLL :-( */ -static int get_ip(const char *str, unsigned char ip[4]) - { +static int +get_ip(const char *str, unsigned char ip[4]) +{ unsigned int tmp[4]; - int num=0,c,ok=0; + int num = 0, c, ok = 0; - tmp[0]=tmp[1]=tmp[2]=tmp[3]=0; + tmp[0] = tmp[1] = tmp[2] = tmp[3] = 0; - for (;;) - { + for (;;) { c= *(str++); - if ((c >= '0') && (c <= '9')) - { - ok=1; - tmp[num]=tmp[num]*10+c-'0'; - if (tmp[num] > 255) return(0); - } - else if (c == '.') - { - if (!ok) return(-1); - if (num == 3) return(0); + if ((c >= '0') && (c <= '9')) { + ok = 1; + tmp[num] = tmp[num]*10 + c-'0'; + if (tmp[num] > 255) + return (0); + } else if (c == '.') { + if (!ok) + return (-1); + if (num == 3) + return (0); num++; - ok=0; - } - else if (c == '\0' && (num == 3) && ok) - break; + ok = 0; + } else if (c == '\0' && (num == 3) && ok) + break; else - return(0); - } - ip[0]=tmp[0]; - ip[1]=tmp[1]; - ip[2]=tmp[2]; - ip[3]=tmp[3]; - return(1); + return (0); } - -int BIO_get_accept_socket(char *host, int bind_mode) - { - int ret=0; + ip[0] = tmp[0]; + ip[1] = tmp[1]; + ip[2] = tmp[2]; + ip[3] = tmp[3]; + return (1); +} + +int +BIO_get_accept_socket(char *host, int bind_mode) +{ + int ret = 0; union { struct sockaddr sa; struct sockaddr_in sa_in; #if OPENSSL_USE_IPV6 struct sockaddr_in6 sa_in6; #endif - } server,client; - int s=-1,cs,addrlen; + } server, client; + int s = -1, cs, addrlen; unsigned char ip[4]; unsigned short port; - char *str=NULL,*e; - char *h,*p; + char *str = NULL, *e; + char *h, *p; unsigned long l; int err_num; - if (BIO_sock_init() != 1) return(-1); + if (BIO_sock_init() != 1) + return (-1); - if ((str=BUF_strdup(host)) == NULL) return(-1); + if ((str = BUF_strdup(host)) == NULL) + return (-1); - h=p=NULL; - h=str; - for (e=str; *e; e++) - { - if (*e == ':') - { - p=e; - } - else if (*e == '/') - { - *e='\0'; + h = p = NULL; + h = str; + for (e = str; *e; e++) { + if (*e == ':') { + p = e; + } else if (*e == '/') { + *e = '\0'; break; - } } - if (p) *p++='\0'; /* points at last ':', '::port' is special [see below] */ - else p=h,h=NULL; + } + if (p) + *p++='\0'; /* points at last ':', '::port' is special [see below] */ + else + p = h, h = NULL; #ifdef EAI_FAMILY do { - static union { void *p; - int (WSAAPI *f)(const char *,const char *, - const struct addrinfo *, - struct addrinfo **); - } p_getaddrinfo = {NULL}; - static union { void *p; + static union { + void *p; + int (WSAAPI *f)(const char *, const char *, + const struct addrinfo *, + struct addrinfo **); + } p_getaddrinfo = {NULL}; + static union { + void *p; void (WSAAPI *f)(struct addrinfo *); - } p_freeaddrinfo = {NULL}; - struct addrinfo *res,hint; - - if (p_getaddrinfo.p==NULL) - { - if ((p_getaddrinfo.p=DSO_global_lookup("getaddrinfo"))==NULL || - (p_freeaddrinfo.p=DSO_global_lookup("freeaddrinfo"))==NULL) - p_getaddrinfo.p=(void*)-1; - } - if (p_getaddrinfo.p==(void *)-1) break; - - /* '::port' enforces IPv6 wildcard listener. Some OSes, - * e.g. Solaris, default to IPv6 without any hint. Also - * note that commonly IPv6 wildchard socket can service - * IPv4 connections just as well... */ - memset(&hint,0,sizeof(hint)); - hint.ai_flags = AI_PASSIVE; - if (h) - { - if (strchr(h,':')) - { - if (h[1]=='\0') h=NULL; + } p_freeaddrinfo = {NULL}; + struct addrinfo *res, hint; + + if (p_getaddrinfo.p == NULL) { + if ((p_getaddrinfo.p = DSO_global_lookup("getaddrinfo"))==NULL || + (p_freeaddrinfo.p = DSO_global_lookup("freeaddrinfo"))==NULL) + p_getaddrinfo.p = (void*) - 1; + } + if (p_getaddrinfo.p == (void *) - 1) break; + + /* '::port' enforces IPv6 wildcard listener. Some OSes, + * e.g. Solaris, default to IPv6 without any hint. Also + * note that commonly IPv6 wildchard socket can service + * IPv4 connections just as well... */ + memset(&hint, 0, sizeof(hint)); + hint.ai_flags = AI_PASSIVE; + if (h) { + if (strchr(h, ':')) { + if (h[1] == '\0') + h = NULL; #if OPENSSL_USE_IPV6 - hint.ai_family = AF_INET6; + hint.ai_family = AF_INET6; #else - h=NULL; + h = NULL; #endif - } - else if (h[0]=='*' && h[1]=='\0') - { - hint.ai_family = AF_INET; - h=NULL; + } else if (h[0] == '*' && h[1] == '\0') { + hint.ai_family = AF_INET; + h = NULL; } } - if ((*p_getaddrinfo.f)(h,p,&hint,&res)) break; + if ((*p_getaddrinfo.f)(h, p, &hint, &res)) + break; - addrlen = res->ai_addrlen<=sizeof(server) ? - res->ai_addrlen : - sizeof(server); - memcpy(&server, res->ai_addr, addrlen); + addrlen = res->ai_addrlen <= sizeof(server) ? + res->ai_addrlen : sizeof(server); + memcpy(&server, res->ai_addr, addrlen); - (*p_freeaddrinfo.f)(res); - goto again; + (*p_freeaddrinfo.f)(res); + goto again; } while (0); #endif - if (!BIO_get_port(p,&port)) goto err; + if (!BIO_get_port(p, &port)) + goto err; - memset((char *)&server,0,sizeof(server)); - server.sa_in.sin_family=AF_INET; - server.sa_in.sin_port=htons(port); + memset((char *)&server, 0, sizeof(server)); + server.sa_in.sin_family = AF_INET; + server.sa_in.sin_port = htons(port); addrlen = sizeof(server.sa_in); - if (h == NULL || strcmp(h,"*") == 0) - server.sa_in.sin_addr.s_addr=INADDR_ANY; - else - { - if (!BIO_get_host_ip(h,&(ip[0]))) goto err; - l=(unsigned long) - ((unsigned long)ip[0]<<24L)| - ((unsigned long)ip[1]<<16L)| - ((unsigned long)ip[2]<< 8L)| - ((unsigned long)ip[3]); - server.sa_in.sin_addr.s_addr=htonl(l); - } + if (h == NULL || strcmp(h, "*") == 0) + server.sa_in.sin_addr.s_addr = INADDR_ANY; + else { + if (!BIO_get_host_ip(h, &(ip[0]))) + goto err; + l = (unsigned long) + ((unsigned long)ip[0]<<24L)| + ((unsigned long)ip[1]<<16L)| + ((unsigned long)ip[2]<< 8L)| + ((unsigned long)ip[3]); + server.sa_in.sin_addr.s_addr = htonl(l); + } again: - s=socket(server.sa.sa_family,SOCK_STREAM,SOCKET_PROTOCOL); - if (s == -1) - { - SYSerr(SYS_F_SOCKET,errno); - ERR_add_error_data(3,"port='",host,"'"); - BIOerr(BIO_F_BIO_GET_ACCEPT_SOCKET,BIO_R_UNABLE_TO_CREATE_SOCKET); + s = socket(server.sa.sa_family, SOCK_STREAM, SOCKET_PROTOCOL); + if (s == -1) { + SYSerr(SYS_F_SOCKET, errno); + ERR_add_error_data(3, "port = '", host, "'"); + BIOerr(BIO_F_BIO_GET_ACCEPT_SOCKET, BIO_R_UNABLE_TO_CREATE_SOCKET); goto err; - } + } #ifdef SO_REUSEADDR - if (bind_mode == BIO_BIND_REUSEADDR) - { - int i=1; + if (bind_mode == BIO_BIND_REUSEADDR) { + int i = 1; - ret=setsockopt(s,SOL_SOCKET,SO_REUSEADDR,(char *)&i,sizeof(i)); - bind_mode=BIO_BIND_NORMAL; - } + ret = setsockopt(s, SOL_SOCKET, SO_REUSEADDR,(char *)&i, sizeof(i)); + bind_mode = BIO_BIND_NORMAL; + } #endif - if (bind(s,&server.sa,addrlen) == -1) - { + if (bind(s, &server.sa, addrlen) == -1) { #ifdef SO_REUSEADDR - err_num=errno; + err_num = errno; if ((bind_mode == BIO_BIND_REUSEADDR_IF_UNUSED) && #ifdef OPENSSL_SYS_WINDOWS /* Some versions of Windows define EADDRINUSE to * a dummy value. */ - (err_num == WSAEADDRINUSE)) + (err_num == WSAEADDRINUSE)) #else - (err_num == EADDRINUSE)) + (err_num == EADDRINUSE)) #endif - { + { client = server; - if (h == NULL || strcmp(h,"*") == 0) - { + if (h == NULL || strcmp(h, "*") == 0) { #if OPENSSL_USE_IPV6 - if (client.sa.sa_family == AF_INET6) - { - memset(&client.sa_in6.sin6_addr,0,sizeof(client.sa_in6.sin6_addr)); - client.sa_in6.sin6_addr.s6_addr[15]=1; - } - else -#endif - if (client.sa.sa_family == AF_INET) - { - client.sa_in.sin_addr.s_addr=htonl(0x7F000001); - } - else goto err; - } - cs=socket(client.sa.sa_family,SOCK_STREAM,SOCKET_PROTOCOL); - if (cs != -1) - { + if (client.sa.sa_family == AF_INET6) { + memset(&client.sa_in6.sin6_addr, 0, sizeof(client.sa_in6.sin6_addr)); + client.sa_in6.sin6_addr.s6_addr[15] = 1; + } else +#endif + if (client.sa.sa_family == AF_INET) { + client.sa_in.sin_addr.s_addr = htonl(0x7F000001); + } else + goto err; + } + cs = socket(client.sa.sa_family, SOCK_STREAM, SOCKET_PROTOCOL); + if (cs != -1) { int ii; - ii=connect(cs,&client.sa,addrlen); + ii = connect(cs, &client.sa, addrlen); close(cs); - if (ii == -1) - { - bind_mode=BIO_BIND_REUSEADDR; + if (ii == -1) { + bind_mode = BIO_BIND_REUSEADDR; close(s); goto again; - } - /* else error */ } - /* else error */ + /* else error */ } + /* else error */ + } #endif - SYSerr(SYS_F_BIND,err_num); - ERR_add_error_data(3,"port='",host,"'"); - BIOerr(BIO_F_BIO_GET_ACCEPT_SOCKET,BIO_R_UNABLE_TO_BIND_SOCKET); + SYSerr(SYS_F_BIND, err_num); + ERR_add_error_data(3, "port = '", host, "'"); + BIOerr(BIO_F_BIO_GET_ACCEPT_SOCKET, BIO_R_UNABLE_TO_BIND_SOCKET); goto err; - } - if (listen(s,MAX_LISTEN) == -1) - { - SYSerr(SYS_F_BIND,errno); - ERR_add_error_data(3,"port='",host,"'"); - BIOerr(BIO_F_BIO_GET_ACCEPT_SOCKET,BIO_R_UNABLE_TO_LISTEN_SOCKET); + } + if (listen(s, MAX_LISTEN) == -1) { + SYSerr(SYS_F_BIND, errno); + ERR_add_error_data(3, "port = '", host, "'"); + BIOerr(BIO_F_BIO_GET_ACCEPT_SOCKET, BIO_R_UNABLE_TO_LISTEN_SOCKET); goto err; - } - ret=1; + } + ret = 1; err: - if (str != NULL) OPENSSL_free(str); - if ((ret == 0) && (s != -1)) - { + if (str != NULL) + OPENSSL_free(str); + if ((ret == 0) && (s != -1)) { close(s); - s= -1; - } - return(s); + s = -1; } + return (s); +} -int BIO_accept(int sock, char **addr) - { - int ret=-1; +int +BIO_accept(int sock, char **addr) +{ + int ret = -1; unsigned long l; unsigned short port; char *p; struct { - /* - * As for following union. Trouble is that there are platforms - * that have socklen_t and there are platforms that don't, on - * some platforms socklen_t is int and on some size_t. So what - * one can do? One can cook #ifdef spaghetti, which is nothing - * but masochistic. Or one can do union between int and size_t. - * One naturally does it primarily for 64-bit platforms where - * sizeof(int) != sizeof(size_t). But would it work? Note that - * if size_t member is initialized to 0, then later int member - * assignment naturally does the job on little-endian platforms - * regardless accept's expectations! What about big-endians? - * If accept expects int*, then it works, and if size_t*, then - * length value would appear as unreasonably large. But this - * won't prevent it from filling in the address structure. The - * trouble of course would be if accept returns more data than - * actual buffer can accomodate and overwrite stack... That's - * where early OPENSSL_assert comes into picture. Besides, the - * only 64-bit big-endian platform found so far that expects - * size_t* is HP-UX, where stack grows towards higher address. - * - */ - union { size_t s; int i; } len; - union { - struct sockaddr sa; - struct sockaddr_in sa_in; + /* + * As for following union. Trouble is that there are platforms + * that have socklen_t and there are platforms that don't, on + * some platforms socklen_t is int and on some size_t. So what + * one can do? One can cook #ifdef spaghetti, which is nothing + * but masochistic. Or one can do union between int and size_t. + * One naturally does it primarily for 64-bit platforms where + * sizeof(int) != sizeof(size_t). But would it work? Note that + * if size_t member is initialized to 0, then later int member + * assignment naturally does the job on little-endian platforms + * regardless accept's expectations! What about big-endians? + * If accept expects int*, then it works, and if size_t*, then + * length value would appear as unreasonably large. But this + * won't prevent it from filling in the address structure. The + * trouble of course would be if accept returns more data than + * actual buffer can accomodate and overwrite stack... That's + * where early OPENSSL_assert comes into picture. Besides, the + * only 64-bit big-endian platform found so far that expects + * size_t* is HP-UX, where stack grows towards higher address. + * + */ + union { + size_t s; + int i; + } len; + union { + struct sockaddr sa; + struct sockaddr_in sa_in; #if OPENSSL_USE_IPV6 - struct sockaddr_in6 sa_in6; + struct sockaddr_in6 sa_in6; #endif } from; } sa; - sa.len.s=0; - sa.len.i=sizeof(sa.from); - memset(&sa.from,0,sizeof(sa.from)); - ret=accept(sock,&sa.from.sa,(void *)&sa.len); - if (sizeof(sa.len.i)!=sizeof(sa.len.s) && sa.len.i==0) - { - OPENSSL_assert(sa.len.s<=sizeof(sa.from)); + sa.len.s = 0; + sa.len.i = sizeof(sa.from); + memset(&sa.from, 0, sizeof(sa.from)); + ret = accept(sock, &sa.from.sa,(void *)&sa.len); + if (sizeof(sa.len.i) != sizeof(sa.len.s) && sa.len.i == 0) { + OPENSSL_assert(sa.len.s <= sizeof(sa.from)); sa.len.i = (int)sa.len.s; /* use sa.len.i from this point */ - } - if (ret == -1) - { - if(BIO_sock_should_retry(ret)) return -2; - SYSerr(SYS_F_ACCEPT,errno); - BIOerr(BIO_F_BIO_ACCEPT,BIO_R_ACCEPT_ERROR); + } + if (ret == -1) { + if (BIO_sock_should_retry(ret)) return -2; + SYSerr(SYS_F_ACCEPT, errno); + BIOerr(BIO_F_BIO_ACCEPT, BIO_R_ACCEPT_ERROR); goto end; - } + } - if (addr == NULL) goto end; + if (addr == NULL) + goto end; #ifdef EAI_FAMILY do { - char h[NI_MAXHOST],s[NI_MAXSERV]; - size_t nl; - static union { void *p; - int (WSAAPI *f)(const struct sockaddr *,size_t/*socklen_t*/, - char *,size_t,char *,size_t,int); - } p_getnameinfo = {NULL}; - /* 2nd argument to getnameinfo is specified to - * be socklen_t. Unfortunately there is a number - * of environments where socklen_t is not defined. - * As it's passed by value, it's safe to pass it - * as size_t... */ - - if (p_getnameinfo.p==NULL) - { - if ((p_getnameinfo.p=DSO_global_lookup("getnameinfo"))==NULL) - p_getnameinfo.p=(void*)-1; + char h[NI_MAXHOST], s[NI_MAXSERV]; + size_t nl; + static union { + void *p; + int (WSAAPI *f)(const struct sockaddr *, + size_t/*socklen_t*/, char *, size_t, + char *, size_t, int); + } p_getnameinfo = {NULL}; + /* 2nd argument to getnameinfo is specified to + * be socklen_t. Unfortunately there is a number + * of environments where socklen_t is not defined. + * As it's passed by value, it's safe to pass it + * as size_t... */ + + if (p_getnameinfo.p == NULL) { + if ((p_getnameinfo.p = DSO_global_lookup("getnameinfo")) == NULL) + p_getnameinfo.p = (void*) - 1; + } + if (p_getnameinfo.p == (void *) - 1) + break; + + if ((*p_getnameinfo.f)(&sa.from.sa, sa.len.i, h, sizeof(h), + s, sizeof(s), NI_NUMERICHOST|NI_NUMERICSERV)) + break; + nl = strlen(h) + strlen(s) + 2; + p = *addr; + if (p) { + *p = '\0'; + p = OPENSSL_realloc(p, nl); + } else { + p = OPENSSL_malloc(nl); + } + if (p == NULL) { + BIOerr(BIO_F_BIO_ACCEPT, ERR_R_MALLOC_FAILURE); + goto end; } - if (p_getnameinfo.p==(void *)-1) break; - - if ((*p_getnameinfo.f)(&sa.from.sa,sa.len.i,h,sizeof(h),s,sizeof(s), - NI_NUMERICHOST|NI_NUMERICSERV)) break; - nl = strlen(h)+strlen(s)+2; - p = *addr; - if (p) { *p = '\0'; p = OPENSSL_realloc(p,nl); } - else { p = OPENSSL_malloc(nl); } - if (p==NULL) - { - BIOerr(BIO_F_BIO_ACCEPT,ERR_R_MALLOC_FAILURE); + *addr = p; + (void) snprintf(*addr, nl, "%s:%s", h, s); goto end; - } - *addr = p; - (void) snprintf(*addr,nl,"%s:%s",h,s); - goto end; - } while(0); -#endif - if (sa.from.sa.sa_family != AF_INET) goto end; - l=ntohl(sa.from.sa_in.sin_addr.s_addr); - port=ntohs(sa.from.sa_in.sin_port); - if (*addr == NULL) - { - if ((p=OPENSSL_malloc(24)) == NULL) - { - BIOerr(BIO_F_BIO_ACCEPT,ERR_R_MALLOC_FAILURE); + } while (0); +#endif + if (sa.from.sa.sa_family != AF_INET) + goto end; + l = ntohl(sa.from.sa_in.sin_addr.s_addr); + port = ntohs(sa.from.sa_in.sin_port); + if (*addr == NULL) { + if ((p = OPENSSL_malloc(24)) == NULL) { + BIOerr(BIO_F_BIO_ACCEPT, ERR_R_MALLOC_FAILURE); goto end; - } - *addr=p; } - (void) snprintf(*addr,24,"%d.%d.%d.%d:%d", - (unsigned char)(l>>24L)&0xff, - (unsigned char)(l>>16L)&0xff, - (unsigned char)(l>> 8L)&0xff, - (unsigned char)(l )&0xff, - port); -end: - return(ret); + *addr = p; } + (void) snprintf(*addr, 24, "%d.%d.%d.%d:%d", + (unsigned char)(l >> 24L) & 0xff, (unsigned char)(l >> 16L) & 0xff, + (unsigned char)(l >> 8L) & 0xff, (unsigned char)(l) & 0xff, port); -int BIO_set_tcp_ndelay(int s, int on) - { - int ret=0; +end: + return (ret); +} + +int +BIO_set_tcp_ndelay(int s, int on) +{ + int ret = 0; #if defined(TCP_NODELAY) && (defined(IPPROTO_TCP) || defined(SOL_TCP)) int opt; #ifdef SOL_TCP - opt=SOL_TCP; + opt = SOL_TCP; #else #ifdef IPPROTO_TCP - opt=IPPROTO_TCP; + opt = IPPROTO_TCP; #endif #endif - - ret=setsockopt(s,opt,TCP_NODELAY,(char *)&on,sizeof(on)); + + ret = setsockopt(s, opt, TCP_NODELAY,(char *)&on, sizeof(on)); #endif - return(ret == 0); - } + return (ret == 0); +} -int BIO_socket_nbio(int s, int mode) - { - int ret= -1; +int +BIO_socket_nbio(int s, int mode) +{ + int ret = -1; int l; - l=mode; + l = mode; #ifdef FIONBIO - ret=BIO_socket_ioctl(s,FIONBIO,&l); + ret = BIO_socket_ioctl(s, FIONBIO, &l); #endif - return(ret == 0); - } + return (ret == 0); +} #endif diff --git a/src/lib/libcrypto/bio/bf_buff.c b/src/lib/libcrypto/bio/bf_buff.c index 4b5a132d8a..9518cf977e 100644 --- a/src/lib/libcrypto/bio/bf_buff.c +++ b/src/lib/libcrypto/bio/bf_buff.c @@ -61,7 +61,7 @@ #include "cryptlib.h" #include -static int buffer_write(BIO *h, const char *buf,int num); +static int buffer_write(BIO *h, const char *buf, int num); static int buffer_read(BIO *h, char *buf, int size); static int buffer_puts(BIO *h, const char *str); static int buffer_gets(BIO *h, char *str, int size); @@ -71,8 +71,7 @@ static int buffer_free(BIO *data); static long buffer_callback_ctrl(BIO *h, int cmd, bio_info_cb *fp); #define DEFAULT_BUFFER_SIZE 4096 -static BIO_METHOD methods_buffer= - { +static BIO_METHOD methods_buffer = { BIO_TYPE_BUFFER, "buffer", buffer_write, @@ -83,430 +82,444 @@ static BIO_METHOD methods_buffer= buffer_new, buffer_free, buffer_callback_ctrl, - }; +}; -BIO_METHOD *BIO_f_buffer(void) - { - return(&methods_buffer); - } +BIO_METHOD +*BIO_f_buffer(void) +{ + return (&methods_buffer); +} -static int buffer_new(BIO *bi) - { +static int +buffer_new(BIO *bi) +{ BIO_F_BUFFER_CTX *ctx; - ctx=(BIO_F_BUFFER_CTX *)OPENSSL_malloc(sizeof(BIO_F_BUFFER_CTX)); - if (ctx == NULL) return(0); - ctx->ibuf=(char *)OPENSSL_malloc(DEFAULT_BUFFER_SIZE); - if (ctx->ibuf == NULL) { OPENSSL_free(ctx); return(0); } - ctx->obuf=(char *)OPENSSL_malloc(DEFAULT_BUFFER_SIZE); - if (ctx->obuf == NULL) { OPENSSL_free(ctx->ibuf); OPENSSL_free(ctx); return(0); } - ctx->ibuf_size=DEFAULT_BUFFER_SIZE; - ctx->obuf_size=DEFAULT_BUFFER_SIZE; - ctx->ibuf_len=0; - ctx->ibuf_off=0; - ctx->obuf_len=0; - ctx->obuf_off=0; - - bi->init=1; - bi->ptr=(char *)ctx; - bi->flags=0; - return(1); + ctx = (BIO_F_BUFFER_CTX *)OPENSSL_malloc(sizeof(BIO_F_BUFFER_CTX)); + if (ctx == NULL) + return (0); + ctx->ibuf = (char *)OPENSSL_malloc(DEFAULT_BUFFER_SIZE); + if (ctx->ibuf == NULL) { + OPENSSL_free(ctx); + return (0); } - -static int buffer_free(BIO *a) - { + ctx->obuf = (char *)OPENSSL_malloc(DEFAULT_BUFFER_SIZE); + if (ctx->obuf == NULL) { + OPENSSL_free(ctx->ibuf); + OPENSSL_free(ctx); + return (0); + } + ctx->ibuf_size = DEFAULT_BUFFER_SIZE; + ctx->obuf_size = DEFAULT_BUFFER_SIZE; + ctx->ibuf_len = 0; + ctx->ibuf_off = 0; + ctx->obuf_len = 0; + ctx->obuf_off = 0; + + bi->init = 1; + bi->ptr = (char *)ctx; + bi->flags = 0; + return (1); +} + +static int +buffer_free(BIO *a) +{ BIO_F_BUFFER_CTX *b; - if (a == NULL) return(0); - b=(BIO_F_BUFFER_CTX *)a->ptr; - if (b->ibuf != NULL) OPENSSL_free(b->ibuf); - if (b->obuf != NULL) OPENSSL_free(b->obuf); + if (a == NULL) + return (0); + b = (BIO_F_BUFFER_CTX *)a->ptr; + if (b->ibuf != NULL) + OPENSSL_free(b->ibuf); + if (b->obuf != NULL) + OPENSSL_free(b->obuf); OPENSSL_free(a->ptr); - a->ptr=NULL; - a->init=0; - a->flags=0; - return(1); - } - -static int buffer_read(BIO *b, char *out, int outl) - { - int i,num=0; + a->ptr = NULL; + a->init = 0; + a->flags = 0; + return (1); +} + +static int +buffer_read(BIO *b, char *out, int outl) +{ + int i, num = 0; BIO_F_BUFFER_CTX *ctx; - if (out == NULL) return(0); - ctx=(BIO_F_BUFFER_CTX *)b->ptr; + if (out == NULL) + return (0); + ctx = (BIO_F_BUFFER_CTX *)b->ptr; - if ((ctx == NULL) || (b->next_bio == NULL)) return(0); - num=0; + if ((ctx == NULL) || (b->next_bio == NULL)) + return (0); + num = 0; BIO_clear_retry_flags(b); start: - i=ctx->ibuf_len; + i = ctx->ibuf_len; /* If there is stuff left over, grab it */ - if (i != 0) - { - if (i > outl) i=outl; - memcpy(out,&(ctx->ibuf[ctx->ibuf_off]),i); - ctx->ibuf_off+=i; - ctx->ibuf_len-=i; - num+=i; - if (outl == i) return(num); - outl-=i; - out+=i; - } + if (i != 0) { + if (i > outl) + i = outl; + memcpy(out, &(ctx->ibuf[ctx->ibuf_off]), i); + ctx->ibuf_off += i; + ctx->ibuf_len -= i; + num += i; + if (outl == i) + return (num); + outl -= i; + out += i; + } /* We may have done a partial read. try to do more. * We have nothing in the buffer. * If we get an error and have read some data, just return it * and let them retry to get the error again. * copy direct to parent address space */ - if (outl > ctx->ibuf_size) - { - for (;;) - { - i=BIO_read(b->next_bio,out,outl); - if (i <= 0) - { + if (outl > ctx->ibuf_size) { + for (;;) { + i = BIO_read(b->next_bio, out, outl); + if (i <= 0) { BIO_copy_next_retry(b); - if (i < 0) return((num > 0)?num:i); - if (i == 0) return(num); - } - num+=i; - if (outl == i) return(num); - out+=i; - outl-=i; + if (i < 0) + return ((num > 0) ? num : i); + if (i == 0) + return (num); } + num += i; + if (outl == i) + return (num); + out += i; + outl -= i; } + } /* else */ /* we are going to be doing some buffering */ - i=BIO_read(b->next_bio,ctx->ibuf,ctx->ibuf_size); - if (i <= 0) - { + i = BIO_read(b->next_bio, ctx->ibuf, ctx->ibuf_size); + if (i <= 0) { BIO_copy_next_retry(b); - if (i < 0) return((num > 0)?num:i); - if (i == 0) return(num); - } - ctx->ibuf_off=0; - ctx->ibuf_len=i; + if (i < 0) + return ((num > 0) ? num : i); + if (i == 0) + return (num); + } + ctx->ibuf_off = 0; + ctx->ibuf_len = i; /* Lets re-read using ourselves :-) */ goto start; - } +} -static int buffer_write(BIO *b, const char *in, int inl) - { - int i,num=0; +static int +buffer_write(BIO *b, const char *in, int inl) +{ + int i, num = 0; BIO_F_BUFFER_CTX *ctx; - if ((in == NULL) || (inl <= 0)) return(0); - ctx=(BIO_F_BUFFER_CTX *)b->ptr; - if ((ctx == NULL) || (b->next_bio == NULL)) return(0); + if ((in == NULL) || (inl <= 0)) + return (0); + ctx = (BIO_F_BUFFER_CTX *)b->ptr; + if ((ctx == NULL) || (b->next_bio == NULL)) + return (0); BIO_clear_retry_flags(b); start: - i=ctx->obuf_size-(ctx->obuf_len+ctx->obuf_off); + i = ctx->obuf_size - (ctx->obuf_len + ctx->obuf_off); /* add to buffer and return */ - if (i >= inl) - { - memcpy(&(ctx->obuf[ctx->obuf_off+ctx->obuf_len]),in,inl); - ctx->obuf_len+=inl; - return(num+inl); - } + if (i >= inl) { + memcpy(&(ctx->obuf[ctx->obuf_off + ctx->obuf_len]), in, inl); + ctx->obuf_len += inl; + return (num + inl); + } /* else */ /* stuff already in buffer, so add to it first, then flush */ - if (ctx->obuf_len != 0) - { + if (ctx->obuf_len != 0) { if (i > 0) /* lets fill it up if we can */ - { - memcpy(&(ctx->obuf[ctx->obuf_off+ctx->obuf_len]),in,i); - in+=i; - inl-=i; - num+=i; - ctx->obuf_len+=i; - } + { + memcpy(&(ctx->obuf[ctx->obuf_off + ctx->obuf_len]), in, i); + in += i; + inl -= i; + num += i; + ctx->obuf_len += i; + } /* we now have a full buffer needing flushing */ - for (;;) - { - i=BIO_write(b->next_bio,&(ctx->obuf[ctx->obuf_off]), - ctx->obuf_len); - if (i <= 0) - { + for (;;) { + i = BIO_write(b->next_bio, &(ctx->obuf[ctx->obuf_off]), + ctx->obuf_len); + if (i <= 0) { BIO_copy_next_retry(b); - if (i < 0) return((num > 0)?num:i); - if (i == 0) return(num); - } - ctx->obuf_off+=i; - ctx->obuf_len-=i; - if (ctx->obuf_len == 0) break; + if (i < 0) + return ((num > 0) ? num : i); + if (i == 0) + return (num); } + ctx->obuf_off += i; + ctx->obuf_len -= i; + if (ctx->obuf_len == 0) + break; } + } /* we only get here if the buffer has been flushed and we * still have stuff to write */ - ctx->obuf_off=0; + ctx->obuf_off = 0; /* we now have inl bytes to write */ - while (inl >= ctx->obuf_size) - { - i=BIO_write(b->next_bio,in,inl); - if (i <= 0) - { + while (inl >= ctx->obuf_size) { + i = BIO_write(b->next_bio, in, inl); + if (i <= 0) { BIO_copy_next_retry(b); - if (i < 0) return((num > 0)?num:i); - if (i == 0) return(num); - } - num+=i; - in+=i; - inl-=i; - if (inl == 0) return(num); + if (i < 0) + return ((num > 0) ? num : i); + if (i == 0) + return (num); } + num += i; + in += i; + inl -= i; + if (inl == 0) + return (num); + } /* copy the rest into the buffer since we have only a small * amount left */ goto start; - } +} -static long buffer_ctrl(BIO *b, int cmd, long num, void *ptr) - { +static long +buffer_ctrl(BIO *b, int cmd, long num, void *ptr) +{ BIO *dbio; BIO_F_BUFFER_CTX *ctx; - long ret=1; - char *p1,*p2; - int r,i,*ip; - int ibs,obs; + long ret = 1; + char *p1, *p2; + int r, i, *ip; + int ibs, obs; - ctx=(BIO_F_BUFFER_CTX *)b->ptr; + ctx = (BIO_F_BUFFER_CTX *)b->ptr; - switch (cmd) - { + switch (cmd) { case BIO_CTRL_RESET: - ctx->ibuf_off=0; - ctx->ibuf_len=0; - ctx->obuf_off=0; - ctx->obuf_len=0; - if (b->next_bio == NULL) return(0); - ret=BIO_ctrl(b->next_bio,cmd,num,ptr); + ctx->ibuf_off = 0; + ctx->ibuf_len = 0; + ctx->obuf_off = 0; + ctx->obuf_len = 0; + if (b->next_bio == NULL) + return (0); + ret = BIO_ctrl(b->next_bio, cmd, num, ptr); break; case BIO_CTRL_INFO: - ret=(long)ctx->obuf_len; + ret = (long)ctx->obuf_len; break; case BIO_C_GET_BUFF_NUM_LINES: - ret=0; - p1=ctx->ibuf; - for (i=0; iibuf_len; i++) - { - if (p1[ctx->ibuf_off + i] == '\n') ret++; - } + ret = 0; + p1 = ctx->ibuf; + for (i = 0; i < ctx->ibuf_len; i++) { + if (p1[ctx->ibuf_off + i] == '\n') + ret++; + } break; case BIO_CTRL_WPENDING: - ret=(long)ctx->obuf_len; - if (ret == 0) - { - if (b->next_bio == NULL) return(0); - ret=BIO_ctrl(b->next_bio,cmd,num,ptr); - } + ret = (long)ctx->obuf_len; + if (ret == 0) { + if (b->next_bio == NULL) + return (0); + ret = BIO_ctrl(b->next_bio, cmd, num, ptr); + } break; case BIO_CTRL_PENDING: - ret=(long)ctx->ibuf_len; - if (ret == 0) - { - if (b->next_bio == NULL) return(0); - ret=BIO_ctrl(b->next_bio,cmd,num,ptr); - } + ret = (long)ctx->ibuf_len; + if (ret == 0) { + if (b->next_bio == NULL) + return (0); + ret = BIO_ctrl(b->next_bio, cmd, num, ptr); + } break; case BIO_C_SET_BUFF_READ_DATA: - if (num > ctx->ibuf_size) - { - p1=OPENSSL_malloc((int)num); - if (p1 == NULL) goto malloc_error; - if (ctx->ibuf != NULL) OPENSSL_free(ctx->ibuf); - ctx->ibuf=p1; - } - ctx->ibuf_off=0; - ctx->ibuf_len=(int)num; - memcpy(ctx->ibuf,ptr,(int)num); - ret=1; + if (num > ctx->ibuf_size) { + p1 = OPENSSL_malloc((int)num); + if (p1 == NULL) + goto malloc_error; + if (ctx->ibuf != NULL) + OPENSSL_free(ctx->ibuf); + ctx->ibuf = p1; + } + ctx->ibuf_off = 0; + ctx->ibuf_len = (int)num; + memcpy(ctx->ibuf, ptr,(int)num); + ret = 1; break; case BIO_C_SET_BUFF_SIZE: - if (ptr != NULL) - { - ip=(int *)ptr; - if (*ip == 0) - { - ibs=(int)num; - obs=ctx->obuf_size; - } - else /* if (*ip == 1) */ - { - ibs=ctx->ibuf_size; - obs=(int)num; - } - } - else - { - ibs=(int)num; - obs=(int)num; + if (ptr != NULL) { + ip = (int *)ptr; + if (*ip == 0) { + ibs = (int)num; + obs = ctx->obuf_size; } - p1=ctx->ibuf; - p2=ctx->obuf; - if ((ibs > DEFAULT_BUFFER_SIZE) && (ibs != ctx->ibuf_size)) + else /* if (*ip == 1) */ { - p1=(char *)OPENSSL_malloc((int)num); - if (p1 == NULL) goto malloc_error; + ibs = ctx->ibuf_size; + obs = (int)num; } - if ((obs > DEFAULT_BUFFER_SIZE) && (obs != ctx->obuf_size)) - { - p2=(char *)OPENSSL_malloc((int)num); - if (p2 == NULL) - { - if (p1 != ctx->ibuf) OPENSSL_free(p1); + } else { + ibs = (int)num; + obs = (int)num; + } + p1 = ctx->ibuf; + p2 = ctx->obuf; + if ((ibs > DEFAULT_BUFFER_SIZE) && (ibs != ctx->ibuf_size)) { + p1 = (char *)OPENSSL_malloc((int)num); + if (p1 == NULL) + goto malloc_error; + } + if ((obs > DEFAULT_BUFFER_SIZE) && (obs != ctx->obuf_size)) { + p2 = (char *)OPENSSL_malloc((int)num); + if (p2 == NULL) { + if (p1 != ctx->ibuf) + OPENSSL_free(p1); goto malloc_error; - } } - if (ctx->ibuf != p1) - { + } + if (ctx->ibuf != p1) { OPENSSL_free(ctx->ibuf); - ctx->ibuf=p1; - ctx->ibuf_off=0; - ctx->ibuf_len=0; - ctx->ibuf_size=ibs; - } - if (ctx->obuf != p2) - { + ctx->ibuf = p1; + ctx->ibuf_off = 0; + ctx->ibuf_len = 0; + ctx->ibuf_size = ibs; + } + if (ctx->obuf != p2) { OPENSSL_free(ctx->obuf); - ctx->obuf=p2; - ctx->obuf_off=0; - ctx->obuf_len=0; - ctx->obuf_size=obs; - } + ctx->obuf = p2; + ctx->obuf_off = 0; + ctx->obuf_len = 0; + ctx->obuf_size = obs; + } break; case BIO_C_DO_STATE_MACHINE: - if (b->next_bio == NULL) return(0); + if (b->next_bio == NULL) + return (0); BIO_clear_retry_flags(b); - ret=BIO_ctrl(b->next_bio,cmd,num,ptr); + ret = BIO_ctrl(b->next_bio, cmd, num, ptr); BIO_copy_next_retry(b); break; case BIO_CTRL_FLUSH: - if (b->next_bio == NULL) return(0); - if (ctx->obuf_len <= 0) - { - ret=BIO_ctrl(b->next_bio,cmd,num,ptr); + if (b->next_bio == NULL) + return (0); + if (ctx->obuf_len <= 0) { + ret = BIO_ctrl(b->next_bio, cmd, num, ptr); break; - } + } - for (;;) - { + for (;;) { BIO_clear_retry_flags(b); - if (ctx->obuf_len > 0) - { - r=BIO_write(b->next_bio, - &(ctx->obuf[ctx->obuf_off]), - ctx->obuf_len); + if (ctx->obuf_len > 0) { + r = BIO_write(b->next_bio, + &(ctx->obuf[ctx->obuf_off]), + ctx->obuf_len); #if 0 -fprintf(stderr,"FLUSH [%3d] %3d -> %3d\n",ctx->obuf_off,ctx->obuf_len,r); + fprintf(stderr, "FLUSH [%3d] %3d -> %3d\n", ctx->obuf_off, ctx->obuf_len, r); #endif BIO_copy_next_retry(b); - if (r <= 0) return((long)r); - ctx->obuf_off+=r; - ctx->obuf_len-=r; - } - else - { - ctx->obuf_len=0; - ctx->obuf_off=0; - ret=1; + if (r <= 0) + return ((long)r); + ctx->obuf_off += r; + ctx->obuf_len -= r; + } else { + ctx->obuf_len = 0; + ctx->obuf_off = 0; + ret = 1; break; - } } - ret=BIO_ctrl(b->next_bio,cmd,num,ptr); + } + ret = BIO_ctrl(b->next_bio, cmd, num, ptr); break; case BIO_CTRL_DUP: - dbio=(BIO *)ptr; - if ( !BIO_set_read_buffer_size(dbio,ctx->ibuf_size) || - !BIO_set_write_buffer_size(dbio,ctx->obuf_size)) - ret=0; + dbio = (BIO *)ptr; + if (!BIO_set_read_buffer_size(dbio, ctx->ibuf_size) || + !BIO_set_write_buffer_size(dbio, ctx->obuf_size)) + ret = 0; break; default: - if (b->next_bio == NULL) return(0); - ret=BIO_ctrl(b->next_bio,cmd,num,ptr); + if (b->next_bio == NULL) + return (0); + ret = BIO_ctrl(b->next_bio, cmd, num, ptr); break; - } - return(ret); -malloc_error: - BIOerr(BIO_F_BUFFER_CTRL,ERR_R_MALLOC_FAILURE); - return(0); } - -static long buffer_callback_ctrl(BIO *b, int cmd, bio_info_cb *fp) - { - long ret=1; - - if (b->next_bio == NULL) return(0); - switch (cmd) - { + return (ret); +malloc_error: + BIOerr(BIO_F_BUFFER_CTRL, ERR_R_MALLOC_FAILURE); + return (0); +} + +static long +buffer_callback_ctrl(BIO *b, int cmd, bio_info_cb *fp) +{ + long ret = 1; + + if (b->next_bio == NULL) + return (0); + switch (cmd) { default: - ret=BIO_callback_ctrl(b->next_bio,cmd,fp); + ret = BIO_callback_ctrl(b->next_bio, cmd, fp); break; - } - return(ret); } + return (ret); +} -static int buffer_gets(BIO *b, char *buf, int size) - { +static int +buffer_gets(BIO *b, char *buf, int size) +{ BIO_F_BUFFER_CTX *ctx; - int num=0,i,flag; + int num = 0, i, flag; char *p; - ctx=(BIO_F_BUFFER_CTX *)b->ptr; + ctx = (BIO_F_BUFFER_CTX *)b->ptr; size--; /* reserve space for a '\0' */ BIO_clear_retry_flags(b); - for (;;) - { - if (ctx->ibuf_len > 0) - { - p= &(ctx->ibuf[ctx->ibuf_off]); - flag=0; - for (i=0; (iibuf_len) && (iibuf_len > 0) { + p = &(ctx->ibuf[ctx->ibuf_off]); + flag = 0; + for (i = 0; (i < ctx->ibuf_len) && (i < size); i++) { + *(buf++) = p[i]; + if (p[i] == '\n') { + flag = 1; i++; break; - } - } - num+=i; - size-=i; - ctx->ibuf_len-=i; - ctx->ibuf_off+=i; - if (flag || size == 0) - { - *buf='\0'; - return(num); } } + num += i; + size -= i; + ctx->ibuf_len -= i; + ctx->ibuf_off += i; + if (flag || size == 0) { + *buf = '\0'; + return (num); + } + } else /* read another chunk */ - { - i=BIO_read(b->next_bio,ctx->ibuf,ctx->ibuf_size); - if (i <= 0) - { + { + i = BIO_read(b->next_bio, ctx->ibuf, ctx->ibuf_size); + if (i <= 0) { BIO_copy_next_retry(b); - *buf='\0'; - if (i < 0) return((num > 0)?num:i); - if (i == 0) return(num); - } - ctx->ibuf_len=i; - ctx->ibuf_off=0; + *buf = '\0'; + if (i < 0) + return ((num > 0) ? num : i); + if (i == 0) + return (num); } + ctx->ibuf_len = i; + ctx->ibuf_off = 0; } } +} -static int buffer_puts(BIO *b, const char *str) - { - return(buffer_write(b,str,strlen(str))); - } - +static int +buffer_puts(BIO *b, const char *str) +{ + return (buffer_write(b, str, strlen(str))); +} diff --git a/src/lib/libcrypto/bio/bf_lbuf.c b/src/lib/libcrypto/bio/bf_lbuf.c index ec0f7eb0b7..838839f1bf 100644 --- a/src/lib/libcrypto/bio/bf_lbuf.c +++ b/src/lib/libcrypto/bio/bf_lbuf.c @@ -62,7 +62,7 @@ #include #include -static int linebuffer_write(BIO *h, const char *buf,int num); +static int linebuffer_write(BIO *h, const char *buf, int num); static int linebuffer_read(BIO *h, char *buf, int size); static int linebuffer_puts(BIO *h, const char *str); static int linebuffer_gets(BIO *h, char *str, int size); @@ -76,8 +76,7 @@ static long linebuffer_callback_ctrl(BIO *h, int cmd, bio_info_cb *fp); /* #define DEBUG */ -static BIO_METHOD methods_linebuffer= - { +static BIO_METHOD methods_linebuffer = { BIO_TYPE_LINEBUFFER, "linebuffer", linebuffer_write, @@ -88,310 +87,313 @@ static BIO_METHOD methods_linebuffer= linebuffer_new, linebuffer_free, linebuffer_callback_ctrl, - }; +}; -BIO_METHOD *BIO_f_linebuffer(void) - { - return(&methods_linebuffer); - } +BIO_METHOD +*BIO_f_linebuffer(void) +{ + return (&methods_linebuffer); +} -typedef struct bio_linebuffer_ctx_struct - { +typedef struct bio_linebuffer_ctx_struct { char *obuf; /* the output char array */ int obuf_size; /* how big is the output buffer */ int obuf_len; /* how many bytes are in it */ - } BIO_LINEBUFFER_CTX; +} BIO_LINEBUFFER_CTX; -static int linebuffer_new(BIO *bi) - { +static int +linebuffer_new(BIO *bi) +{ BIO_LINEBUFFER_CTX *ctx; - ctx=(BIO_LINEBUFFER_CTX *)OPENSSL_malloc(sizeof(BIO_LINEBUFFER_CTX)); - if (ctx == NULL) return(0); - ctx->obuf=(char *)OPENSSL_malloc(DEFAULT_LINEBUFFER_SIZE); - if (ctx->obuf == NULL) { OPENSSL_free(ctx); return(0); } - ctx->obuf_size=DEFAULT_LINEBUFFER_SIZE; - ctx->obuf_len=0; - - bi->init=1; - bi->ptr=(char *)ctx; - bi->flags=0; - return(1); + ctx = (BIO_LINEBUFFER_CTX *)OPENSSL_malloc(sizeof(BIO_LINEBUFFER_CTX)); + if (ctx == NULL) + return (0); + ctx->obuf = (char *)OPENSSL_malloc(DEFAULT_LINEBUFFER_SIZE); + if (ctx->obuf == NULL) { + OPENSSL_free(ctx); + return (0); } + ctx->obuf_size = DEFAULT_LINEBUFFER_SIZE; + ctx->obuf_len = 0; + + bi->init = 1; + bi->ptr = (char *)ctx; + bi->flags = 0; + return (1); +} -static int linebuffer_free(BIO *a) - { +static int +linebuffer_free(BIO *a) +{ BIO_LINEBUFFER_CTX *b; - if (a == NULL) return(0); - b=(BIO_LINEBUFFER_CTX *)a->ptr; - if (b->obuf != NULL) OPENSSL_free(b->obuf); + if (a == NULL) + return (0); + b = (BIO_LINEBUFFER_CTX *)a->ptr; + if (b->obuf != NULL) + OPENSSL_free(b->obuf); OPENSSL_free(a->ptr); - a->ptr=NULL; - a->init=0; - a->flags=0; - return(1); - } - -static int linebuffer_read(BIO *b, char *out, int outl) - { - int ret=0; - - if (out == NULL) return(0); - if (b->next_bio == NULL) return(0); - ret=BIO_read(b->next_bio,out,outl); + a->ptr = NULL; + a->init = 0; + a->flags = 0; + return (1); +} + +static int +linebuffer_read(BIO *b, char *out, int outl) +{ + int ret = 0; + + if (out == NULL) + return (0); + if (b->next_bio == NULL) + return (0); + ret = BIO_read(b->next_bio, out, outl); BIO_clear_retry_flags(b); BIO_copy_next_retry(b); - return(ret); - } + return (ret); +} -static int linebuffer_write(BIO *b, const char *in, int inl) - { - int i,num=0,foundnl; +static int +linebuffer_write(BIO *b, const char *in, int inl) +{ + int i, num = 0, foundnl; BIO_LINEBUFFER_CTX *ctx; - if ((in == NULL) || (inl <= 0)) return(0); - ctx=(BIO_LINEBUFFER_CTX *)b->ptr; - if ((ctx == NULL) || (b->next_bio == NULL)) return(0); + if ((in == NULL) || (inl <= 0)) + return (0); + ctx = (BIO_LINEBUFFER_CTX *)b->ptr; + if ((ctx == NULL) || (b->next_bio == NULL)) + return (0); BIO_clear_retry_flags(b); - do - { + do { const char *p; - for(p = in; p < in + inl && *p != '\n'; p++) + for (p = in; p < in + inl && *p != '\n'; p++) ; - if (*p == '\n') - { + if (*p == '\n') { p++; foundnl = 1; - } - else + } else foundnl = 0; /* If a NL was found and we already have text in the save buffer, concatenate them and write */ - while ((foundnl || p - in > ctx->obuf_size - ctx->obuf_len) - && ctx->obuf_len > 0) - { + while ((foundnl || p - in > ctx->obuf_size - ctx->obuf_len) && + ctx->obuf_len > 0) { int orig_olen = ctx->obuf_len; - + i = ctx->obuf_size - ctx->obuf_len; - if (p - in > 0) - { - if (i >= p - in) - { + if (p - in > 0) { + if (i >= p - in) { memcpy(&(ctx->obuf[ctx->obuf_len]), - in,p - in); + in, p - in); ctx->obuf_len += p - in; inl -= p - in; num += p - in; in = p; - } - else - { + } else { memcpy(&(ctx->obuf[ctx->obuf_len]), - in,i); + in, i); ctx->obuf_len += i; inl -= i; in += i; num += i; - } } + } #if 0 -BIO_write(b->next_bio, "<*<", 3); + BIO_write(b->next_bio, "<*<", 3); #endif - i=BIO_write(b->next_bio, - ctx->obuf, ctx->obuf_len); - if (i <= 0) - { + i = BIO_write(b->next_bio, ctx->obuf, ctx->obuf_len); + if (i <= 0) { ctx->obuf_len = orig_olen; BIO_copy_next_retry(b); - #if 0 -BIO_write(b->next_bio, ">*>", 3); + BIO_write(b->next_bio, ">*>", 3); #endif - if (i < 0) return((num > 0)?num:i); - if (i == 0) return(num); - } + if (i < 0) + return ((num > 0) ? num : i); + if (i == 0) + return (num); + } #if 0 -BIO_write(b->next_bio, ">*>", 3); + BIO_write(b->next_bio, ">*>", 3); #endif if (i < ctx->obuf_len) memmove(ctx->obuf, ctx->obuf + i, - ctx->obuf_len - i); - ctx->obuf_len-=i; - } + ctx->obuf_len - i); + ctx->obuf_len -= i; + } /* Now that the save buffer is emptied, let's write the input buffer if a NL was found and there is anything to write. */ - if ((foundnl || p - in > ctx->obuf_size) && p - in > 0) - { + if ((foundnl || p - in > ctx->obuf_size) && p - in > 0) { #if 0 -BIO_write(b->next_bio, "<*<", 3); + BIO_write(b->next_bio, "<*<", 3); #endif - i=BIO_write(b->next_bio,in,p - in); - if (i <= 0) - { + i = BIO_write(b->next_bio, in, p - in); + if (i <= 0) { BIO_copy_next_retry(b); #if 0 -BIO_write(b->next_bio, ">*>", 3); + BIO_write(b->next_bio, ">*>", 3); #endif - if (i < 0) return((num > 0)?num:i); - if (i == 0) return(num); - } + if (i < 0) + return ((num > 0) ? num : i); + if (i == 0) + return (num); + } #if 0 -BIO_write(b->next_bio, ">*>", 3); + BIO_write(b->next_bio, ">*>", 3); #endif - num+=i; - in+=i; - inl-=i; - } + num += i; + in += i; + inl -= i; } - while(foundnl && inl > 0); + } while (foundnl && inl > 0); /* We've written as much as we can. The rest of the input buffer, if any, is text that doesn't and with a NL and therefore needs to be saved for the next trip. */ - if (inl > 0) - { + if (inl > 0) { memcpy(&(ctx->obuf[ctx->obuf_len]), in, inl); ctx->obuf_len += inl; num += inl; - } - return num; } + return num; +} -static long linebuffer_ctrl(BIO *b, int cmd, long num, void *ptr) - { +static long +linebuffer_ctrl(BIO *b, int cmd, long num, void *ptr) +{ BIO *dbio; BIO_LINEBUFFER_CTX *ctx; - long ret=1; + long ret = 1; char *p; int r; int obs; - ctx=(BIO_LINEBUFFER_CTX *)b->ptr; + ctx = (BIO_LINEBUFFER_CTX *)b->ptr; - switch (cmd) - { + switch (cmd) { case BIO_CTRL_RESET: - ctx->obuf_len=0; - if (b->next_bio == NULL) return(0); - ret=BIO_ctrl(b->next_bio,cmd,num,ptr); + ctx->obuf_len = 0; + if (b->next_bio == NULL) + return (0); + ret = BIO_ctrl(b->next_bio, cmd, num, ptr); break; case BIO_CTRL_INFO: - ret=(long)ctx->obuf_len; + ret = (long)ctx->obuf_len; break; case BIO_CTRL_WPENDING: - ret=(long)ctx->obuf_len; - if (ret == 0) - { - if (b->next_bio == NULL) return(0); - ret=BIO_ctrl(b->next_bio,cmd,num,ptr); - } + ret = (long)ctx->obuf_len; + if (ret == 0) { + if (b->next_bio == NULL) + return (0); + ret = BIO_ctrl(b->next_bio, cmd, num, ptr); + } break; case BIO_C_SET_BUFF_SIZE: - obs=(int)num; - p=ctx->obuf; - if ((obs > DEFAULT_LINEBUFFER_SIZE) && (obs != ctx->obuf_size)) - { - p=(char *)OPENSSL_malloc((int)num); + obs = (int)num; + p = ctx->obuf; + if ((obs > DEFAULT_LINEBUFFER_SIZE) && (obs != ctx->obuf_size)) { + p = (char *)OPENSSL_malloc((int)num); if (p == NULL) goto malloc_error; - } - if (ctx->obuf != p) - { - if (ctx->obuf_len > obs) - { + } + if (ctx->obuf != p) { + if (ctx->obuf_len > obs) { ctx->obuf_len = obs; - } + } memcpy(p, ctx->obuf, ctx->obuf_len); OPENSSL_free(ctx->obuf); - ctx->obuf=p; - ctx->obuf_size=obs; - } + ctx->obuf = p; + ctx->obuf_size = obs; + } break; case BIO_C_DO_STATE_MACHINE: - if (b->next_bio == NULL) return(0); + if (b->next_bio == NULL) + return (0); BIO_clear_retry_flags(b); - ret=BIO_ctrl(b->next_bio,cmd,num,ptr); + ret = BIO_ctrl(b->next_bio, cmd, num, ptr); BIO_copy_next_retry(b); break; case BIO_CTRL_FLUSH: - if (b->next_bio == NULL) return(0); - if (ctx->obuf_len <= 0) - { - ret=BIO_ctrl(b->next_bio,cmd,num,ptr); + if (b->next_bio == NULL) + return (0); + if (ctx->obuf_len <= 0) { + ret = BIO_ctrl(b->next_bio, cmd, num, ptr); break; - } + } - for (;;) - { + for (;;) { BIO_clear_retry_flags(b); - if (ctx->obuf_len > 0) - { - r=BIO_write(b->next_bio, - ctx->obuf, ctx->obuf_len); + if (ctx->obuf_len > 0) { + r = BIO_write(b->next_bio, + ctx->obuf, ctx->obuf_len); #if 0 -fprintf(stderr,"FLUSH %3d -> %3d\n",ctx->obuf_len,r); + fprintf(stderr, "FLUSH %3d -> %3d\n", ctx->obuf_len, r); #endif BIO_copy_next_retry(b); - if (r <= 0) return((long)r); + if (r <= 0) + return ((long)r); if (r < ctx->obuf_len) memmove(ctx->obuf, ctx->obuf + r, - ctx->obuf_len - r); - ctx->obuf_len-=r; - } - else - { - ctx->obuf_len=0; - ret=1; + ctx->obuf_len - r); + ctx->obuf_len -= r; + } else { + ctx->obuf_len = 0; + ret = 1; break; - } } - ret=BIO_ctrl(b->next_bio,cmd,num,ptr); + } + ret = BIO_ctrl(b->next_bio, cmd, num, ptr); break; case BIO_CTRL_DUP: - dbio=(BIO *)ptr; - if ( !BIO_set_write_buffer_size(dbio,ctx->obuf_size)) - ret=0; + dbio = (BIO *)ptr; + if (!BIO_set_write_buffer_size(dbio, ctx->obuf_size)) + ret = 0; break; default: - if (b->next_bio == NULL) return(0); - ret=BIO_ctrl(b->next_bio,cmd,num,ptr); + if (b->next_bio == NULL) + return (0); + ret = BIO_ctrl(b->next_bio, cmd, num, ptr); break; - } - return(ret); -malloc_error: - BIOerr(BIO_F_LINEBUFFER_CTRL,ERR_R_MALLOC_FAILURE); - return(0); } + return (ret); +malloc_error: + BIOerr(BIO_F_LINEBUFFER_CTRL, ERR_R_MALLOC_FAILURE); + return (0); +} -static long linebuffer_callback_ctrl(BIO *b, int cmd, bio_info_cb *fp) - { - long ret=1; +static long +linebuffer_callback_ctrl(BIO *b, int cmd, bio_info_cb *fp) +{ + long ret = 1; - if (b->next_bio == NULL) return(0); - switch (cmd) - { + if (b->next_bio == NULL) + return (0); + switch (cmd) { default: - ret=BIO_callback_ctrl(b->next_bio,cmd,fp); + ret = BIO_callback_ctrl(b->next_bio, cmd, fp); break; - } - return(ret); } + return (ret); +} -static int linebuffer_gets(BIO *b, char *buf, int size) - { - if (b->next_bio == NULL) return(0); - return(BIO_gets(b->next_bio,buf,size)); - } - -static int linebuffer_puts(BIO *b, const char *str) - { - return(linebuffer_write(b,str,strlen(str))); - } +static int +linebuffer_gets(BIO *b, char *buf, int size) +{ + if (b->next_bio == NULL) + return (0); + return (BIO_gets(b->next_bio, buf, size)); +} +static int +linebuffer_puts(BIO *b, const char *str) +{ + return (linebuffer_write(b, str, strlen(str))); +} diff --git a/src/lib/libcrypto/bio/bf_nbio.c b/src/lib/libcrypto/bio/bf_nbio.c index 028616c064..76f8f31950 100644 --- a/src/lib/libcrypto/bio/bf_nbio.c +++ b/src/lib/libcrypto/bio/bf_nbio.c @@ -65,23 +65,22 @@ /* BIO_put and BIO_get both add to the digest, * BIO_gets returns the digest */ -static int nbiof_write(BIO *h,const char *buf,int num); -static int nbiof_read(BIO *h,char *buf,int size); -static int nbiof_puts(BIO *h,const char *str); -static int nbiof_gets(BIO *h,char *str,int size); -static long nbiof_ctrl(BIO *h,int cmd,long arg1,void *arg2); +static int nbiof_write(BIO *h, const char *buf, int num); +static int nbiof_read(BIO *h, char *buf, int size); +static int nbiof_puts(BIO *h, const char *str); +static int nbiof_gets(BIO *h, char *str, int size); +static long nbiof_ctrl(BIO *h, int cmd, long arg1, void *arg2); static int nbiof_new(BIO *h); static int nbiof_free(BIO *data); -static long nbiof_callback_ctrl(BIO *h,int cmd,bio_info_cb *fp); -typedef struct nbio_test_st - { +static long nbiof_callback_ctrl(BIO *h, int cmd, bio_info_cb *fp); + +typedef struct nbio_test_st { /* only set if we sent a 'should retry' error */ int lrn; int lwn; - } NBIO_TEST; +} NBIO_TEST; -static BIO_METHOD methods_nbiof= - { +static BIO_METHOD methods_nbiof = { BIO_TYPE_NBIO_TEST, "non-blocking IO test filter", nbiof_write, @@ -92,162 +91,170 @@ static BIO_METHOD methods_nbiof= nbiof_new, nbiof_free, nbiof_callback_ctrl, - }; +}; -BIO_METHOD *BIO_f_nbio_test(void) - { - return(&methods_nbiof); - } +BIO_METHOD +*BIO_f_nbio_test(void) +{ + return (&methods_nbiof); +} -static int nbiof_new(BIO *bi) - { +static int +nbiof_new(BIO *bi) +{ NBIO_TEST *nt; - if (!(nt=(NBIO_TEST *)OPENSSL_malloc(sizeof(NBIO_TEST)))) return(0); - nt->lrn= -1; - nt->lwn= -1; - bi->ptr=(char *)nt; - bi->init=1; - bi->flags=0; - return(1); - } + if (!(nt = (NBIO_TEST *)OPENSSL_malloc(sizeof(NBIO_TEST)))) + return (0); + nt->lrn = -1; + nt->lwn = -1; + bi->ptr = (char *)nt; + bi->init = 1; + bi->flags = 0; + return (1); +} -static int nbiof_free(BIO *a) - { - if (a == NULL) return(0); +static int +nbiof_free(BIO *a) +{ + if (a == NULL) + return (0); if (a->ptr != NULL) OPENSSL_free(a->ptr); - a->ptr=NULL; - a->init=0; - a->flags=0; - return(1); - } - -static int nbiof_read(BIO *b, char *out, int outl) - { - int ret=0; + a->ptr = NULL; + a->init = 0; + a->flags = 0; + return (1); +} + +static int +nbiof_read(BIO *b, char *out, int outl) +{ + int ret = 0; #if 1 int num; unsigned char n; #endif - if (out == NULL) return(0); - if (b->next_bio == NULL) return(0); + if (out == NULL) + return (0); + if (b->next_bio == NULL) + return (0); BIO_clear_retry_flags(b); #if 1 - RAND_pseudo_bytes(&n,1); - num=(n&0x07); + RAND_pseudo_bytes(&n, 1); + num = (n & 0x07); - if (outl > num) outl=num; + if (outl > num) + outl = num; - if (num == 0) - { - ret= -1; + if (num == 0) { + ret = -1; BIO_set_retry_read(b); - } - else + } else #endif - { - ret=BIO_read(b->next_bio,out,outl); + { + ret = BIO_read(b->next_bio, out, outl); if (ret < 0) BIO_copy_next_retry(b); - } - return(ret); } + return (ret); +} -static int nbiof_write(BIO *b, const char *in, int inl) - { +static int +nbiof_write(BIO *b, const char *in, int inl) +{ NBIO_TEST *nt; - int ret=0; + int ret = 0; int num; unsigned char n; - if ((in == NULL) || (inl <= 0)) return(0); - if (b->next_bio == NULL) return(0); - nt=(NBIO_TEST *)b->ptr; + if ((in == NULL) || (inl <= 0)) + return (0); + if (b->next_bio == NULL) + return (0); + nt = (NBIO_TEST *)b->ptr; BIO_clear_retry_flags(b); #if 1 - if (nt->lwn > 0) - { - num=nt->lwn; - nt->lwn=0; - } - else - { - RAND_pseudo_bytes(&n,1); - num=(n&7); - } + if (nt->lwn > 0) { + num = nt->lwn; + nt->lwn = 0; + } else { + RAND_pseudo_bytes(&n, 1); + num = (n&7); + } - if (inl > num) inl=num; + if (inl > num) + inl = num; - if (num == 0) - { - ret= -1; + if (num == 0) { + ret = -1; BIO_set_retry_write(b); - } - else + } else #endif - { - ret=BIO_write(b->next_bio,in,inl); - if (ret < 0) - { + { + ret = BIO_write(b->next_bio, in, inl); + if (ret < 0) { BIO_copy_next_retry(b); - nt->lwn=inl; - } + nt->lwn = inl; } - return(ret); } + return (ret); +} -static long nbiof_ctrl(BIO *b, int cmd, long num, void *ptr) - { +static long +nbiof_ctrl(BIO *b, int cmd, long num, void *ptr) +{ long ret; - if (b->next_bio == NULL) return(0); - switch (cmd) - { - case BIO_C_DO_STATE_MACHINE: + if (b->next_bio == NULL) + return (0); + switch (cmd) { + case BIO_C_DO_STATE_MACHINE: BIO_clear_retry_flags(b); - ret=BIO_ctrl(b->next_bio,cmd,num,ptr); + ret = BIO_ctrl(b->next_bio, cmd, num, ptr); BIO_copy_next_retry(b); break; case BIO_CTRL_DUP: - ret=0L; + ret = 0L; break; default: - ret=BIO_ctrl(b->next_bio,cmd,num,ptr); + ret = BIO_ctrl(b->next_bio, cmd, num, ptr); break; - } - return(ret); } + return (ret); +} -static long nbiof_callback_ctrl(BIO *b, int cmd, bio_info_cb *fp) - { - long ret=1; +static long +nbiof_callback_ctrl(BIO *b, int cmd, bio_info_cb *fp) +{ + long ret = 1; - if (b->next_bio == NULL) return(0); - switch (cmd) - { + if (b->next_bio == NULL) + return (0); + switch (cmd) { default: - ret=BIO_callback_ctrl(b->next_bio,cmd,fp); + ret = BIO_callback_ctrl(b->next_bio, cmd, fp); break; - } - return(ret); - } - -static int nbiof_gets(BIO *bp, char *buf, int size) - { - if (bp->next_bio == NULL) return(0); - return(BIO_gets(bp->next_bio,buf,size)); - } - - -static int nbiof_puts(BIO *bp, const char *str) - { - if (bp->next_bio == NULL) return(0); - return(BIO_puts(bp->next_bio,str)); } + return (ret); +} +static int +nbiof_gets(BIO *bp, char *buf, int size) +{ + if (bp->next_bio == NULL) + return (0); + return (BIO_gets(bp->next_bio, buf, size)); +} +static int +nbiof_puts(BIO *bp, const char *str) +{ + if (bp->next_bio == NULL) + return (0); + return (BIO_puts(bp->next_bio, str)); +} diff --git a/src/lib/libcrypto/bio/bf_null.c b/src/lib/libcrypto/bio/bf_null.c index c1bf39a904..354731c0c7 100644 --- a/src/lib/libcrypto/bio/bf_null.c +++ b/src/lib/libcrypto/bio/bf_null.c @@ -72,8 +72,8 @@ static long nullf_ctrl(BIO *h, int cmd, long arg1, void *arg2); static int nullf_new(BIO *h); static int nullf_free(BIO *data); static long nullf_callback_ctrl(BIO *h, int cmd, bio_info_cb *fp); -static BIO_METHOD methods_nullf= - { + +static BIO_METHOD methods_nullf = { BIO_TYPE_NULL_FILTER, "NULL filter", nullf_write, @@ -84,100 +84,113 @@ static BIO_METHOD methods_nullf= nullf_new, nullf_free, nullf_callback_ctrl, - }; - -BIO_METHOD *BIO_f_null(void) - { - return(&methods_nullf); - } - -static int nullf_new(BIO *bi) - { - bi->init=1; - bi->ptr=NULL; - bi->flags=0; - return(1); - } - -static int nullf_free(BIO *a) - { - if (a == NULL) return(0); +}; + +BIO_METHOD +*BIO_f_null(void) +{ + return (&methods_nullf); +} + +static int +nullf_new(BIO *bi) +{ + bi->init = 1; + bi->ptr = NULL; + bi->flags = 0; + return (1); +} + +static int +nullf_free(BIO *a) +{ + if (a == NULL) + return (0); /* a->ptr=NULL; a->init=0; a->flags=0;*/ - return(1); - } - -static int nullf_read(BIO *b, char *out, int outl) - { - int ret=0; - - if (out == NULL) return(0); - if (b->next_bio == NULL) return(0); - ret=BIO_read(b->next_bio,out,outl); + return (1); +} + +static int +nullf_read(BIO *b, char *out, int outl) +{ + int ret = 0; + + if (out == NULL) + return (0); + if (b->next_bio == NULL) + return (0); + ret = BIO_read(b->next_bio, out, outl); BIO_clear_retry_flags(b); BIO_copy_next_retry(b); - return(ret); - } - -static int nullf_write(BIO *b, const char *in, int inl) - { - int ret=0; - - if ((in == NULL) || (inl <= 0)) return(0); - if (b->next_bio == NULL) return(0); - ret=BIO_write(b->next_bio,in,inl); + return (ret); +} + +static int +nullf_write(BIO *b, const char *in, int inl) +{ + int ret = 0; + + if ((in == NULL) || (inl <= 0)) + return (0); + if (b->next_bio == NULL) + return (0); + ret = BIO_write(b->next_bio, in, inl); BIO_clear_retry_flags(b); BIO_copy_next_retry(b); - return(ret); - } + return (ret); +} -static long nullf_ctrl(BIO *b, int cmd, long num, void *ptr) - { +static long +nullf_ctrl(BIO *b, int cmd, long num, void *ptr) +{ long ret; - if (b->next_bio == NULL) return(0); - switch(cmd) - { - case BIO_C_DO_STATE_MACHINE: + if (b->next_bio == NULL) + return (0); + switch (cmd) { + case BIO_C_DO_STATE_MACHINE: BIO_clear_retry_flags(b); - ret=BIO_ctrl(b->next_bio,cmd,num,ptr); + ret = BIO_ctrl(b->next_bio, cmd, num, ptr); BIO_copy_next_retry(b); break; case BIO_CTRL_DUP: - ret=0L; + ret = 0L; break; default: - ret=BIO_ctrl(b->next_bio,cmd,num,ptr); - } - return(ret); + ret = BIO_ctrl(b->next_bio, cmd, num, ptr); } + return (ret); +} -static long nullf_callback_ctrl(BIO *b, int cmd, bio_info_cb *fp) - { - long ret=1; +static long +nullf_callback_ctrl(BIO *b, int cmd, bio_info_cb *fp) +{ + long ret = 1; - if (b->next_bio == NULL) return(0); - switch (cmd) - { + if (b->next_bio == NULL) + return (0); + switch (cmd) { default: - ret=BIO_callback_ctrl(b->next_bio,cmd,fp); + ret = BIO_callback_ctrl(b->next_bio, cmd, fp); break; - } - return(ret); } - -static int nullf_gets(BIO *bp, char *buf, int size) - { - if (bp->next_bio == NULL) return(0); - return(BIO_gets(bp->next_bio,buf,size)); - } - - -static int nullf_puts(BIO *bp, const char *str) - { - if (bp->next_bio == NULL) return(0); - return(BIO_puts(bp->next_bio,str)); - } - - + return (ret); +} + +static int +nullf_gets(BIO *bp, char *buf, int size) +{ + if (bp->next_bio == NULL) + return (0); + return (BIO_gets(bp->next_bio, buf, size)); +} + +static int +nullf_puts(BIO *bp, const char *str) +{ + if (bp->next_bio == NULL) + return (0); + return (BIO_puts(bp->next_bio, str)); +} diff --git a/src/lib/libcrypto/bio/bio.h b/src/lib/libcrypto/bio/bio.h index 05699ab212..4f1d02ada5 100644 --- a/src/lib/libcrypto/bio/bio.h +++ b/src/lib/libcrypto/bio/bio.h @@ -151,7 +151,7 @@ extern "C" { #define BIO_CTRL_DGRAM_GET_RECV_TIMER_EXP 37 /* flag whether the last */ #define BIO_CTRL_DGRAM_GET_SEND_TIMER_EXP 38 /* I/O operation tiemd out */ - + /* #ifdef IP_MTU_DISCOVER */ #define BIO_CTRL_DGRAM_MTU_DISCOVER 39 /* set DF bit on egress packets */ /* #endif */ @@ -282,9 +282,10 @@ void BIO_clear_flags(BIO *b, int flags); #define BIO_cb_pre(a) (!((a)&BIO_CB_RETURN)) #define BIO_cb_post(a) ((a)&BIO_CB_RETURN) -long (*BIO_get_callback(const BIO *b)) (struct bio_st *,int,const char *,int, long,long); -void BIO_set_callback(BIO *b, - long (*callback)(struct bio_st *,int,const char *,int, long,long)); +long (*BIO_get_callback(const BIO *b))(struct bio_st *, int, const char *, + int, long, long); +void BIO_set_callback(BIO *b, + long (*callback)(struct bio_st *, int, const char *, int, long, long)); char *BIO_get_callback_arg(const BIO *b); void BIO_set_callback_arg(BIO *b, char *arg); @@ -293,8 +294,7 @@ int BIO_method_type(const BIO *b); typedef void bio_info_cb(struct bio_st *, int, const char *, int, long, long); -typedef struct bio_method_st - { +typedef struct bio_method_st { int type; const char *name; int (*bwrite)(BIO *, const char *, int); @@ -304,14 +304,13 @@ typedef struct bio_method_st long (*ctrl)(BIO *, int, long, void *); int (*create)(BIO *); int (*destroy)(BIO *); - long (*callback_ctrl)(BIO *, int, bio_info_cb *); - } BIO_METHOD; + long (*callback_ctrl)(BIO *, int, bio_info_cb *); +} BIO_METHOD; -struct bio_st - { +struct bio_st { BIO_METHOD *method; /* bio, mode, argp, argi, argl, ret */ - long (*callback)(struct bio_st *,int,const char *,int, long,long); + long (*callback)(struct bio_st *, int, const char *, int, long, long); char *cb_arg; /* first argument for the callback */ int init; @@ -327,12 +326,11 @@ struct bio_st unsigned long num_write; CRYPTO_EX_DATA ex_data; - }; +}; DECLARE_STACK_OF(BIO) -typedef struct bio_f_buffer_ctx_struct - { +typedef struct bio_f_buffer_ctx_struct { /* Buffers are setup like this: * * <---------------------- size -----------------------> @@ -346,30 +344,28 @@ typedef struct bio_f_buffer_ctx_struct int ibuf_size; /* how big is the input buffer */ int obuf_size; /* how big is the output buffer */ - char *ibuf; /* the char array */ - int ibuf_len; /* how many bytes are in it */ - int ibuf_off; /* write/read offset */ + char *ibuf; /* the char array */ + int ibuf_len; /* how many bytes are in it */ + int ibuf_off; /* write/read offset */ - char *obuf; /* the char array */ - int obuf_len; /* how many bytes are in it */ - int obuf_off; /* write/read offset */ - } BIO_F_BUFFER_CTX; + char *obuf; /* the char array */ + int obuf_len; /* how many bytes are in it */ + int obuf_off; /* write/read offset */ +} BIO_F_BUFFER_CTX; /* Prefix and suffix callback in ASN1 BIO */ typedef int asn1_ps_func(BIO *b, unsigned char **pbuf, int *plen, void *parg); #ifndef OPENSSL_NO_SCTP /* SCTP parameter structs */ -struct bio_dgram_sctp_sndinfo - { +struct bio_dgram_sctp_sndinfo { uint16_t snd_sid; uint16_t snd_flags; uint32_t snd_ppid; uint32_t snd_context; - }; +}; -struct bio_dgram_sctp_rcvinfo - { +struct bio_dgram_sctp_rcvinfo { uint16_t rcv_sid; uint16_t rcv_ssn; uint16_t rcv_flags; @@ -377,13 +373,12 @@ struct bio_dgram_sctp_rcvinfo uint32_t rcv_tsn; uint32_t rcv_cumtsn; uint32_t rcv_context; - }; +}; -struct bio_dgram_sctp_prinfo - { +struct bio_dgram_sctp_prinfo { uint16_t pr_policy; uint32_t pr_value; - }; +}; #endif /* connect BIO stuff */ @@ -519,7 +514,7 @@ struct bio_dgram_sctp_prinfo /* If you are wondering why this isn't defined, its because CONST_STRICT is * purely a compile-time kludge to allow const to be checked. */ -int BIO_read_filename(BIO *b,const char *name); +int BIO_read_filename(BIO *b, const char *name); #else #define BIO_read_filename(b,name) BIO_ctrl(b,BIO_C_SET_FILENAME, \ BIO_CLOSE|BIO_FP_READ,(char *)name) @@ -611,22 +606,27 @@ int BIO_ctrl_reset_read_request(BIO *b); /* These two aren't currently implemented */ /* int BIO_get_ex_num(BIO *bio); */ /* void BIO_set_ex_free_func(BIO *bio,int idx,void (*cb)()); */ -int BIO_set_ex_data(BIO *bio,int idx,void *data); -void *BIO_get_ex_data(BIO *bio,int idx); -int BIO_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func, - CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func); +int BIO_set_ex_data(BIO *bio, int idx, void *data); +void *BIO_get_ex_data(BIO *bio, int idx); +int +BIO_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func, +CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func); unsigned long BIO_number_read(BIO *bio); unsigned long BIO_number_written(BIO *bio); /* For BIO_f_asn1() */ -int BIO_asn1_set_prefix(BIO *b, asn1_ps_func *prefix, - asn1_ps_func *prefix_free); -int BIO_asn1_get_prefix(BIO *b, asn1_ps_func **pprefix, - asn1_ps_func **pprefix_free); -int BIO_asn1_set_suffix(BIO *b, asn1_ps_func *suffix, - asn1_ps_func *suffix_free); -int BIO_asn1_get_suffix(BIO *b, asn1_ps_func **psuffix, - asn1_ps_func **psuffix_free); +int +BIO_asn1_set_prefix(BIO *b, asn1_ps_func *prefix, +asn1_ps_func *prefix_free); +int +BIO_asn1_get_prefix(BIO *b, asn1_ps_func **pprefix, +asn1_ps_func **pprefix_free); +int +BIO_asn1_set_suffix(BIO *b, asn1_ps_func *suffix, +asn1_ps_func *suffix_free); +int +BIO_asn1_get_suffix(BIO *b, asn1_ps_func **psuffix, +asn1_ps_func **psuffix_free); # ifndef OPENSSL_NO_FP_API BIO_METHOD *BIO_s_file(void ); @@ -635,22 +635,23 @@ BIO *BIO_new_fp(FILE *stream, int close_flag); # define BIO_s_file_internal BIO_s_file # endif BIO * BIO_new(BIO_METHOD *type); -int BIO_set(BIO *a,BIO_METHOD *type); +int BIO_set(BIO *a, BIO_METHOD *type); int BIO_free(BIO *a); void BIO_vfree(BIO *a); int BIO_read(BIO *b, void *data, int len); -int BIO_gets(BIO *bp,char *buf, int size); +int BIO_gets(BIO *bp, char *buf, int size); int BIO_write(BIO *b, const void *data, int len); -int BIO_puts(BIO *bp,const char *buf); -int BIO_indent(BIO *b,int indent,int max); -long BIO_ctrl(BIO *bp,int cmd,long larg,void *parg); -long BIO_callback_ctrl(BIO *b, int cmd, void (*fp)(struct bio_st *, int, const char *, int, long, long)); -char * BIO_ptr_ctrl(BIO *bp,int cmd,long larg); -long BIO_int_ctrl(BIO *bp,int cmd,long larg,int iarg); -BIO * BIO_push(BIO *b,BIO *append); +int BIO_puts(BIO *bp, const char *buf); +int BIO_indent(BIO *b, int indent, int max); +long BIO_ctrl(BIO *bp, int cmd, long larg, void *parg); +long BIO_callback_ctrl(BIO *b, int cmd, + void (*fp)(struct bio_st *, int, const char *, int, long, long)); +char * BIO_ptr_ctrl(BIO *bp, int cmd, long larg); +long BIO_int_ctrl(BIO *bp, int cmd, long larg, int iarg); +BIO * BIO_push(BIO *b, BIO *append); BIO * BIO_pop(BIO *b); void BIO_free_all(BIO *a); -BIO * BIO_find_type(BIO *b,int bio_type); +BIO * BIO_find_type(BIO *b, int bio_type); BIO * BIO_next(BIO *b); BIO * BIO_get_retry_BIO(BIO *bio, int *reason); int BIO_get_retry_reason(BIO *bio); @@ -661,8 +662,8 @@ int BIO_nread(BIO *bio, char **buf, int num); int BIO_nwrite0(BIO *bio, char **buf); int BIO_nwrite(BIO *bio, char **buf, int num); -long BIO_debug_callback(BIO *bio,int cmd,const char *argp,int argi, - long argl,long ret); +long BIO_debug_callback(BIO *bio, int cmd, const char *argp, int argi, + long argl, long ret); BIO_METHOD *BIO_s_mem(void); BIO *BIO_new_mem_buf(void *buf, int len); @@ -696,12 +697,14 @@ int BIO_dgram_non_fatal_error(int error); int BIO_fd_should_retry(int i); int BIO_fd_non_fatal_error(int error); -int BIO_dump_cb(int (*cb)(const void *data, size_t len, void *u), - void *u, const char *s, int len); -int BIO_dump_indent_cb(int (*cb)(const void *data, size_t len, void *u), - void *u, const char *s, int len, int indent); -int BIO_dump(BIO *b,const char *bytes,int len); -int BIO_dump_indent(BIO *b,const char *bytes,int len,int indent); +int +BIO_dump_cb(int (*cb)(const void *data, size_t len, void *u), +void *u, const char *s, int len); +int +BIO_dump_indent_cb(int (*cb)(const void *data, size_t len, void *u), +void *u, const char *s, int len, int indent); +int BIO_dump(BIO *b, const char *bytes, int len); +int BIO_dump_indent(BIO *b, const char *bytes, int len, int indent); #ifndef OPENSSL_NO_FP_API int BIO_dump_fp(FILE *fp, const char *s, int len); int BIO_dump_indent_fp(FILE *fp, const char *s, int len, int indent); @@ -717,23 +720,24 @@ struct hostent *BIO_gethostbyname(const char *name); */ int BIO_sock_error(int sock); int BIO_socket_ioctl(int fd, long type, void *arg); -int BIO_socket_nbio(int fd,int mode); +int BIO_socket_nbio(int fd, int mode); int BIO_get_port(const char *str, unsigned short *port_ptr); int BIO_get_host_ip(const char *str, unsigned char *ip); -int BIO_get_accept_socket(char *host_port,int mode); -int BIO_accept(int sock,char **ip_port); +int BIO_get_accept_socket(char *host_port, int mode); +int BIO_accept(int sock, char **ip_port); int BIO_sock_init(void ); void BIO_sock_cleanup(void); -int BIO_set_tcp_ndelay(int sock,int turn_on); +int BIO_set_tcp_ndelay(int sock, int turn_on); BIO *BIO_new_socket(int sock, int close_flag); BIO *BIO_new_dgram(int fd, int close_flag); #ifndef OPENSSL_NO_SCTP BIO *BIO_new_dgram_sctp(int fd, int close_flag); int BIO_dgram_is_sctp(BIO *bio); -int BIO_dgram_sctp_notification_cb(BIO *b, - void (*handle_notifications)(BIO *bio, void *context, void *buf), - void *context); +int +BIO_dgram_sctp_notification_cb(BIO *b, + void (*handle_notifications)(BIO *bio, void *context, void *buf), +void *context); int BIO_dgram_sctp_wait_for_dry(BIO *b); int BIO_dgram_sctp_msg_waiting(BIO *b); #endif @@ -741,8 +745,9 @@ BIO *BIO_new_fd(int fd, int close_flag); BIO *BIO_new_connect(char *host_port); BIO *BIO_new_accept(char *host_port); -int BIO_new_bio_pair(BIO **bio1, size_t writebuf1, - BIO **bio2, size_t writebuf2); +int +BIO_new_bio_pair(BIO **bio1, size_t writebuf1, +BIO **bio2, size_t writebuf2); /* If successful, returns 1 and in *bio1, *bio2 two BIO pair endpoints. * Otherwise returns 0 and sets *bio1 and *bio2 to NULL. * Size 0 uses default value. @@ -757,14 +762,18 @@ void BIO_copy_next_retry(BIO *b); #else # define __bio_h__attr__(x) #endif -int BIO_printf(BIO *bio, const char *format, ...) - __bio_h__attr__((__format__(__printf__,2,3))); -int BIO_vprintf(BIO *bio, const char *format, va_list args) - __bio_h__attr__((__format__(__printf__,2,0))); -int BIO_snprintf(char *buf, size_t n, const char *format, ...) - __bio_h__attr__((__format__(__printf__,3,4))); -int BIO_vsnprintf(char *buf, size_t n, const char *format, va_list args) - __bio_h__attr__((__format__(__printf__,3,0))); +int +BIO_printf(BIO *bio, const char *format, ...) +__bio_h__attr__((__format__(__printf__, 2, 3))); +int +BIO_vprintf(BIO *bio, const char *format, va_list args) +__bio_h__attr__((__format__(__printf__, 2, 0))); +int +BIO_snprintf(char *buf, size_t n, const char *format, ...) +__bio_h__attr__((__format__(__printf__, 3, 4))); +int +BIO_vsnprintf(char *buf, size_t n, const char *format, va_list args) +__bio_h__attr__((__format__(__printf__, 3, 0))); #undef __bio_h__attr__ /* BEGIN ERROR CODES */ diff --git a/src/lib/libcrypto/bio/bio_cb.c b/src/lib/libcrypto/bio/bio_cb.c index 78c8974ab4..3e110f3751 100644 --- a/src/lib/libcrypto/bio/bio_cb.c +++ b/src/lib/libcrypto/bio/bio_cb.c @@ -63,81 +63,85 @@ #include #include -long BIO_debug_callback(BIO *bio, int cmd, const char *argp, - int argi, long argl, long ret) - { +long +BIO_debug_callback(BIO *bio, int cmd, const char *argp, int argi, long argl, + long ret) +{ BIO *b; char buf[256]; char *p; - long r=1; + long r = 1; size_t p_maxlen; if (BIO_CB_RETURN & cmd) - r=ret; + r = ret; - (void) snprintf(buf,sizeof buf,"BIO[%08lX]:",(unsigned long)bio); - p= &(buf[14]); + (void) snprintf(buf, sizeof buf, "BIO[%08lX]:", (unsigned long)bio); + p = &(buf[14]); p_maxlen = sizeof buf - 14; - switch (cmd) - { + switch (cmd) { case BIO_CB_FREE: - (void) snprintf(p,p_maxlen,"Free - %s\n",bio->method->name); + (void) snprintf(p, p_maxlen, "Free - %s\n", bio->method->name); break; case BIO_CB_READ: if (bio->method->type & BIO_TYPE_DESCRIPTOR) - (void) snprintf(p,p_maxlen,"read(%d,%lu) - %s fd=%d\n", - bio->num,(unsigned long)argi, - bio->method->name,bio->num); + (void) snprintf(p, p_maxlen, + "read(%d,%lu) - %s fd=%d\n", + bio->num,(unsigned long)argi, + bio->method->name, bio->num); else - (void) snprintf(p,p_maxlen,"read(%d,%lu) - %s\n", - bio->num,(unsigned long)argi, - bio->method->name); + (void) snprintf(p, p_maxlen, "read(%d,%lu) - %s\n", + bio->num, (unsigned long)argi, bio->method->name); break; case BIO_CB_WRITE: if (bio->method->type & BIO_TYPE_DESCRIPTOR) - (void) snprintf(p,p_maxlen,"write(%d,%lu) - %s fd=%d\n", - bio->num,(unsigned long)argi, - bio->method->name,bio->num); + (void) snprintf(p, p_maxlen, + "write(%d,%lu) - %s fd=%d\n", + bio->num, (unsigned long)argi, + bio->method->name, bio->num); else - (void) snprintf(p,p_maxlen,"write(%d,%lu) - %s\n", - bio->num,(unsigned long)argi, - bio->method->name); + (void) snprintf(p, p_maxlen, "write(%d,%lu) - %s\n", + bio->num, (unsigned long)argi, bio->method->name); break; case BIO_CB_PUTS: - (void) snprintf(p,p_maxlen,"puts() - %s\n",bio->method->name); + (void) snprintf(p, p_maxlen, + "puts() - %s\n", bio->method->name); break; case BIO_CB_GETS: - (void) snprintf(p,p_maxlen,"gets(%lu) - %s\n",(unsigned long)argi,bio->method->name); + (void) snprintf(p, p_maxlen, "gets(%lu) - %s\n", + (unsigned long)argi, bio->method->name); break; case BIO_CB_CTRL: - (void) snprintf(p,p_maxlen,"ctrl(%lu) - %s\n",(unsigned long)argi,bio->method->name); + (void) snprintf(p, p_maxlen, "ctrl(%lu) - %s\n", + (unsigned long)argi, bio->method->name); break; case BIO_CB_RETURN|BIO_CB_READ: - (void) snprintf(p,p_maxlen,"read return %ld\n",ret); + (void) snprintf(p, p_maxlen, "read return %ld\n", ret); break; case BIO_CB_RETURN|BIO_CB_WRITE: - (void) snprintf(p,p_maxlen,"write return %ld\n",ret); + (void) snprintf(p, p_maxlen, "write return %ld\n", ret); break; case BIO_CB_RETURN|BIO_CB_GETS: - (void) snprintf(p,p_maxlen,"gets return %ld\n",ret); + (void) snprintf(p, p_maxlen, "gets return %ld\n", ret); break; case BIO_CB_RETURN|BIO_CB_PUTS: - (void) snprintf(p,p_maxlen,"puts return %ld\n",ret); + (void) snprintf(p, p_maxlen, "puts return %ld\n", ret); break; case BIO_CB_RETURN|BIO_CB_CTRL: - (void) snprintf(p,p_maxlen,"ctrl return %ld\n",ret); + (void) snprintf(p, p_maxlen, "ctrl return %ld\n", ret); break; default: - (void) snprintf(p,p_maxlen,"bio callback - unknown type (%d)\n",cmd); + (void) snprintf(p, p_maxlen, + "bio callback - unknown type (%d)\n", cmd); break; - } + } - b=(BIO *)bio->cb_arg; + b = (BIO *)bio->cb_arg; if (b != NULL) - BIO_write(b,buf,strlen(buf)); + BIO_write(b, buf, strlen(buf)); #if !defined(OPENSSL_NO_STDIO) && !defined(OPENSSL_SYS_WIN16) else - fputs(buf,stderr); + fputs(buf, stderr); #endif - return(r); - } + return (r); +} diff --git a/src/lib/libcrypto/bio/bio_err.c b/src/lib/libcrypto/bio/bio_err.c index 0dbfbd80d3..86e9a3082b 100644 --- a/src/lib/libcrypto/bio/bio_err.c +++ b/src/lib/libcrypto/bio/bio_err.c @@ -68,88 +68,85 @@ #define ERR_FUNC(func) ERR_PACK(ERR_LIB_BIO,func,0) #define ERR_REASON(reason) ERR_PACK(ERR_LIB_BIO,0,reason) -static ERR_STRING_DATA BIO_str_functs[]= - { -{ERR_FUNC(BIO_F_ACPT_STATE), "ACPT_STATE"}, -{ERR_FUNC(BIO_F_BIO_ACCEPT), "BIO_accept"}, -{ERR_FUNC(BIO_F_BIO_BER_GET_HEADER), "BIO_BER_GET_HEADER"}, -{ERR_FUNC(BIO_F_BIO_CALLBACK_CTRL), "BIO_callback_ctrl"}, -{ERR_FUNC(BIO_F_BIO_CTRL), "BIO_ctrl"}, -{ERR_FUNC(BIO_F_BIO_GETHOSTBYNAME), "BIO_gethostbyname"}, -{ERR_FUNC(BIO_F_BIO_GETS), "BIO_gets"}, -{ERR_FUNC(BIO_F_BIO_GET_ACCEPT_SOCKET), "BIO_get_accept_socket"}, -{ERR_FUNC(BIO_F_BIO_GET_HOST_IP), "BIO_get_host_ip"}, -{ERR_FUNC(BIO_F_BIO_GET_PORT), "BIO_get_port"}, -{ERR_FUNC(BIO_F_BIO_MAKE_PAIR), "BIO_MAKE_PAIR"}, -{ERR_FUNC(BIO_F_BIO_NEW), "BIO_new"}, -{ERR_FUNC(BIO_F_BIO_NEW_FILE), "BIO_new_file"}, -{ERR_FUNC(BIO_F_BIO_NEW_MEM_BUF), "BIO_new_mem_buf"}, -{ERR_FUNC(BIO_F_BIO_NREAD), "BIO_nread"}, -{ERR_FUNC(BIO_F_BIO_NREAD0), "BIO_nread0"}, -{ERR_FUNC(BIO_F_BIO_NWRITE), "BIO_nwrite"}, -{ERR_FUNC(BIO_F_BIO_NWRITE0), "BIO_nwrite0"}, -{ERR_FUNC(BIO_F_BIO_PUTS), "BIO_puts"}, -{ERR_FUNC(BIO_F_BIO_READ), "BIO_read"}, -{ERR_FUNC(BIO_F_BIO_SOCK_INIT), "BIO_sock_init"}, -{ERR_FUNC(BIO_F_BIO_WRITE), "BIO_write"}, -{ERR_FUNC(BIO_F_BUFFER_CTRL), "BUFFER_CTRL"}, -{ERR_FUNC(BIO_F_CONN_CTRL), "CONN_CTRL"}, -{ERR_FUNC(BIO_F_CONN_STATE), "CONN_STATE"}, -{ERR_FUNC(BIO_F_DGRAM_SCTP_READ), "DGRAM_SCTP_READ"}, -{ERR_FUNC(BIO_F_FILE_CTRL), "FILE_CTRL"}, -{ERR_FUNC(BIO_F_FILE_READ), "FILE_READ"}, -{ERR_FUNC(BIO_F_LINEBUFFER_CTRL), "LINEBUFFER_CTRL"}, -{ERR_FUNC(BIO_F_MEM_READ), "MEM_READ"}, -{ERR_FUNC(BIO_F_MEM_WRITE), "MEM_WRITE"}, -{ERR_FUNC(BIO_F_SSL_NEW), "SSL_new"}, -{ERR_FUNC(BIO_F_WSASTARTUP), "WSASTARTUP"}, -{0,NULL} - }; +static ERR_STRING_DATA BIO_str_functs[]= { + {ERR_FUNC(BIO_F_ACPT_STATE), "ACPT_STATE"}, + {ERR_FUNC(BIO_F_BIO_ACCEPT), "BIO_accept"}, + {ERR_FUNC(BIO_F_BIO_BER_GET_HEADER), "BIO_BER_GET_HEADER"}, + {ERR_FUNC(BIO_F_BIO_CALLBACK_CTRL), "BIO_callback_ctrl"}, + {ERR_FUNC(BIO_F_BIO_CTRL), "BIO_ctrl"}, + {ERR_FUNC(BIO_F_BIO_GETHOSTBYNAME), "BIO_gethostbyname"}, + {ERR_FUNC(BIO_F_BIO_GETS), "BIO_gets"}, + {ERR_FUNC(BIO_F_BIO_GET_ACCEPT_SOCKET), "BIO_get_accept_socket"}, + {ERR_FUNC(BIO_F_BIO_GET_HOST_IP), "BIO_get_host_ip"}, + {ERR_FUNC(BIO_F_BIO_GET_PORT), "BIO_get_port"}, + {ERR_FUNC(BIO_F_BIO_MAKE_PAIR), "BIO_MAKE_PAIR"}, + {ERR_FUNC(BIO_F_BIO_NEW), "BIO_new"}, + {ERR_FUNC(BIO_F_BIO_NEW_FILE), "BIO_new_file"}, + {ERR_FUNC(BIO_F_BIO_NEW_MEM_BUF), "BIO_new_mem_buf"}, + {ERR_FUNC(BIO_F_BIO_NREAD), "BIO_nread"}, + {ERR_FUNC(BIO_F_BIO_NREAD0), "BIO_nread0"}, + {ERR_FUNC(BIO_F_BIO_NWRITE), "BIO_nwrite"}, + {ERR_FUNC(BIO_F_BIO_NWRITE0), "BIO_nwrite0"}, + {ERR_FUNC(BIO_F_BIO_PUTS), "BIO_puts"}, + {ERR_FUNC(BIO_F_BIO_READ), "BIO_read"}, + {ERR_FUNC(BIO_F_BIO_SOCK_INIT), "BIO_sock_init"}, + {ERR_FUNC(BIO_F_BIO_WRITE), "BIO_write"}, + {ERR_FUNC(BIO_F_BUFFER_CTRL), "BUFFER_CTRL"}, + {ERR_FUNC(BIO_F_CONN_CTRL), "CONN_CTRL"}, + {ERR_FUNC(BIO_F_CONN_STATE), "CONN_STATE"}, + {ERR_FUNC(BIO_F_DGRAM_SCTP_READ), "DGRAM_SCTP_READ"}, + {ERR_FUNC(BIO_F_FILE_CTRL), "FILE_CTRL"}, + {ERR_FUNC(BIO_F_FILE_READ), "FILE_READ"}, + {ERR_FUNC(BIO_F_LINEBUFFER_CTRL), "LINEBUFFER_CTRL"}, + {ERR_FUNC(BIO_F_MEM_READ), "MEM_READ"}, + {ERR_FUNC(BIO_F_MEM_WRITE), "MEM_WRITE"}, + {ERR_FUNC(BIO_F_SSL_NEW), "SSL_new"}, + {ERR_FUNC(BIO_F_WSASTARTUP), "WSASTARTUP"}, + {0, NULL} +}; -static ERR_STRING_DATA BIO_str_reasons[]= - { -{ERR_REASON(BIO_R_ACCEPT_ERROR) ,"accept error"}, -{ERR_REASON(BIO_R_BAD_FOPEN_MODE) ,"bad fopen mode"}, -{ERR_REASON(BIO_R_BAD_HOSTNAME_LOOKUP) ,"bad hostname lookup"}, -{ERR_REASON(BIO_R_BROKEN_PIPE) ,"broken pipe"}, -{ERR_REASON(BIO_R_CONNECT_ERROR) ,"connect error"}, -{ERR_REASON(BIO_R_EOF_ON_MEMORY_BIO) ,"EOF on memory BIO"}, -{ERR_REASON(BIO_R_ERROR_SETTING_NBIO) ,"error setting nbio"}, -{ERR_REASON(BIO_R_ERROR_SETTING_NBIO_ON_ACCEPTED_SOCKET),"error setting nbio on accepted socket"}, -{ERR_REASON(BIO_R_ERROR_SETTING_NBIO_ON_ACCEPT_SOCKET),"error setting nbio on accept socket"}, -{ERR_REASON(BIO_R_GETHOSTBYNAME_ADDR_IS_NOT_AF_INET),"gethostbyname addr is not af inet"}, -{ERR_REASON(BIO_R_INVALID_ARGUMENT) ,"invalid argument"}, -{ERR_REASON(BIO_R_INVALID_IP_ADDRESS) ,"invalid ip address"}, -{ERR_REASON(BIO_R_IN_USE) ,"in use"}, -{ERR_REASON(BIO_R_KEEPALIVE) ,"keepalive"}, -{ERR_REASON(BIO_R_NBIO_CONNECT_ERROR) ,"nbio connect error"}, -{ERR_REASON(BIO_R_NO_ACCEPT_PORT_SPECIFIED),"no accept port specified"}, -{ERR_REASON(BIO_R_NO_HOSTNAME_SPECIFIED) ,"no hostname specified"}, -{ERR_REASON(BIO_R_NO_PORT_DEFINED) ,"no port defined"}, -{ERR_REASON(BIO_R_NO_PORT_SPECIFIED) ,"no port specified"}, -{ERR_REASON(BIO_R_NO_SUCH_FILE) ,"no such file"}, -{ERR_REASON(BIO_R_NULL_PARAMETER) ,"null parameter"}, -{ERR_REASON(BIO_R_TAG_MISMATCH) ,"tag mismatch"}, -{ERR_REASON(BIO_R_UNABLE_TO_BIND_SOCKET) ,"unable to bind socket"}, -{ERR_REASON(BIO_R_UNABLE_TO_CREATE_SOCKET),"unable to create socket"}, -{ERR_REASON(BIO_R_UNABLE_TO_LISTEN_SOCKET),"unable to listen socket"}, -{ERR_REASON(BIO_R_UNINITIALIZED) ,"uninitialized"}, -{ERR_REASON(BIO_R_UNSUPPORTED_METHOD) ,"unsupported method"}, -{ERR_REASON(BIO_R_WRITE_TO_READ_ONLY_BIO),"write to read only BIO"}, -{ERR_REASON(BIO_R_WSASTARTUP) ,"WSAStartup"}, -{0,NULL} - }; +static ERR_STRING_DATA BIO_str_reasons[]= { + {ERR_REASON(BIO_R_ACCEPT_ERROR) , "accept error"}, + {ERR_REASON(BIO_R_BAD_FOPEN_MODE) , "bad fopen mode"}, + {ERR_REASON(BIO_R_BAD_HOSTNAME_LOOKUP) , "bad hostname lookup"}, + {ERR_REASON(BIO_R_BROKEN_PIPE) , "broken pipe"}, + {ERR_REASON(BIO_R_CONNECT_ERROR) , "connect error"}, + {ERR_REASON(BIO_R_EOF_ON_MEMORY_BIO) , "EOF on memory BIO"}, + {ERR_REASON(BIO_R_ERROR_SETTING_NBIO) , "error setting nbio"}, + {ERR_REASON(BIO_R_ERROR_SETTING_NBIO_ON_ACCEPTED_SOCKET), "error setting nbio on accepted socket"}, + {ERR_REASON(BIO_R_ERROR_SETTING_NBIO_ON_ACCEPT_SOCKET), "error setting nbio on accept socket"}, + {ERR_REASON(BIO_R_GETHOSTBYNAME_ADDR_IS_NOT_AF_INET), "gethostbyname addr is not af inet"}, + {ERR_REASON(BIO_R_INVALID_ARGUMENT) , "invalid argument"}, + {ERR_REASON(BIO_R_INVALID_IP_ADDRESS) , "invalid ip address"}, + {ERR_REASON(BIO_R_IN_USE) , "in use"}, + {ERR_REASON(BIO_R_KEEPALIVE) , "keepalive"}, + {ERR_REASON(BIO_R_NBIO_CONNECT_ERROR) , "nbio connect error"}, + {ERR_REASON(BIO_R_NO_ACCEPT_PORT_SPECIFIED), "no accept port specified"}, + {ERR_REASON(BIO_R_NO_HOSTNAME_SPECIFIED) , "no hostname specified"}, + {ERR_REASON(BIO_R_NO_PORT_DEFINED) , "no port defined"}, + {ERR_REASON(BIO_R_NO_PORT_SPECIFIED) , "no port specified"}, + {ERR_REASON(BIO_R_NO_SUCH_FILE) , "no such file"}, + {ERR_REASON(BIO_R_NULL_PARAMETER) , "null parameter"}, + {ERR_REASON(BIO_R_TAG_MISMATCH) , "tag mismatch"}, + {ERR_REASON(BIO_R_UNABLE_TO_BIND_SOCKET) , "unable to bind socket"}, + {ERR_REASON(BIO_R_UNABLE_TO_CREATE_SOCKET), "unable to create socket"}, + {ERR_REASON(BIO_R_UNABLE_TO_LISTEN_SOCKET), "unable to listen socket"}, + {ERR_REASON(BIO_R_UNINITIALIZED) , "uninitialized"}, + {ERR_REASON(BIO_R_UNSUPPORTED_METHOD) , "unsupported method"}, + {ERR_REASON(BIO_R_WRITE_TO_READ_ONLY_BIO), "write to read only BIO"}, + {ERR_REASON(BIO_R_WSASTARTUP) , "WSAStartup"}, + {0, NULL} +}; #endif -void ERR_load_BIO_strings(void) - { +void +ERR_load_BIO_strings(void) +{ #ifndef OPENSSL_NO_ERR - - if (ERR_func_error_string(BIO_str_functs[0].error) == NULL) - { - ERR_load_strings(0,BIO_str_functs); - ERR_load_strings(0,BIO_str_reasons); - } -#endif + if (ERR_func_error_string(BIO_str_functs[0].error) == NULL) { + ERR_load_strings(0, BIO_str_functs); + ERR_load_strings(0, BIO_str_reasons); } +#endif +} diff --git a/src/lib/libcrypto/bio/bio_lib.c b/src/lib/libcrypto/bio/bio_lib.c index 9c9646afa8..9e8fb7913a 100644 --- a/src/lib/libcrypto/bio/bio_lib.c +++ b/src/lib/libcrypto/bio/bio_lib.c @@ -63,539 +63,571 @@ #include #include -BIO *BIO_new(BIO_METHOD *method) - { - BIO *ret=NULL; - - ret=(BIO *)OPENSSL_malloc(sizeof(BIO)); - if (ret == NULL) - { - BIOerr(BIO_F_BIO_NEW,ERR_R_MALLOC_FAILURE); - return(NULL); - } - if (!BIO_set(ret,method)) - { +BIO +*BIO_new(BIO_METHOD *method) +{ + BIO *ret = NULL; + + ret = (BIO *)OPENSSL_malloc(sizeof(BIO)); + if (ret == NULL) { + BIOerr(BIO_F_BIO_NEW, ERR_R_MALLOC_FAILURE); + return (NULL); + } + if (!BIO_set(ret, method)) { OPENSSL_free(ret); - ret=NULL; - } - return(ret); + ret = NULL; } + return (ret); +} -int BIO_set(BIO *bio, BIO_METHOD *method) - { - bio->method=method; - bio->callback=NULL; - bio->cb_arg=NULL; - bio->init=0; - bio->shutdown=1; - bio->flags=0; - bio->retry_reason=0; - bio->num=0; - bio->ptr=NULL; - bio->prev_bio=NULL; - bio->next_bio=NULL; - bio->references=1; - bio->num_read=0L; - bio->num_write=0L; +int +BIO_set(BIO *bio, BIO_METHOD *method) +{ + bio->method = method; + bio->callback = NULL; + bio->cb_arg = NULL; + bio->init = 0; + bio->shutdown = 1; + bio->flags = 0; + bio->retry_reason = 0; + bio->num = 0; + bio->ptr = NULL; + bio->prev_bio = NULL; + bio->next_bio = NULL; + bio->references = 1; + bio->num_read = 0L; + bio->num_write = 0L; CRYPTO_new_ex_data(CRYPTO_EX_INDEX_BIO, bio, &bio->ex_data); if (method->create != NULL) - if (!method->create(bio)) - { + if (!method->create(bio)) { CRYPTO_free_ex_data(CRYPTO_EX_INDEX_BIO, bio, - &bio->ex_data); - return(0); - } - return(1); - } + &bio->ex_data); + return (0); + } + return (1); +} -int BIO_free(BIO *a) - { +int +BIO_free(BIO *a) +{ int i; - if (a == NULL) return(0); + if (a == NULL) + return (0); - i=CRYPTO_add(&a->references,-1,CRYPTO_LOCK_BIO); + i = CRYPTO_add(&a->references, -1, CRYPTO_LOCK_BIO); #ifdef REF_PRINT - REF_PRINT("BIO",a); + REF_PRINT("BIO", a); #endif - if (i > 0) return(1); + if (i > 0) + return (1); #ifdef REF_CHECK - if (i < 0) - { - fprintf(stderr,"BIO_free, bad reference count\n"); + if (i < 0) { + fprintf(stderr, "BIO_free, bad reference count\n"); abort(); - } + } #endif if ((a->callback != NULL) && - ((i=(int)a->callback(a,BIO_CB_FREE,NULL,0,0L,1L)) <= 0)) - return(i); + ((i = (int)a->callback(a, BIO_CB_FREE, NULL, 0, 0L, 1L)) <= 0)) + return (i); CRYPTO_free_ex_data(CRYPTO_EX_INDEX_BIO, a, &a->ex_data); - if ((a->method == NULL) || (a->method->destroy == NULL)) return(1); + if ((a->method == NULL) || (a->method->destroy == NULL)) + return (1); a->method->destroy(a); OPENSSL_free(a); - return(1); - } + return (1); +} -void BIO_vfree(BIO *a) - { BIO_free(a); } +void +BIO_vfree(BIO *a) +{ + BIO_free(a); +} -void BIO_clear_flags(BIO *b, int flags) - { +void +BIO_clear_flags(BIO *b, int flags) +{ b->flags &= ~flags; - } +} -int BIO_test_flags(const BIO *b, int flags) - { +int +BIO_test_flags(const BIO *b, int flags) +{ return (b->flags & flags); - } +} -void BIO_set_flags(BIO *b, int flags) - { +void +BIO_set_flags(BIO *b, int flags) +{ b->flags |= flags; - } +} -long (*BIO_get_callback(const BIO *b))(struct bio_st *,int,const char *,int, long,long) - { +long +(*BIO_get_callback(const BIO *b))(struct bio_st *, int, const char *, int, + long, long) +{ return b->callback; - } +} -void BIO_set_callback(BIO *b, long (*cb)(struct bio_st *,int,const char *,int, long,long)) - { +void +BIO_set_callback(BIO *b, long (*cb)(struct bio_st *, int, const char *, int, + long, long)) +{ b->callback = cb; - } +} -void BIO_set_callback_arg(BIO *b, char *arg) - { +void +BIO_set_callback_arg(BIO *b, char *arg) +{ b->cb_arg = arg; - } +} -char * BIO_get_callback_arg(const BIO *b) - { +char * +BIO_get_callback_arg(const BIO *b) +{ return b->cb_arg; - } +} -const char * BIO_method_name(const BIO *b) - { +const char * +BIO_method_name(const BIO *b) +{ return b->method->name; - } +} -int BIO_method_type(const BIO *b) - { +int +BIO_method_type(const BIO *b) +{ return b->method->type; - } - +} -int BIO_read(BIO *b, void *out, int outl) - { +int +BIO_read(BIO *b, void *out, int outl) +{ int i; - long (*cb)(BIO *,int,const char *,int,long,long); + long (*cb)(BIO *, int, const char *, int, long, long); - if ((b == NULL) || (b->method == NULL) || (b->method->bread == NULL)) - { - BIOerr(BIO_F_BIO_READ,BIO_R_UNSUPPORTED_METHOD); - return(-2); - } + if ((b == NULL) || (b->method == NULL) || (b->method->bread == NULL)) { + BIOerr(BIO_F_BIO_READ, BIO_R_UNSUPPORTED_METHOD); + return (-2); + } - cb=b->callback; + cb = b->callback; if ((cb != NULL) && - ((i=(int)cb(b,BIO_CB_READ,out,outl,0L,1L)) <= 0)) - return(i); + ((i = (int)cb(b, BIO_CB_READ, out, outl, 0L, 1L)) <= 0)) + return (i); - if (!b->init) - { - BIOerr(BIO_F_BIO_READ,BIO_R_UNINITIALIZED); - return(-2); - } + if (!b->init) { + BIOerr(BIO_F_BIO_READ, BIO_R_UNINITIALIZED); + return (-2); + } - i=b->method->bread(b,out,outl); + i = b->method->bread(b, out, outl); - if (i > 0) b->num_read+=(unsigned long)i; + if (i > 0) + b->num_read += (unsigned long)i; if (cb != NULL) - i=(int)cb(b,BIO_CB_READ|BIO_CB_RETURN,out,outl, - 0L,(long)i); - return(i); - } + i = (int)cb(b, BIO_CB_READ|BIO_CB_RETURN, out, outl, + 0L, (long)i); + return (i); +} -int BIO_write(BIO *b, const void *in, int inl) - { +int +BIO_write(BIO *b, const void *in, int inl) +{ int i; - long (*cb)(BIO *,int,const char *,int,long,long); + long (*cb)(BIO *, int, const char *, int, long, long); if (b == NULL) - return(0); + return (0); - cb=b->callback; - if ((b->method == NULL) || (b->method->bwrite == NULL)) - { - BIOerr(BIO_F_BIO_WRITE,BIO_R_UNSUPPORTED_METHOD); - return(-2); - } + cb = b->callback; + if ((b->method == NULL) || (b->method->bwrite == NULL)) { + BIOerr(BIO_F_BIO_WRITE, BIO_R_UNSUPPORTED_METHOD); + return (-2); + } if ((cb != NULL) && - ((i=(int)cb(b,BIO_CB_WRITE,in,inl,0L,1L)) <= 0)) - return(i); + ((i = (int)cb(b, BIO_CB_WRITE, in, inl, 0L, 1L)) <= 0)) + return (i); - if (!b->init) - { - BIOerr(BIO_F_BIO_WRITE,BIO_R_UNINITIALIZED); - return(-2); - } + if (!b->init) { + BIOerr(BIO_F_BIO_WRITE, BIO_R_UNINITIALIZED); + return (-2); + } - i=b->method->bwrite(b,in,inl); + i = b->method->bwrite(b, in, inl); - if (i > 0) b->num_write+=(unsigned long)i; + if (i > 0) + b->num_write += (unsigned long)i; if (cb != NULL) - i=(int)cb(b,BIO_CB_WRITE|BIO_CB_RETURN,in,inl, - 0L,(long)i); - return(i); - } + i = (int)cb(b, BIO_CB_WRITE|BIO_CB_RETURN, in, inl, + 0L, (long)i); + return (i); +} -int BIO_puts(BIO *b, const char *in) - { +int +BIO_puts(BIO *b, const char *in) +{ int i; - long (*cb)(BIO *,int,const char *,int,long,long); + long (*cb)(BIO *, int, const char *, int, long, long); - if ((b == NULL) || (b->method == NULL) || (b->method->bputs == NULL)) - { - BIOerr(BIO_F_BIO_PUTS,BIO_R_UNSUPPORTED_METHOD); - return(-2); - } + if ((b == NULL) || (b->method == NULL) || (b->method->bputs == NULL)) { + BIOerr(BIO_F_BIO_PUTS, BIO_R_UNSUPPORTED_METHOD); + return (-2); + } - cb=b->callback; + cb = b->callback; if ((cb != NULL) && - ((i=(int)cb(b,BIO_CB_PUTS,in,0,0L,1L)) <= 0)) - return(i); + ((i = (int)cb(b, BIO_CB_PUTS, in, 0, 0L, 1L)) <= 0)) + return (i); - if (!b->init) - { - BIOerr(BIO_F_BIO_PUTS,BIO_R_UNINITIALIZED); - return(-2); - } + if (!b->init) { + BIOerr(BIO_F_BIO_PUTS, BIO_R_UNINITIALIZED); + return (-2); + } - i=b->method->bputs(b,in); + i = b->method->bputs(b, in); - if (i > 0) b->num_write+=(unsigned long)i; + if (i > 0) + b->num_write += (unsigned long)i; if (cb != NULL) - i=(int)cb(b,BIO_CB_PUTS|BIO_CB_RETURN,in,0, - 0L,(long)i); - return(i); - } + i = (int)cb(b, BIO_CB_PUTS|BIO_CB_RETURN, in, 0, 0L, (long)i); + return (i); +} -int BIO_gets(BIO *b, char *in, int inl) - { +int +BIO_gets(BIO *b, char *in, int inl) +{ int i; - long (*cb)(BIO *,int,const char *,int,long,long); + long (*cb)(BIO *, int, const char *, int, long, long); - if ((b == NULL) || (b->method == NULL) || (b->method->bgets == NULL)) - { - BIOerr(BIO_F_BIO_GETS,BIO_R_UNSUPPORTED_METHOD); - return(-2); - } + if ((b == NULL) || (b->method == NULL) || (b->method->bgets == NULL)) { + BIOerr(BIO_F_BIO_GETS, BIO_R_UNSUPPORTED_METHOD); + return (-2); + } - cb=b->callback; + cb = b->callback; if ((cb != NULL) && - ((i=(int)cb(b,BIO_CB_GETS,in,inl,0L,1L)) <= 0)) - return(i); + ((i = (int)cb(b, BIO_CB_GETS, in, inl, 0L, 1L)) <= 0)) + return (i); - if (!b->init) - { - BIOerr(BIO_F_BIO_GETS,BIO_R_UNINITIALIZED); - return(-2); - } + if (!b->init) { + BIOerr(BIO_F_BIO_GETS, BIO_R_UNINITIALIZED); + return (-2); + } - i=b->method->bgets(b,in,inl); + i = b->method->bgets(b, in, inl); if (cb != NULL) - i=(int)cb(b,BIO_CB_GETS|BIO_CB_RETURN,in,inl, - 0L,(long)i); - return(i); - } + i = (int)cb(b, BIO_CB_GETS|BIO_CB_RETURN, in, inl, 0L, (long)i); + return (i); +} -int BIO_indent(BIO *b,int indent,int max) - { - if(indent < 0) - indent=0; - if(indent > max) - indent=max; - while(indent--) - if(BIO_puts(b," ") != 1) - return 0; +int +BIO_indent(BIO *b, int indent, int max) +{ + if (indent < 0) + indent = 0; + if (indent > max) + indent = max; + while (indent--) + if (BIO_puts(b, " ") != 1) + return 0; return 1; - } +} -long BIO_int_ctrl(BIO *b, int cmd, long larg, int iarg) - { +long +BIO_int_ctrl(BIO *b, int cmd, long larg, int iarg) +{ int i; - i=iarg; - return(BIO_ctrl(b,cmd,larg,(char *)&i)); - } + i = iarg; + return (BIO_ctrl(b, cmd, larg,(char *)&i)); +} -char *BIO_ptr_ctrl(BIO *b, int cmd, long larg) - { - char *p=NULL; +char +*BIO_ptr_ctrl(BIO *b, int cmd, long larg) +{ + char *p = NULL; - if (BIO_ctrl(b,cmd,larg,(char *)&p) <= 0) - return(NULL); + if (BIO_ctrl(b, cmd, larg,(char *)&p) <= 0) + return (NULL); else - return(p); - } + return (p); +} -long BIO_ctrl(BIO *b, int cmd, long larg, void *parg) - { +long +BIO_ctrl(BIO *b, int cmd, long larg, void *parg) +{ long ret; - long (*cb)(BIO *,int,const char *,int,long,long); + long (*cb)(BIO *, int, const char *, int, long, long); - if (b == NULL) return(0); + if (b == NULL) + return (0); - if ((b->method == NULL) || (b->method->ctrl == NULL)) - { - BIOerr(BIO_F_BIO_CTRL,BIO_R_UNSUPPORTED_METHOD); - return(-2); - } + if ((b->method == NULL) || (b->method->ctrl == NULL)) { + BIOerr(BIO_F_BIO_CTRL, BIO_R_UNSUPPORTED_METHOD); + return (-2); + } - cb=b->callback; + cb = b->callback; if ((cb != NULL) && - ((ret=cb(b,BIO_CB_CTRL,parg,cmd,larg,1L)) <= 0)) - return(ret); + ((ret = cb(b, BIO_CB_CTRL, parg, cmd, larg, 1L)) <= 0)) + return (ret); - ret=b->method->ctrl(b,cmd,larg,parg); + ret = b->method->ctrl(b, cmd, larg, parg); if (cb != NULL) - ret=cb(b,BIO_CB_CTRL|BIO_CB_RETURN,parg,cmd, - larg,ret); - return(ret); - } + ret = cb(b, BIO_CB_CTRL|BIO_CB_RETURN, parg, cmd, larg, ret); + return (ret); +} -long BIO_callback_ctrl(BIO *b, int cmd, void (*fp)(struct bio_st *, int, const char *, int, long, long)) - { +long +BIO_callback_ctrl(BIO *b, int cmd, + void (*fp)(struct bio_st *, int, const char *, int, long, long)) +{ long ret; - long (*cb)(BIO *,int,const char *,int,long,long); + long (*cb)(BIO *, int, const char *, int, long, long); - if (b == NULL) return(0); + if (b == NULL) + return (0); - if ((b->method == NULL) || (b->method->callback_ctrl == NULL)) - { - BIOerr(BIO_F_BIO_CALLBACK_CTRL,BIO_R_UNSUPPORTED_METHOD); - return(-2); - } + if ((b->method == NULL) || (b->method->callback_ctrl == NULL)) { + BIOerr(BIO_F_BIO_CALLBACK_CTRL, BIO_R_UNSUPPORTED_METHOD); + return (-2); + } - cb=b->callback; + cb = b->callback; if ((cb != NULL) && - ((ret=cb(b,BIO_CB_CTRL,(void *)&fp,cmd,0,1L)) <= 0)) - return(ret); + ((ret = cb(b, BIO_CB_CTRL,(void *)&fp, cmd, 0, 1L)) <= 0)) + return (ret); - ret=b->method->callback_ctrl(b,cmd,fp); + ret = b->method->callback_ctrl(b, cmd, fp); if (cb != NULL) - ret=cb(b,BIO_CB_CTRL|BIO_CB_RETURN,(void *)&fp,cmd, - 0,ret); - return(ret); - } + ret = cb(b, BIO_CB_CTRL|BIO_CB_RETURN,(void *)&fp, cmd, 0, ret); + return (ret); +} /* It is unfortunate to duplicate in functions what the BIO_(w)pending macros * do; but those macros have inappropriate return type, and for interfacing * from other programming languages, C macros aren't much of a help anyway. */ -size_t BIO_ctrl_pending(BIO *bio) - { +size_t +BIO_ctrl_pending(BIO *bio) +{ return BIO_ctrl(bio, BIO_CTRL_PENDING, 0, NULL); - } +} -size_t BIO_ctrl_wpending(BIO *bio) - { +size_t +BIO_ctrl_wpending(BIO *bio) +{ return BIO_ctrl(bio, BIO_CTRL_WPENDING, 0, NULL); - } +} /* put the 'bio' on the end of b's list of operators */ -BIO *BIO_push(BIO *b, BIO *bio) - { +BIO +*BIO_push(BIO *b, BIO *bio) +{ BIO *lb; - if (b == NULL) return(bio); - lb=b; + if (b == NULL) + return (bio); + lb = b; while (lb->next_bio != NULL) - lb=lb->next_bio; - lb->next_bio=bio; + lb = lb->next_bio; + lb->next_bio = bio; if (bio != NULL) - bio->prev_bio=lb; + bio->prev_bio = lb; /* called to do internal processing */ - BIO_ctrl(b,BIO_CTRL_PUSH,0,lb); - return(b); - } + BIO_ctrl(b, BIO_CTRL_PUSH, 0, lb); + return (b); +} /* Remove the first and return the rest */ -BIO *BIO_pop(BIO *b) - { +BIO +*BIO_pop(BIO *b) +{ BIO *ret; - if (b == NULL) return(NULL); - ret=b->next_bio; + if (b == NULL) + return (NULL); + ret = b->next_bio; - BIO_ctrl(b,BIO_CTRL_POP,0,b); + BIO_ctrl(b, BIO_CTRL_POP, 0, b); if (b->prev_bio != NULL) - b->prev_bio->next_bio=b->next_bio; + b->prev_bio->next_bio = b->next_bio; if (b->next_bio != NULL) - b->next_bio->prev_bio=b->prev_bio; + b->next_bio->prev_bio = b->prev_bio; - b->next_bio=NULL; - b->prev_bio=NULL; - return(ret); - } + b->next_bio = NULL; + b->prev_bio = NULL; + return (ret); +} -BIO *BIO_get_retry_BIO(BIO *bio, int *reason) - { - BIO *b,*last; +BIO +*BIO_get_retry_BIO(BIO *bio, int *reason) +{ + BIO *b, *last; - b=last=bio; - for (;;) - { + b = last = bio; + for (;;) { if (!BIO_should_retry(b)) break; - last=b; - b=b->next_bio; - if (b == NULL) break; - } - if (reason != NULL) *reason=last->retry_reason; - return(last); - } + last = b; + b = b->next_bio; + if (b == NULL) + break; + } + if (reason != NULL) + *reason = last->retry_reason; + return (last); +} -int BIO_get_retry_reason(BIO *bio) - { - return(bio->retry_reason); - } +int +BIO_get_retry_reason(BIO *bio) +{ + return (bio->retry_reason); +} -BIO *BIO_find_type(BIO *bio, int type) - { - int mt,mask; - - if(!bio) return NULL; - mask=type&0xff; - do { - if (bio->method != NULL) - { - mt=bio->method->type; - - if (!mask) - { - if (mt & type) return(bio); - } - else if (mt == type) - return(bio); - } - bio=bio->next_bio; - } while (bio != NULL); - return(NULL); - } +BIO +*BIO_find_type(BIO *bio, int type) +{ + int mt, mask; + + if (!bio) + return NULL; + mask = type & 0xff; + do { + if (bio->method != NULL) { + mt = bio->method->type; + if (!mask) { + if (mt & type) + return (bio); + } else if (mt == type) + return (bio); + } + bio = bio->next_bio; + } while (bio != NULL); + return (NULL); +} -BIO *BIO_next(BIO *b) - { - if(!b) return NULL; +BIO +*BIO_next(BIO *b) +{ + if (!b) + return NULL; return b->next_bio; - } +} -void BIO_free_all(BIO *bio) - { +void +BIO_free_all(BIO *bio) +{ BIO *b; int ref; - while (bio != NULL) - { - b=bio; - ref=b->references; - bio=bio->next_bio; + while (bio != NULL) { + b = bio; + ref = b->references; + bio = bio->next_bio; BIO_free(b); /* Since ref count > 1, don't free anyone else. */ - if (ref > 1) break; - } + if (ref > 1) + break; } +} -BIO *BIO_dup_chain(BIO *in) - { - BIO *ret=NULL,*eoc=NULL,*bio,*new_bio; +BIO +*BIO_dup_chain(BIO *in) +{ + BIO *ret = NULL, *eoc = NULL, *bio, *new_bio; - for (bio=in; bio != NULL; bio=bio->next_bio) - { - if ((new_bio=BIO_new(bio->method)) == NULL) goto err; - new_bio->callback=bio->callback; - new_bio->cb_arg=bio->cb_arg; - new_bio->init=bio->init; - new_bio->shutdown=bio->shutdown; - new_bio->flags=bio->flags; + for (bio = in; bio != NULL; bio = bio->next_bio) { + if ((new_bio = BIO_new(bio->method)) == NULL) goto err; + new_bio->callback = bio->callback; + new_bio->cb_arg = bio->cb_arg; + new_bio->init = bio->init; + new_bio->shutdown = bio->shutdown; + new_bio->flags = bio->flags; /* This will let SSL_s_sock() work with stdin/stdout */ - new_bio->num=bio->num; + new_bio->num = bio->num; - if (!BIO_dup_state(bio,(char *)new_bio)) - { + if (!BIO_dup_state(bio,(char *)new_bio)) { BIO_free(new_bio); goto err; - } + } /* copy app data */ - if (!CRYPTO_dup_ex_data(CRYPTO_EX_INDEX_BIO, &new_bio->ex_data, - &bio->ex_data)) + if (!CRYPTO_dup_ex_data(CRYPTO_EX_INDEX_BIO, + &new_bio->ex_data, &bio->ex_data)) goto err; - if (ret == NULL) - { - eoc=new_bio; - ret=eoc; - } - else - { - BIO_push(eoc,new_bio); - eoc=new_bio; - } + if (ret == NULL) { + eoc = new_bio; + ret = eoc; + } else { + BIO_push(eoc, new_bio); + eoc = new_bio; } - return(ret); + } + return (ret); err: if (ret != NULL) BIO_free(ret); - return(NULL); - } + return (NULL); -void BIO_copy_next_retry(BIO *b) - { - BIO_set_flags(b,BIO_get_retry_flags(b->next_bio)); - b->retry_reason=b->next_bio->retry_reason; - } +} -int BIO_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func, - CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func) - { +void +BIO_copy_next_retry(BIO *b) +{ + BIO_set_flags(b, BIO_get_retry_flags(b->next_bio)); + b->retry_reason = b->next_bio->retry_reason; +} + +int +BIO_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func, + CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func) +{ return CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_BIO, argl, argp, - new_func, dup_func, free_func); - } + new_func, dup_func, free_func); +} -int BIO_set_ex_data(BIO *bio, int idx, void *data) - { - return(CRYPTO_set_ex_data(&(bio->ex_data),idx,data)); - } +int +BIO_set_ex_data(BIO *bio, int idx, void *data) +{ + return (CRYPTO_set_ex_data(&(bio->ex_data), idx, data)); +} -void *BIO_get_ex_data(BIO *bio, int idx) - { - return(CRYPTO_get_ex_data(&(bio->ex_data),idx)); - } +void +*BIO_get_ex_data(BIO *bio, int idx) +{ + return (CRYPTO_get_ex_data(&(bio->ex_data), idx)); +} -unsigned long BIO_number_read(BIO *bio) +unsigned long +BIO_number_read(BIO *bio) { - if(bio) return bio->num_read; + if (bio) + return bio->num_read; return 0; } -unsigned long BIO_number_written(BIO *bio) +unsigned long +BIO_number_written(BIO *bio) { - if(bio) return bio->num_write; + if (bio) + return bio->num_write; return 0; } diff --git a/src/lib/libcrypto/bio/bss_acpt.c b/src/lib/libcrypto/bio/bss_acpt.c index 04bfb6fb9d..d772515d64 100644 --- a/src/lib/libcrypto/bio/bss_acpt.c +++ b/src/lib/libcrypto/bio/bss_acpt.c @@ -75,8 +75,7 @@ #undef FIONBIO #endif -typedef struct bio_accept_st - { +typedef struct bio_accept_st { int state; char *param_addr; @@ -90,7 +89,7 @@ typedef struct bio_accept_st * If 2, always use SO_REUSEADDR. */ int bind_mode; BIO *bio_chain; - } BIO_ACCEPT; +} BIO_ACCEPT; static int acpt_write(BIO *h, const char *buf, int num); static int acpt_read(BIO *h, char *buf, int size); @@ -107,8 +106,7 @@ static void BIO_ACCEPT_free(BIO_ACCEPT *a); #define ACPT_S_GET_ACCEPT_SOCKET 2 #define ACPT_S_OK 3 -static BIO_METHOD methods_acceptp= - { +static BIO_METHOD methods_acceptp = { BIO_TYPE_ACCEPT, "socket accept", acpt_write, @@ -119,321 +117,313 @@ static BIO_METHOD methods_acceptp= acpt_new, acpt_free, NULL, - }; +}; -BIO_METHOD *BIO_s_accept(void) - { - return(&methods_acceptp); - } +BIO_METHOD +*BIO_s_accept(void) +{ + return (&methods_acceptp); +} -static int acpt_new(BIO *bi) - { +static int +acpt_new(BIO *bi) +{ BIO_ACCEPT *ba; - bi->init=0; - bi->num=-1; - bi->flags=0; - if ((ba=BIO_ACCEPT_new()) == NULL) - return(0); - bi->ptr=(char *)ba; - ba->state=ACPT_S_BEFORE; - bi->shutdown=1; - return(1); - } - -static BIO_ACCEPT *BIO_ACCEPT_new(void) - { + bi->init = 0; + bi->num = -1; + bi->flags = 0; + if ((ba = BIO_ACCEPT_new()) == NULL) + return (0); + bi->ptr = (char *)ba; + ba->state = ACPT_S_BEFORE; + bi->shutdown = 1; + return (1); +} + +static BIO_ACCEPT +*BIO_ACCEPT_new(void) +{ BIO_ACCEPT *ret; - if ((ret=(BIO_ACCEPT *)OPENSSL_malloc(sizeof(BIO_ACCEPT))) == NULL) - return(NULL); - - memset(ret,0,sizeof(BIO_ACCEPT)); - ret->accept_sock=-1; - ret->bind_mode=BIO_BIND_NORMAL; - return(ret); - } - -static void BIO_ACCEPT_free(BIO_ACCEPT *a) - { - if(a == NULL) - return; - - if (a->param_addr != NULL) OPENSSL_free(a->param_addr); - if (a->addr != NULL) OPENSSL_free(a->addr); - if (a->bio_chain != NULL) BIO_free(a->bio_chain); + if ((ret = (BIO_ACCEPT *)OPENSSL_malloc(sizeof(BIO_ACCEPT))) == NULL) + return (NULL); + + memset(ret, 0, sizeof(BIO_ACCEPT)); + ret->accept_sock = -1; + ret->bind_mode = BIO_BIND_NORMAL; + return (ret); +} + +static void +BIO_ACCEPT_free(BIO_ACCEPT *a) +{ + if (a == NULL) + return; + + if (a->param_addr != NULL) + OPENSSL_free(a->param_addr); + if (a->addr != NULL) + OPENSSL_free(a->addr); + if (a->bio_chain != NULL) + BIO_free(a->bio_chain); OPENSSL_free(a); - } +} -static void acpt_close_socket(BIO *bio) - { +static void +acpt_close_socket(BIO *bio) +{ BIO_ACCEPT *c; - c=(BIO_ACCEPT *)bio->ptr; - if (c->accept_sock != -1) - { + c = (BIO_ACCEPT *)bio->ptr; + if (c->accept_sock != -1) { shutdown(c->accept_sock, SHUT_RDWR); close(c->accept_sock); - c->accept_sock=-1; - bio->num=-1; - } + c->accept_sock = -1; + bio->num = -1; } +} -static int acpt_free(BIO *a) - { +static int +acpt_free(BIO *a) +{ BIO_ACCEPT *data; - if (a == NULL) return(0); - data=(BIO_ACCEPT *)a->ptr; - - if (a->shutdown) - { + if (a == NULL) + return (0); + data = (BIO_ACCEPT *)a->ptr; + + if (a->shutdown) { acpt_close_socket(a); BIO_ACCEPT_free(data); - a->ptr=NULL; - a->flags=0; - a->init=0; - } - return(1); + a->ptr = NULL; + a->flags = 0; + a->init = 0; } - -static int acpt_state(BIO *b, BIO_ACCEPT *c) - { - BIO *bio=NULL,*dbio; - int s= -1; + return (1); +} + +static int +acpt_state(BIO *b, BIO_ACCEPT *c) +{ + BIO *bio = NULL, *dbio; + int s = -1; int i; again: - switch (c->state) - { + switch (c->state) { case ACPT_S_BEFORE: - if (c->param_addr == NULL) - { - BIOerr(BIO_F_ACPT_STATE,BIO_R_NO_ACCEPT_PORT_SPECIFIED); - return(-1); - } - s=BIO_get_accept_socket(c->param_addr,c->bind_mode); + if (c->param_addr == NULL) { + BIOerr(BIO_F_ACPT_STATE, BIO_R_NO_ACCEPT_PORT_SPECIFIED); + return (-1); + } + s = BIO_get_accept_socket(c->param_addr, c->bind_mode); if (s == -1) - return(-1); + return (-1); - if (c->accept_nbio) - { - if (!BIO_socket_nbio(s,1)) - { + if (c->accept_nbio) { + if (!BIO_socket_nbio(s, 1)) { close(s); - BIOerr(BIO_F_ACPT_STATE,BIO_R_ERROR_SETTING_NBIO_ON_ACCEPT_SOCKET); - return(-1); - } + BIOerr(BIO_F_ACPT_STATE, BIO_R_ERROR_SETTING_NBIO_ON_ACCEPT_SOCKET); + return (-1); } - c->accept_sock=s; - b->num=s; - c->state=ACPT_S_GET_ACCEPT_SOCKET; - return(1); + } + c->accept_sock = s; + b->num = s; + c->state = ACPT_S_GET_ACCEPT_SOCKET; + return (1); /* break; */ case ACPT_S_GET_ACCEPT_SOCKET: - if (b->next_bio != NULL) - { - c->state=ACPT_S_OK; + if (b->next_bio != NULL) { + c->state = ACPT_S_OK; goto again; - } + } BIO_clear_retry_flags(b); - b->retry_reason=0; - i=BIO_accept(c->accept_sock,&(c->addr)); + b->retry_reason = 0; + i = BIO_accept(c->accept_sock, &(c->addr)); /* -2 return means we should retry */ - if(i == -2) - { + if (i == -2) { BIO_set_retry_special(b); - b->retry_reason=BIO_RR_ACCEPT; + b->retry_reason = BIO_RR_ACCEPT; return -1; - } + } - if (i < 0) return(i); + if (i < 0) + return (i); - bio=BIO_new_socket(i,BIO_CLOSE); - if (bio == NULL) goto err; + bio = BIO_new_socket(i, BIO_CLOSE); + if (bio == NULL) + goto err; - BIO_set_callback(bio,BIO_get_callback(b)); - BIO_set_callback_arg(bio,BIO_get_callback_arg(b)); + BIO_set_callback(bio, BIO_get_callback(b)); + BIO_set_callback_arg(bio, BIO_get_callback_arg(b)); - if (c->nbio) - { - if (!BIO_socket_nbio(i,1)) - { - BIOerr(BIO_F_ACPT_STATE,BIO_R_ERROR_SETTING_NBIO_ON_ACCEPTED_SOCKET); + if (c->nbio) { + if (!BIO_socket_nbio(i, 1)) { + BIOerr(BIO_F_ACPT_STATE, BIO_R_ERROR_SETTING_NBIO_ON_ACCEPTED_SOCKET); goto err; - } } + } /* If the accept BIO has an bio_chain, we dup it and * put the new socket at the end. */ - if (c->bio_chain != NULL) - { - if ((dbio=BIO_dup_chain(c->bio_chain)) == NULL) + if (c->bio_chain != NULL) { + if ((dbio = BIO_dup_chain(c->bio_chain)) == NULL) goto err; - if (!BIO_push(dbio,bio)) goto err; - bio=dbio; - } - if (BIO_push(b,bio) == NULL) goto err; + if (!BIO_push(dbio, bio)) goto err; + bio = dbio; + } + if (BIO_push(b, bio) + == NULL) goto err; + + c->state = ACPT_S_OK; + return (1); - c->state=ACPT_S_OK; - return(1); err: if (bio != NULL) BIO_free(bio); else if (s >= 0) close(s); - return(0); + return (0); /* break; */ case ACPT_S_OK: - if (b->next_bio == NULL) - { - c->state=ACPT_S_GET_ACCEPT_SOCKET; + if (b->next_bio == NULL) { + c->state = ACPT_S_GET_ACCEPT_SOCKET; goto again; - } - return(1); + } + return (1); /* break; */ - default: - return(0); + default: + return (0); /* break; */ - } - } +} -static int acpt_read(BIO *b, char *out, int outl) - { - int ret=0; +static int +acpt_read(BIO *b, char *out, int outl) +{ + int ret = 0; BIO_ACCEPT *data; BIO_clear_retry_flags(b); - data=(BIO_ACCEPT *)b->ptr; + data = (BIO_ACCEPT *)b->ptr; - while (b->next_bio == NULL) - { - ret=acpt_state(b,data); - if (ret <= 0) return(ret); - } + while (b->next_bio == NULL) { + ret = acpt_state(b, data); + if (ret <= 0) + return (ret); + } - ret=BIO_read(b->next_bio,out,outl); + ret = BIO_read(b->next_bio, out, outl); BIO_copy_next_retry(b); - return(ret); - } + return (ret); +} -static int acpt_write(BIO *b, const char *in, int inl) - { +static int +acpt_write(BIO *b, const char *in, int inl) +{ int ret; BIO_ACCEPT *data; BIO_clear_retry_flags(b); - data=(BIO_ACCEPT *)b->ptr; + data = (BIO_ACCEPT *)b->ptr; - while (b->next_bio == NULL) - { - ret=acpt_state(b,data); - if (ret <= 0) return(ret); - } + while (b->next_bio == NULL) { + ret = acpt_state(b, data); + if (ret <= 0) + return (ret); + } - ret=BIO_write(b->next_bio,in,inl); + ret = BIO_write(b->next_bio, in, inl); BIO_copy_next_retry(b); - return(ret); - } + return (ret); +} -static long acpt_ctrl(BIO *b, int cmd, long num, void *ptr) - { +static long +acpt_ctrl(BIO *b, int cmd, long num, void *ptr) +{ int *ip; - long ret=1; + long ret = 1; BIO_ACCEPT *data; char **pp; - data=(BIO_ACCEPT *)b->ptr; + data = (BIO_ACCEPT *)b->ptr; - switch (cmd) - { + switch (cmd) { case BIO_CTRL_RESET: - ret=0; - data->state=ACPT_S_BEFORE; + ret = 0; + data->state = ACPT_S_BEFORE; acpt_close_socket(b); - b->flags=0; + b->flags = 0; break; case BIO_C_DO_STATE_MACHINE: /* use this one to start the connection */ - ret=(long)acpt_state(b,data); + ret = (long)acpt_state(b, data); break; case BIO_C_SET_ACCEPT: - if (ptr != NULL) - { - if (num == 0) - { - b->init=1; + if (ptr != NULL) { + if (num == 0) { + b->init = 1; if (data->param_addr != NULL) OPENSSL_free(data->param_addr); - data->param_addr=BUF_strdup(ptr); - } - else if (num == 1) - { - data->accept_nbio=(ptr != NULL); - } - else if (num == 2) - { + data->param_addr = BUF_strdup(ptr); + } else if (num == 1) { + data->accept_nbio = (ptr != NULL); + } else if (num == 2) { if (data->bio_chain != NULL) BIO_free(data->bio_chain); - data->bio_chain=(BIO *)ptr; - } + data->bio_chain = (BIO *)ptr; } + } break; case BIO_C_SET_NBIO: - data->nbio=(int)num; + data->nbio = (int)num; break; case BIO_C_SET_FD: - b->init=1; + b->init = 1; b->num= *((int *)ptr); - data->accept_sock=b->num; - data->state=ACPT_S_GET_ACCEPT_SOCKET; - b->shutdown=(int)num; - b->init=1; + data->accept_sock = b->num; + data->state = ACPT_S_GET_ACCEPT_SOCKET; + b->shutdown = (int)num; + b->init = 1; break; case BIO_C_GET_FD: - if (b->init) - { - ip=(int *)ptr; + if (b->init) { + ip = (int *)ptr; if (ip != NULL) - *ip=data->accept_sock; - ret=data->accept_sock; - } - else - ret= -1; + *ip = data->accept_sock; + ret = data->accept_sock; + } else + ret = -1; break; case BIO_C_GET_ACCEPT: - if (b->init) - { - if (ptr != NULL) - { - pp=(char **)ptr; - *pp=data->param_addr; - } - else - ret= -1; - } - else - ret= -1; + if (b->init) { + if (ptr != NULL) { + pp = (char **)ptr; + *pp = data->param_addr; + } else + ret = -1; + } else + ret = -1; break; case BIO_CTRL_GET_CLOSE: - ret=b->shutdown; + ret = b->shutdown; break; case BIO_CTRL_SET_CLOSE: - b->shutdown=(int)num; + b->shutdown = (int)num; break; case BIO_CTRL_PENDING: case BIO_CTRL_WPENDING: - ret=0; + ret = 0; break; case BIO_CTRL_FLUSH: break; case BIO_C_SET_BIND_MODE: - data->bind_mode=(int)num; + data->bind_mode = (int)num; break; case BIO_C_GET_BIND_MODE: - ret=(long)data->bind_mode; + ret = (long)data->bind_mode; break; case BIO_CTRL_DUP: /* dbio=(BIO *)ptr; @@ -441,38 +431,41 @@ static long acpt_ctrl(BIO *b, int cmd, long num, void *ptr) BIO_set_port(dbio,data->param_port); if (data->param_hostname) BIO_set_hostname(dbio,data->param_hostname); - BIO_set_nbio(dbio,data->nbio); */ + BIO_set_nbio(dbio,data->nbio); +*/ break; default: - ret=0; + ret = 0; break; - } - return(ret); } - -static int acpt_puts(BIO *bp, const char *str) - { - int n,ret; - - n=strlen(str); - ret=acpt_write(bp,str,n); - return(ret); - } - -BIO *BIO_new_accept(char *str) - { + return (ret); +} + +static int +acpt_puts(BIO *bp, const char *str) +{ + int n, ret; + + n = strlen(str); + ret = acpt_write(bp, str, n); + return (ret); +} + +BIO +*BIO_new_accept(char *str) +{ BIO *ret; - ret=BIO_new(BIO_s_accept()); - if (ret == NULL) return(NULL); - if (BIO_set_accept_port(ret,str)) - return(ret); - else - { + ret = BIO_new(BIO_s_accept()); + if (ret == NULL) + return (NULL); + if (BIO_set_accept_port(ret, str)) + return (ret); + else { BIO_free(ret); - return(NULL); - } + return (NULL); } +} #endif diff --git a/src/lib/libcrypto/bio/bss_bio.c b/src/lib/libcrypto/bio/bss_bio.c index 52ef0ebcb3..a74fcfdabc 100644 --- a/src/lib/libcrypto/bio/bss_bio.c +++ b/src/lib/libcrypto/bio/bss_bio.c @@ -103,8 +103,7 @@ static int bio_puts(BIO *bio, const char *str); static int bio_make_pair(BIO *bio1, BIO *bio2); static void bio_destroy_pair(BIO *bio); -static BIO_METHOD methods_biop = -{ +static BIO_METHOD methods_biop = { BIO_TYPE_BIO, "BIO pair", bio_write, @@ -117,50 +116,51 @@ static BIO_METHOD methods_biop = NULL /* no bio_callback_ctrl */ }; -BIO_METHOD *BIO_s_bio(void) - { +BIO_METHOD +*BIO_s_bio(void) +{ return &methods_biop; - } +} + +struct bio_bio_st { + BIO *peer; /* NULL if buf == NULL. + * If peer != NULL, then peer->ptr is also a bio_bio_st, + * and its "peer" member points back to us. + * peer != NULL iff init != 0 in the BIO. */ -struct bio_bio_st -{ - BIO *peer; /* NULL if buf == NULL. - * If peer != NULL, then peer->ptr is also a bio_bio_st, - * and its "peer" member points back to us. - * peer != NULL iff init != 0 in the BIO. */ - /* This is for what we write (i.e. reading uses peer's struct): */ - int closed; /* valid iff peer != NULL */ - size_t len; /* valid iff buf != NULL; 0 if peer == NULL */ - size_t offset; /* valid iff buf != NULL; 0 if len == 0 */ + int closed; /* valid iff peer != NULL */ + size_t len; /* valid iff buf != NULL; 0 if peer == NULL */ + size_t offset; /* valid iff buf != NULL; 0 if len == 0 */ size_t size; char *buf; /* "size" elements (if != NULL) */ size_t request; /* valid iff peer != NULL; 0 if len != 0, - * otherwise set by peer to number of bytes - * it (unsuccessfully) tried to read, + * otherwise set by peer to number of bytes + * it (unsuccessfully) tried to read, * never more than buffer space (size-len) warrants. */ }; -static int bio_new(BIO *bio) - { +static int +bio_new(BIO *bio) +{ struct bio_bio_st *b; - + b = OPENSSL_malloc(sizeof *b); if (b == NULL) return 0; b->peer = NULL; - b->size = 17*1024; /* enough for one TLS record (just a default) */ + b->size = 17 * 1024; /* enough for one TLS record (just a default) */ b->buf = NULL; bio->ptr = b; return 1; - } +} - -static int bio_free(BIO *bio) - { +static int +bio_free(BIO *bio) +{ struct bio_bio_st *b; if (bio == NULL) @@ -171,21 +171,21 @@ static int bio_free(BIO *bio) if (b->peer) bio_destroy_pair(bio); - - if (b->buf != NULL) - { + + if (b->buf != NULL) { OPENSSL_free(b->buf); - } + } OPENSSL_free(b); return 1; - } +} -static int bio_read(BIO *bio, char *buf, int size_) - { +static int +bio_read(BIO *bio, char *buf, int size_) +{ size_t size = size_; size_t rest; struct bio_bio_st *b, *peer_b; @@ -207,12 +207,10 @@ static int bio_read(BIO *bio, char *buf, int size_) if (buf == NULL || size == 0) return 0; - if (peer_b->len == 0) - { + if (peer_b->len == 0) { if (peer_b->closed) return 0; /* writer has closed, and no data is left */ - else - { + else { BIO_set_retry_read(bio); /* buffer is empty */ if (size <= peer_b->size) peer_b->request = size; @@ -221,22 +219,22 @@ static int bio_read(BIO *bio, char *buf, int size_) * deliver in one write */ peer_b->request = peer_b->size; return -1; - } } + } /* we can read */ if (peer_b->len < size) size = peer_b->len; /* now read "size" bytes */ - + rest = size; - + assert(rest > 0); do /* one or two iterations */ - { + { size_t chunk; - + assert(rest <= peer_b->len); if (peer_b->offset + rest <= peer_b->size) chunk = rest; @@ -244,30 +242,26 @@ static int bio_read(BIO *bio, char *buf, int size_) /* wrap around ring buffer */ chunk = peer_b->size - peer_b->offset; assert(peer_b->offset + chunk <= peer_b->size); - + memcpy(buf, peer_b->buf + peer_b->offset, chunk); - + peer_b->len -= chunk; - if (peer_b->len) - { + if (peer_b->len) { peer_b->offset += chunk; assert(peer_b->offset <= peer_b->size); if (peer_b->offset == peer_b->size) peer_b->offset = 0; buf += chunk; - } - else - { + } else { /* buffer now empty, no need to advance "buf" */ assert(chunk == rest); peer_b->offset = 0; - } - rest -= chunk; } - while (rest); - + rest -= chunk; + } while (rest); + return size; - } +} /* non-copying interface: provide pointer to available data in buffer * bio_nread0: return number of available bytes @@ -277,32 +271,32 @@ static int bio_read(BIO *bio, char *buf, int size_) */ /* WARNING: The non-copying interface is largely untested as of yet * and may contain bugs. */ -static ossl_ssize_t bio_nread0(BIO *bio, char **buf) - { +static ossl_ssize_t +bio_nread0(BIO *bio, char **buf) +{ struct bio_bio_st *b, *peer_b; ossl_ssize_t num; - + BIO_clear_retry_flags(bio); if (!bio->init) return 0; - + b = bio->ptr; assert(b != NULL); assert(b->peer != NULL); peer_b = b->peer->ptr; assert(peer_b != NULL); assert(peer_b->buf != NULL); - + peer_b->request = 0; - - if (peer_b->len == 0) - { + + if (peer_b->len == 0) { char dummy; - + /* avoid code duplication -- nothing available for reading */ return bio_read(bio, &dummy, 1); /* returns 0 or -1 */ - } + } num = peer_b->len; if (peer_b->size < peer_b->offset + num) @@ -313,10 +307,11 @@ static ossl_ssize_t bio_nread0(BIO *bio, char **buf) if (buf != NULL) *buf = peer_b->buf + peer_b->offset; return num; - } +} -static ossl_ssize_t bio_nread(BIO *bio, char **buf, size_t num_) - { +static ossl_ssize_t +bio_nread(BIO *bio, char **buf, size_t num_) +{ struct bio_bio_st *b, *peer_b; ossl_ssize_t num, available; @@ -335,22 +330,21 @@ static ossl_ssize_t bio_nread(BIO *bio, char **buf, size_t num_) peer_b = b->peer->ptr; peer_b->len -= num; - if (peer_b->len) - { + if (peer_b->len) { peer_b->offset += num; assert(peer_b->offset <= peer_b->size); if (peer_b->offset == peer_b->size) peer_b->offset = 0; - } - else + } else peer_b->offset = 0; return num; - } +} -static int bio_write(BIO *bio, const char *buf, int num_) - { +static int +bio_write(BIO *bio, const char *buf, int num_) +{ size_t num = num_; size_t rest; struct bio_bio_st *b; @@ -360,38 +354,37 @@ static int bio_write(BIO *bio, const char *buf, int num_) if (!bio->init || buf == NULL || num == 0) return 0; - b = bio->ptr; + b = bio->ptr; + assert(b != NULL); assert(b->peer != NULL); assert(b->buf != NULL); b->request = 0; - if (b->closed) - { + if (b->closed) { /* we already closed */ BIOerr(BIO_F_BIO_WRITE, BIO_R_BROKEN_PIPE); return -1; - } + } assert(b->len <= b->size); - if (b->len == b->size) - { + if (b->len == b->size) { BIO_set_retry_write(bio); /* buffer is full */ return -1; - } + } /* we can write */ if (num > b->size - b->len) num = b->size - b->len; - + /* now write "num" bytes */ rest = num; - + assert(rest > 0); do /* one or two iterations */ - { + { size_t write_offset; size_t chunk; @@ -407,20 +400,19 @@ static int bio_write(BIO *bio, const char *buf, int num_) else /* wrap around ring buffer */ chunk = b->size - write_offset; - + memcpy(b->buf + write_offset, buf, chunk); - + b->len += chunk; assert(b->len <= b->size); - + rest -= chunk; buf += chunk; - } - while (rest); + } while (rest); return num; - } +} /* non-copying interface: provide pointer to region to write to * bio_nwrite0: check how much space is available @@ -428,8 +420,9 @@ static int bio_write(BIO *bio, const char *buf, int num_) * (example usage: bio_nwrite0(), write to buffer, bio_nwrite() * or just bio_nwrite(), write to buffer) */ -static ossl_ssize_t bio_nwrite0(BIO *bio, char **buf) - { +static ossl_ssize_t +bio_nwrite0(BIO *bio, char **buf) +{ struct bio_bio_st *b; size_t num; size_t write_offset; @@ -439,25 +432,24 @@ static ossl_ssize_t bio_nwrite0(BIO *bio, char **buf) if (!bio->init) return 0; - b = bio->ptr; + b = bio->ptr; + assert(b != NULL); assert(b->peer != NULL); assert(b->buf != NULL); b->request = 0; - if (b->closed) - { + if (b->closed) { BIOerr(BIO_F_BIO_NWRITE0, BIO_R_BROKEN_PIPE); return -1; - } + } assert(b->len <= b->size); - if (b->len == b->size) - { + if (b->len == b->size) { BIO_set_retry_write(bio); return -1; - } + } num = b->size - b->len; write_offset = b->offset + b->len; @@ -474,10 +466,11 @@ static ossl_ssize_t bio_nwrite0(BIO *bio, char **buf) assert(write_offset + num <= b->size); return num; - } +} -static ossl_ssize_t bio_nwrite(BIO *bio, char **buf, size_t num_) - { +static ossl_ssize_t +bio_nwrite(BIO *bio, char **buf, size_t num_) +{ struct bio_bio_st *b; ossl_ssize_t num, space; @@ -497,46 +490,39 @@ static ossl_ssize_t bio_nwrite(BIO *bio, char **buf, size_t num_) assert(b->len <= b->size); return num; - } +} -static long bio_ctrl(BIO *bio, int cmd, long num, void *ptr) - { +static long +bio_ctrl(BIO *bio, int cmd, long num, void *ptr) +{ long ret; struct bio_bio_st *b = bio->ptr; - + assert(b != NULL); - switch (cmd) - { - /* specific CTRL codes */ + switch (cmd) { + /* specific CTRL codes */ case BIO_C_SET_WRITE_BUF_SIZE: - if (b->peer) - { + if (b->peer) { BIOerr(BIO_F_BIO_CTRL, BIO_R_IN_USE); ret = 0; - } - else if (num == 0) - { + } else if (num == 0) { BIOerr(BIO_F_BIO_CTRL, BIO_R_INVALID_ARGUMENT); ret = 0; - } - else - { + } else { size_t new_size = num; - if (b->size != new_size) - { - if (b->buf) - { + if (b->size != new_size) { + if (b->buf) { OPENSSL_free(b->buf); b->buf = NULL; - } - b->size = new_size; } - ret = 1; + b->size = new_size; } + ret = 1; + } break; case BIO_C_GET_WRITE_BUF_SIZE: @@ -545,15 +531,15 @@ static long bio_ctrl(BIO *bio, int cmd, long num, void *ptr) case BIO_C_MAKE_BIO_PAIR: { - BIO *other_bio = ptr; - - if (bio_make_pair(bio, other_bio)) - ret = 1; - else - ret = 0; + BIO *other_bio = ptr; + + if (bio_make_pair(bio, other_bio)) + ret = 1; + else + ret = 0; } break; - + case BIO_C_DESTROY_BIO_PAIR: /* Affects both BIOs in the pair -- call just once! * Or let BIO_free(bio1); BIO_free(bio2); do the job. */ @@ -596,12 +582,12 @@ static long bio_ctrl(BIO *bio, int cmd, long num, void *ptr) /* prepare for non-copying read */ ret = (long) bio_nread0(bio, ptr); break; - + case BIO_C_NREAD: /* non-copying read */ ret = (long) bio_nread(bio, ptr, (size_t) num); break; - + case BIO_C_NWRITE0: /* prepare for non-copying write */ ret = (long) bio_nwrite0(bio, ptr); @@ -611,18 +597,18 @@ static long bio_ctrl(BIO *bio, int cmd, long num, void *ptr) /* non-copying write */ ret = (long) bio_nwrite(bio, ptr, (size_t) num); break; - - /* standard CTRL codes follow */ + + /* standard CTRL codes follow */ case BIO_CTRL_RESET: - if (b->buf != NULL) - { + if (b->buf != NULL) { b->len = 0; b->offset = 0; - } + } ret = 0; - break; + break; + case BIO_CTRL_GET_CLOSE: ret = bio->shutdown; @@ -634,13 +620,11 @@ static long bio_ctrl(BIO *bio, int cmd, long num, void *ptr) break; case BIO_CTRL_PENDING: - if (b->peer != NULL) - { + if (b->peer != NULL) { struct bio_bio_st *peer_b = b->peer->ptr; - + ret = (long) peer_b->len; - } - else + } else ret = 0; break; @@ -654,16 +638,16 @@ static long bio_ctrl(BIO *bio, int cmd, long num, void *ptr) case BIO_CTRL_DUP: /* See BIO_dup_chain for circumstances we have to expect. */ { - BIO *other_bio = ptr; - struct bio_bio_st *other_b; - - assert(other_bio != NULL); - other_b = other_bio->ptr; - assert(other_b != NULL); - - assert(other_b->buf == NULL); /* other_bio is always fresh */ - - other_b->size = b->size; + BIO *other_bio = ptr; + struct bio_bio_st *other_b; + + assert(other_bio != NULL); + other_b = other_bio->ptr; + assert(other_b != NULL); + + assert(other_b->buf == NULL); /* other_bio is always fresh */ + + other_b->size = b->size; } ret = 1; @@ -675,34 +659,34 @@ static long bio_ctrl(BIO *bio, int cmd, long num, void *ptr) case BIO_CTRL_EOF: { - BIO *other_bio = ptr; - - if (other_bio) - { - struct bio_bio_st *other_b = other_bio->ptr; - - assert(other_b != NULL); - ret = other_b->len == 0 && other_b->closed; - } - else - ret = 1; + BIO *other_bio = ptr; + + if (other_bio) { + struct bio_bio_st *other_b = other_bio->ptr; + + assert(other_b != NULL); + ret = other_b->len == 0 && other_b->closed; + } else + ret = 1; } break; default: ret = 0; - } - return ret; } + return ret; +} -static int bio_puts(BIO *bio, const char *str) - { +static int +bio_puts(BIO *bio, const char *str) +{ return bio_write(bio, str, strlen(str)); - } +} -static int bio_make_pair(BIO *bio1, BIO *bio2) - { +static int +bio_make_pair(BIO *bio1, BIO *bio2) +{ struct bio_bio_st *b1, *b2; assert(bio1 != NULL); @@ -710,37 +694,32 @@ static int bio_make_pair(BIO *bio1, BIO *bio2) b1 = bio1->ptr; b2 = bio2->ptr; - - if (b1->peer != NULL || b2->peer != NULL) - { + + if (b1->peer != NULL || b2->peer != NULL) { BIOerr(BIO_F_BIO_MAKE_PAIR, BIO_R_IN_USE); return 0; - } - - if (b1->buf == NULL) - { + } + + if (b1->buf == NULL) { b1->buf = OPENSSL_malloc(b1->size); - if (b1->buf == NULL) - { + if (b1->buf == NULL) { BIOerr(BIO_F_BIO_MAKE_PAIR, ERR_R_MALLOC_FAILURE); return 0; - } + } b1->len = 0; b1->offset = 0; - } - - if (b2->buf == NULL) - { + } + + if (b2->buf == NULL) { b2->buf = OPENSSL_malloc(b2->size); - if (b2->buf == NULL) - { + if (b2->buf == NULL) { BIOerr(BIO_F_BIO_MAKE_PAIR, ERR_R_MALLOC_FAILURE); return 0; - } + } b2->len = 0; b2->offset = 0; - } - + } + b1->peer = bio2; b1->closed = 0; b1->request = 0; @@ -752,18 +731,17 @@ static int bio_make_pair(BIO *bio1, BIO *bio2) bio2->init = 1; return 1; - } +} -static void bio_destroy_pair(BIO *bio) - { +static void +bio_destroy_pair(BIO *bio) +{ struct bio_bio_st *b = bio->ptr; - if (b != NULL) - { + if (b != NULL) { BIO *peer_bio = b->peer; - if (peer_bio != NULL) - { + if (peer_bio != NULL) { struct bio_bio_st *peer_b = peer_bio->ptr; assert(peer_b != NULL); @@ -774,151 +752,149 @@ static void bio_destroy_pair(BIO *bio) assert(peer_b->buf != NULL); peer_b->len = 0; peer_b->offset = 0; - + b->peer = NULL; bio->init = 0; assert(b->buf != NULL); b->len = 0; b->offset = 0; - } } } - +} + /* Exported convenience functions */ -int BIO_new_bio_pair(BIO **bio1_p, size_t writebuf1, - BIO **bio2_p, size_t writebuf2) - { - BIO *bio1 = NULL, *bio2 = NULL; - long r; - int ret = 0; - - bio1 = BIO_new(BIO_s_bio()); - if (bio1 == NULL) - goto err; - bio2 = BIO_new(BIO_s_bio()); - if (bio2 == NULL) - goto err; - - if (writebuf1) - { - r = BIO_set_write_buf_size(bio1, writebuf1); - if (!r) - goto err; - } - if (writebuf2) - { - r = BIO_set_write_buf_size(bio2, writebuf2); - if (!r) - goto err; - } - - r = BIO_make_bio_pair(bio1, bio2); - if (!r) - goto err; - ret = 1; - - err: - if (ret == 0) - { - if (bio1) - { - BIO_free(bio1); - bio1 = NULL; - } - if (bio2) - { - BIO_free(bio2); - bio2 = NULL; - } - } - - *bio1_p = bio1; - *bio2_p = bio2; - return ret; - } - -size_t BIO_ctrl_get_write_guarantee(BIO *bio) - { - return BIO_ctrl(bio, BIO_C_GET_WRITE_GUARANTEE, 0, NULL); +int +BIO_new_bio_pair(BIO **bio1_p, size_t writebuf1, BIO **bio2_p, size_t writebuf2) +{ + BIO *bio1 = NULL, *bio2 = NULL; + long r; + int ret = 0; + + bio1 = BIO_new(BIO_s_bio()); + if (bio1 == NULL) + goto err; + bio2 = BIO_new(BIO_s_bio()); + if (bio2 == NULL) + goto err; + + if (writebuf1) { + r = BIO_set_write_buf_size(bio1, writebuf1); + if (!r) + goto err; + } + if (writebuf2) { + r = BIO_set_write_buf_size(bio2, writebuf2); + if (!r) + goto err; } -size_t BIO_ctrl_get_read_request(BIO *bio) - { - return BIO_ctrl(bio, BIO_C_GET_READ_REQUEST, 0, NULL); + r = BIO_make_bio_pair(bio1, bio2); + if (!r) + goto err; + ret = 1; + + err: + if (ret == 0) { + if (bio1) { + BIO_free(bio1); + bio1 = NULL; + } + if (bio2) { + BIO_free(bio2); + bio2 = NULL; + } } -int BIO_ctrl_reset_read_request(BIO *bio) - { + *bio1_p = bio1; + *bio2_p = bio2; + return ret; +} + +size_t +BIO_ctrl_get_write_guarantee(BIO *bio) +{ + return BIO_ctrl(bio, BIO_C_GET_WRITE_GUARANTEE, 0, NULL); +} + +size_t +BIO_ctrl_get_read_request(BIO *bio) +{ + return BIO_ctrl(bio, BIO_C_GET_READ_REQUEST, 0, NULL); +} + +int +BIO_ctrl_reset_read_request(BIO *bio) +{ return (BIO_ctrl(bio, BIO_C_RESET_READ_REQUEST, 0, NULL) != 0); - } +} /* BIO_nread0/nread/nwrite0/nwrite are available only for BIO pairs for now * (conceivably some other BIOs could allow non-copying reads and writes too.) */ -int BIO_nread0(BIO *bio, char **buf) - { +int +BIO_nread0(BIO *bio, char **buf) +{ long ret; - if (!bio->init) - { + if (!bio->init) { BIOerr(BIO_F_BIO_NREAD0, BIO_R_UNINITIALIZED); return -2; - } + } ret = BIO_ctrl(bio, BIO_C_NREAD0, 0, buf); if (ret > INT_MAX) return INT_MAX; else return (int) ret; - } +} -int BIO_nread(BIO *bio, char **buf, int num) - { +int +BIO_nread(BIO *bio, char **buf, int num) +{ int ret; - if (!bio->init) - { + if (!bio->init) { BIOerr(BIO_F_BIO_NREAD, BIO_R_UNINITIALIZED); return -2; - } + } ret = (int) BIO_ctrl(bio, BIO_C_NREAD, num, buf); if (ret > 0) bio->num_read += ret; return ret; - } +} -int BIO_nwrite0(BIO *bio, char **buf) - { +int +BIO_nwrite0(BIO *bio, char **buf) +{ long ret; - if (!bio->init) - { + if (!bio->init) { BIOerr(BIO_F_BIO_NWRITE0, BIO_R_UNINITIALIZED); return -2; - } + } ret = BIO_ctrl(bio, BIO_C_NWRITE0, 0, buf); if (ret > INT_MAX) return INT_MAX; else return (int) ret; - } +} -int BIO_nwrite(BIO *bio, char **buf, int num) - { +int +BIO_nwrite(BIO *bio, char **buf, int num) +{ int ret; - if (!bio->init) - { + if (!bio->init) { BIOerr(BIO_F_BIO_NWRITE, BIO_R_UNINITIALIZED); return -2; - } + } ret = BIO_ctrl(bio, BIO_C_NWRITE, num, buf); if (ret > 0) bio->num_write += ret; return ret; - } +} diff --git a/src/lib/libcrypto/bio/bss_conn.c b/src/lib/libcrypto/bio/bss_conn.c index 5162e75c87..df34c49a4a 100644 --- a/src/lib/libcrypto/bio/bss_conn.c +++ b/src/lib/libcrypto/bio/bss_conn.c @@ -76,8 +76,7 @@ #endif -typedef struct bio_connect_st - { +typedef struct bio_connect_st { int state; char *param_hostname; @@ -95,8 +94,8 @@ typedef struct bio_connect_st /* called when the connection is initially made * callback(BIO,state,ret); The callback should return * 'ret'. state is for compatibility with the ssl info_callback */ - int (*info_callback)(const BIO *bio,int state,int ret); - } BIO_CONNECT; + int (*info_callback)(const BIO *bio, int state, int ret); +} BIO_CONNECT; static int conn_write(BIO *h, const char *buf, int num); static int conn_read(BIO *h, char *buf, int size); @@ -108,11 +107,10 @@ static long conn_callback_ctrl(BIO *h, int cmd, bio_info_cb *); static int conn_state(BIO *b, BIO_CONNECT *c); static void conn_close_socket(BIO *data); -BIO_CONNECT *BIO_CONNECT_new(void ); +BIO_CONNECT *BIO_CONNECT_new(void); void BIO_CONNECT_free(BIO_CONNECT *a); -static BIO_METHOD methods_connectp= - { +static BIO_METHOD methods_connectp = { BIO_TYPE_CONNECT, "socket connect", conn_write, @@ -123,530 +121,501 @@ static BIO_METHOD methods_connectp= conn_new, conn_free, conn_callback_ctrl, - }; +}; -static int conn_state(BIO *b, BIO_CONNECT *c) - { - int ret= -1,i; +static int +conn_state(BIO *b, BIO_CONNECT *c) +{ + int ret = -1, i; unsigned long l; - char *p,*q; - int (*cb)(const BIO *,int,int)=NULL; + char *p, *q; + int (*cb)(const BIO *, int, int) = NULL; if (c->info_callback != NULL) - cb=c->info_callback; + cb = c->info_callback; - for (;;) - { - switch (c->state) - { + for (;;) { + switch (c->state) { case BIO_CONN_S_BEFORE: - p=c->param_hostname; - if (p == NULL) - { - BIOerr(BIO_F_CONN_STATE,BIO_R_NO_HOSTNAME_SPECIFIED); + p = c->param_hostname; + if (p == NULL) { + BIOerr(BIO_F_CONN_STATE, BIO_R_NO_HOSTNAME_SPECIFIED); goto exit_loop; - } - for ( ; *p != '\0'; p++) - { - if ((*p == ':') || (*p == '/')) break; - } + } + for (; *p != '\0'; p++) { + if ((*p == ':') || (*p == '/')) + break; + } i= *p; - if ((i == ':') || (i == '/')) - { - - *(p++)='\0'; - if (i == ':') - { - for (q=p; *q; q++) - if (*q == '/') - { - *q='\0'; + if ((i == ':') || (i == '/')) { + *(p++) = '\0'; + if (i == ':') { + for (q = p; *q; q++) + if (*q == '/') { + *q = '\0'; break; - } + } if (c->param_port != NULL) OPENSSL_free(c->param_port); - c->param_port=BUF_strdup(p); - } + c->param_port = BUF_strdup(p); } + } - if (c->param_port == NULL) - { - BIOerr(BIO_F_CONN_STATE,BIO_R_NO_PORT_SPECIFIED); - ERR_add_error_data(2,"host=",c->param_hostname); + if (c->param_port == NULL) { + BIOerr(BIO_F_CONN_STATE, BIO_R_NO_PORT_SPECIFIED); + ERR_add_error_data(2, "host=", c->param_hostname); goto exit_loop; - } - c->state=BIO_CONN_S_GET_IP; + } + c->state = BIO_CONN_S_GET_IP; break; case BIO_CONN_S_GET_IP: - if (BIO_get_host_ip(c->param_hostname,&(c->ip[0])) <= 0) + if (BIO_get_host_ip(c->param_hostname, &(c->ip[0])) <= 0) goto exit_loop; - c->state=BIO_CONN_S_GET_PORT; + c->state = BIO_CONN_S_GET_PORT; break; case BIO_CONN_S_GET_PORT: - if (c->param_port == NULL) - { + if (c->param_port == NULL) { /* abort(); */ goto exit_loop; - } - else if (BIO_get_port(c->param_port,&c->port) <= 0) + } else if (BIO_get_port(c->param_port, &c->port) <= 0) goto exit_loop; - c->state=BIO_CONN_S_CREATE_SOCKET; + c->state = BIO_CONN_S_CREATE_SOCKET; break; case BIO_CONN_S_CREATE_SOCKET: /* now setup address */ - memset((char *)&c->them,0,sizeof(c->them)); - c->them.sin_family=AF_INET; - c->them.sin_port=htons((unsigned short)c->port); - l=(unsigned long) - ((unsigned long)c->ip[0]<<24L)| - ((unsigned long)c->ip[1]<<16L)| - ((unsigned long)c->ip[2]<< 8L)| - ((unsigned long)c->ip[3]); - c->them.sin_addr.s_addr=htonl(l); - c->state=BIO_CONN_S_CREATE_SOCKET; - - ret=socket(AF_INET,SOCK_STREAM,SOCKET_PROTOCOL); - if (ret == -1) - { - SYSerr(SYS_F_SOCKET,errno); - ERR_add_error_data(4,"host=",c->param_hostname, - ":",c->param_port); - BIOerr(BIO_F_CONN_STATE,BIO_R_UNABLE_TO_CREATE_SOCKET); + memset((char *)&c->them, 0, sizeof(c->them)); + c->them.sin_family = AF_INET; + c->them.sin_port = htons((unsigned short)c->port); + l = (unsigned long) + ((unsigned long)c->ip[0] << 24L)| + ((unsigned long)c->ip[1] << 16L)| + ((unsigned long)c->ip[2] << 8L)| + ((unsigned long)c->ip[3]); + c->them.sin_addr.s_addr = htonl(l); + c->state = BIO_CONN_S_CREATE_SOCKET; + + ret = socket(AF_INET, SOCK_STREAM, SOCKET_PROTOCOL); + if (ret == -1) { + SYSerr(SYS_F_SOCKET, errno); + ERR_add_error_data(4, "host=", + c->param_hostname, ":", c->param_port); + BIOerr(BIO_F_CONN_STATE, + BIO_R_UNABLE_TO_CREATE_SOCKET); goto exit_loop; - } - b->num=ret; - c->state=BIO_CONN_S_NBIO; + } + b->num = ret; + c->state = BIO_CONN_S_NBIO; break; case BIO_CONN_S_NBIO: - if (c->nbio) - { - if (!BIO_socket_nbio(b->num,1)) - { - BIOerr(BIO_F_CONN_STATE,BIO_R_ERROR_SETTING_NBIO); - ERR_add_error_data(4,"host=", - c->param_hostname, - ":",c->param_port); + if (c->nbio) { + if (!BIO_socket_nbio(b->num, 1)) { + BIOerr(BIO_F_CONN_STATE, + BIO_R_ERROR_SETTING_NBIO); + ERR_add_error_data(4, "host=", + c->param_hostname, ":", + c->param_port); goto exit_loop; - } } - c->state=BIO_CONN_S_CONNECT; + } + c->state = BIO_CONN_S_CONNECT; #if defined(SO_KEEPALIVE) && !defined(OPENSSL_SYS_MPE) - i=1; - i=setsockopt(b->num,SOL_SOCKET,SO_KEEPALIVE,(char *)&i,sizeof(i)); - if (i < 0) - { - SYSerr(SYS_F_SOCKET,errno); - ERR_add_error_data(4,"host=",c->param_hostname, - ":",c->param_port); - BIOerr(BIO_F_CONN_STATE,BIO_R_KEEPALIVE); + i = 1; + i = setsockopt(b->num, SOL_SOCKET, SO_KEEPALIVE,(char *)&i, sizeof(i)); + if (i < 0) { + SYSerr(SYS_F_SOCKET, errno); + ERR_add_error_data(4, "host=", + c->param_hostname, ":", c->param_port); + BIOerr(BIO_F_CONN_STATE, BIO_R_KEEPALIVE); goto exit_loop; - } + } #endif break; case BIO_CONN_S_CONNECT: BIO_clear_retry_flags(b); - ret=connect(b->num, - (struct sockaddr *)&c->them, - sizeof(c->them)); - b->retry_reason=0; - if (ret < 0) - { - if (BIO_sock_should_retry(ret)) - { + ret = connect(b->num, + (struct sockaddr *)&c->them, + sizeof(c->them)); + b->retry_reason = 0; + if (ret < 0) { + if (BIO_sock_should_retry(ret)) { BIO_set_retry_special(b); - c->state=BIO_CONN_S_BLOCKED_CONNECT; - b->retry_reason=BIO_RR_CONNECT; - } - else - { - SYSerr(SYS_F_CONNECT,errno); - ERR_add_error_data(4,"host=", - c->param_hostname, - ":",c->param_port); - BIOerr(BIO_F_CONN_STATE,BIO_R_CONNECT_ERROR); - } - goto exit_loop; + c->state = BIO_CONN_S_BLOCKED_CONNECT; + b->retry_reason = BIO_RR_CONNECT; + } else { + SYSerr(SYS_F_CONNECT, errno); + ERR_add_error_data(4, "host=", + c->param_hostname, ":", + c->param_port); + BIOerr(BIO_F_CONN_STATE, + BIO_R_CONNECT_ERROR); } - else - c->state=BIO_CONN_S_OK; + goto exit_loop; + } else + c->state = BIO_CONN_S_OK; break; case BIO_CONN_S_BLOCKED_CONNECT: - i=BIO_sock_error(b->num); - if (i) - { + i = BIO_sock_error(b->num); + if (i) { BIO_clear_retry_flags(b); - SYSerr(SYS_F_CONNECT,i); - ERR_add_error_data(4,"host=", - c->param_hostname, - ":",c->param_port); - BIOerr(BIO_F_CONN_STATE,BIO_R_NBIO_CONNECT_ERROR); - ret=0; + SYSerr(SYS_F_CONNECT, i); + ERR_add_error_data(4, "host=", + c->param_hostname, ":", c->param_port); + BIOerr(BIO_F_CONN_STATE, + BIO_R_NBIO_CONNECT_ERROR); + ret = 0; goto exit_loop; - } - else - c->state=BIO_CONN_S_OK; + } else + c->state = BIO_CONN_S_OK; break; case BIO_CONN_S_OK: - ret=1; + ret = 1; goto exit_loop; default: /* abort(); */ goto exit_loop; - } + } - if (cb != NULL) - { - if (!(ret=cb((BIO *)b,c->state,ret))) + if (cb != NULL) { + if (!(ret = cb((BIO *)b, c->state, ret))) goto end; - } } + } /* Loop does not exit */ exit_loop: if (cb != NULL) - ret=cb((BIO *)b,c->state,ret); + ret = cb((BIO *)b, c->state, ret); end: - return(ret); - } + return (ret); +} -BIO_CONNECT *BIO_CONNECT_new(void) - { +BIO_CONNECT +*BIO_CONNECT_new(void) +{ BIO_CONNECT *ret; - if ((ret=(BIO_CONNECT *)OPENSSL_malloc(sizeof(BIO_CONNECT))) == NULL) - return(NULL); - ret->state=BIO_CONN_S_BEFORE; - ret->param_hostname=NULL; - ret->param_port=NULL; - ret->info_callback=NULL; - ret->nbio=0; - ret->ip[0]=0; - ret->ip[1]=0; - ret->ip[2]=0; - ret->ip[3]=0; - ret->port=0; - memset((char *)&ret->them,0,sizeof(ret->them)); - return(ret); - } - -void BIO_CONNECT_free(BIO_CONNECT *a) - { - if(a == NULL) - return; + if ((ret = (BIO_CONNECT *)OPENSSL_malloc(sizeof(BIO_CONNECT))) == NULL) + return (NULL); + ret->state = BIO_CONN_S_BEFORE; + ret->param_hostname = NULL; + ret->param_port = NULL; + ret->info_callback = NULL; + ret->nbio = 0; + ret->ip[0] = 0; + ret->ip[1] = 0; + ret->ip[2] = 0; + ret->ip[3] = 0; + ret->port = 0; + memset((char *)&ret->them, 0, sizeof(ret->them)); + return (ret); +} + +void +BIO_CONNECT_free(BIO_CONNECT *a) +{ + if (a == NULL) + return; if (a->param_hostname != NULL) OPENSSL_free(a->param_hostname); if (a->param_port != NULL) OPENSSL_free(a->param_port); OPENSSL_free(a); - } - -BIO_METHOD *BIO_s_connect(void) - { - return(&methods_connectp); - } - -static int conn_new(BIO *bi) - { - bi->init=0; - bi->num=-1; - bi->flags=0; - if ((bi->ptr=(char *)BIO_CONNECT_new()) == NULL) - return(0); +} + +BIO_METHOD +*BIO_s_connect(void) +{ + return (&methods_connectp); +} + +static int +conn_new(BIO *bi) +{ + bi->init = 0; + bi->num = -1; + bi->flags = 0; + if ((bi->ptr = (char *)BIO_CONNECT_new()) == NULL) + return (0); else - return(1); - } + return (1); +} -static void conn_close_socket(BIO *bio) - { +static void +conn_close_socket(BIO *bio) +{ BIO_CONNECT *c; - c=(BIO_CONNECT *)bio->ptr; - if (bio->num != -1) - { + c = (BIO_CONNECT *)bio->ptr; + if (bio->num != -1) { /* Only do a shutdown if things were established */ if (c->state == BIO_CONN_S_OK) shutdown(bio->num, SHUT_RDWR); close(bio->num); - bio->num=-1; - } + bio->num = -1; } +} -static int conn_free(BIO *a) - { +static int +conn_free(BIO *a) +{ BIO_CONNECT *data; - if (a == NULL) return(0); - data=(BIO_CONNECT *)a->ptr; - - if (a->shutdown) - { + if (a == NULL) + return (0); + data = (BIO_CONNECT *)a->ptr; + + if (a->shutdown) { conn_close_socket(a); BIO_CONNECT_free(data); - a->ptr=NULL; - a->flags=0; - a->init=0; - } - return(1); + a->ptr = NULL; + a->flags = 0; + a->init = 0; } - -static int conn_read(BIO *b, char *out, int outl) - { - int ret=0; + return (1); +} + +static int +conn_read(BIO *b, char *out, int outl) +{ + int ret = 0; BIO_CONNECT *data; - data=(BIO_CONNECT *)b->ptr; - if (data->state != BIO_CONN_S_OK) - { - ret=conn_state(b,data); + data = (BIO_CONNECT *)b->ptr; + if (data->state != BIO_CONN_S_OK) { + ret = conn_state(b, data); if (ret <= 0) - return(ret); - } + return (ret); + } - if (out != NULL) - { + if (out != NULL) { errno = 0; - ret=read(b->num,out,outl); + ret = read(b->num, out, outl); BIO_clear_retry_flags(b); - if (ret <= 0) - { + if (ret <= 0) { if (BIO_sock_should_retry(ret)) BIO_set_retry_read(b); - } } - return(ret); } + return (ret); +} -static int conn_write(BIO *b, const char *in, int inl) - { +static int +conn_write(BIO *b, const char *in, int inl) +{ int ret; BIO_CONNECT *data; - data=(BIO_CONNECT *)b->ptr; - if (data->state != BIO_CONN_S_OK) - { - ret=conn_state(b,data); - if (ret <= 0) return(ret); - } + data = (BIO_CONNECT *)b->ptr; + if (data->state != BIO_CONN_S_OK) { + ret = conn_state(b, data); + if (ret <= 0) + return (ret); + } errno = 0; - ret=write(b->num,in,inl); + ret = write(b->num, in, inl); BIO_clear_retry_flags(b); - if (ret <= 0) - { + if (ret <= 0) { if (BIO_sock_should_retry(ret)) BIO_set_retry_write(b); - } - return(ret); } + return (ret); +} -static long conn_ctrl(BIO *b, int cmd, long num, void *ptr) - { +static long +conn_ctrl(BIO *b, int cmd, long num, void *ptr) +{ BIO *dbio; int *ip; const char **pptr; - long ret=1; + long ret = 1; BIO_CONNECT *data; - data=(BIO_CONNECT *)b->ptr; + data = (BIO_CONNECT *)b->ptr; - switch (cmd) - { + switch (cmd) { case BIO_CTRL_RESET: - ret=0; - data->state=BIO_CONN_S_BEFORE; + ret = 0; + data->state = BIO_CONN_S_BEFORE; conn_close_socket(b); - b->flags=0; + b->flags = 0; break; case BIO_C_DO_STATE_MACHINE: /* use this one to start the connection */ if (data->state != BIO_CONN_S_OK) - ret=(long)conn_state(b,data); + ret = (long)conn_state(b, data); else - ret=1; + ret = 1; break; case BIO_C_GET_CONNECT: - if (ptr != NULL) - { - pptr=(const char **)ptr; - if (num == 0) - { - *pptr=data->param_hostname; - - } - else if (num == 1) - { - *pptr=data->param_port; - } - else if (num == 2) - { - *pptr= (char *)&(data->ip[0]); - } - else if (num == 3) - { - *((int *)ptr)=data->port; - } - if ((!b->init) || (ptr == NULL)) - *pptr="not initialized"; - ret=1; + if (ptr != NULL) { + pptr = (const char **)ptr; + if (num == 0) { + *pptr = data->param_hostname; + + } else if (num == 1) { + *pptr = data->param_port; + } else if (num == 2) { + *pptr = (char *)&(data->ip[0]); + } else if (num == 3) { + *((int *)ptr) = data->port; } + if ((!b->init) || (ptr == NULL)) + *pptr = "not initialized"; + ret = 1; + } break; case BIO_C_SET_CONNECT: - if (ptr != NULL) - { - b->init=1; - if (num == 0) - { + if (ptr != NULL) { + b->init = 1; + if (num == 0) { if (data->param_hostname != NULL) OPENSSL_free(data->param_hostname); - data->param_hostname=BUF_strdup(ptr); - } - else if (num == 1) - { + data->param_hostname = BUF_strdup(ptr); + } else if (num == 1) { if (data->param_port != NULL) OPENSSL_free(data->param_port); - data->param_port=BUF_strdup(ptr); - } - else if (num == 2) - { + data->param_port = BUF_strdup(ptr); + } else if (num == 2) { char buf[16]; unsigned char *p = ptr; - (void) snprintf(buf,sizeof buf,"%d.%d.%d.%d", - p[0],p[1],p[2],p[3]); + (void) snprintf(buf, sizeof buf, "%d.%d.%d.%d", + p[0], p[1], p[2], p[3]); if (data->param_hostname != NULL) OPENSSL_free(data->param_hostname); - data->param_hostname=BUF_strdup(buf); - memcpy(&(data->ip[0]),ptr,4); - } - else if (num == 3) - { - char buf[DECIMAL_SIZE(int)+1]; + data->param_hostname = BUF_strdup(buf); + memcpy(&(data->ip[0]), ptr, 4); + } else if (num == 3) { + char buf[DECIMAL_SIZE(int) + 1]; - (void) snprintf(buf,sizeof buf,"%d",*(int *)ptr); + (void) snprintf(buf, sizeof buf, "%d", + *(int *)ptr); if (data->param_port != NULL) OPENSSL_free(data->param_port); - data->param_port=BUF_strdup(buf); + data->param_port = BUF_strdup(buf); data->port= *(int *)ptr; - } } + } break; case BIO_C_SET_NBIO: - data->nbio=(int)num; + data->nbio = (int)num; break; case BIO_C_GET_FD: - if (b->init) - { - ip=(int *)ptr; + if (b->init) { + ip = (int *)ptr; if (ip != NULL) - *ip=b->num; - ret=b->num; - } - else - ret= -1; + *ip = b->num; + ret = b->num; + } else + ret = -1; break; case BIO_CTRL_GET_CLOSE: - ret=b->shutdown; + ret = b->shutdown; break; case BIO_CTRL_SET_CLOSE: - b->shutdown=(int)num; + b->shutdown = (int)num; break; case BIO_CTRL_PENDING: case BIO_CTRL_WPENDING: - ret=0; + ret = 0; break; case BIO_CTRL_FLUSH: break; case BIO_CTRL_DUP: { - dbio=(BIO *)ptr; - if (data->param_port) - BIO_set_conn_port(dbio,data->param_port); - if (data->param_hostname) - BIO_set_conn_hostname(dbio,data->param_hostname); - BIO_set_nbio(dbio,data->nbio); - /* FIXME: the cast of the function seems unlikely to be a good idea */ - (void)BIO_set_info_callback(dbio,(bio_info_cb *)data->info_callback); + dbio = (BIO *)ptr; + if (data->param_port) + BIO_set_conn_port(dbio, data->param_port); + if (data->param_hostname) + BIO_set_conn_hostname(dbio, + data->param_hostname); + BIO_set_nbio(dbio, data->nbio); + /* FIXME: the cast of the function seems unlikely to be a good idea */ + (void)BIO_set_info_callback(dbio, + (bio_info_cb *)data->info_callback); } break; case BIO_CTRL_SET_CALLBACK: { #if 0 /* FIXME: Should this be used? -- Richard Levitte */ - BIOerr(BIO_F_CONN_CTRL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED); - ret = -1; + BIOerr(BIO_F_CONN_CTRL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED); + ret = -1; #else - ret=0; + ret = 0; #endif } break; case BIO_CTRL_GET_CALLBACK: { - int (**fptr)(const BIO *bio,int state,int xret); + int (**fptr)(const BIO *bio, int state, int xret); - fptr=(int (**)(const BIO *bio,int state,int xret))ptr; - *fptr=data->info_callback; + fptr = (int (**)(const BIO *bio, int state, int xret))ptr; + *fptr = data->info_callback; } break; default: - ret=0; + ret = 0; break; - } - return(ret); } + return (ret); +} -static long conn_callback_ctrl(BIO *b, int cmd, bio_info_cb *fp) - { - long ret=1; +static long +conn_callback_ctrl(BIO *b, int cmd, bio_info_cb *fp) +{ + long ret = 1; BIO_CONNECT *data; - data=(BIO_CONNECT *)b->ptr; + data = (BIO_CONNECT *)b->ptr; - switch (cmd) - { + switch (cmd) { case BIO_CTRL_SET_CALLBACK: { - data->info_callback=(int (*)(const struct bio_st *, int, int))fp; + data->info_callback = (int (*)(const struct bio_st *, int, int))fp; } break; default: - ret=0; + ret = 0; break; - } - return(ret); } - -static int conn_puts(BIO *bp, const char *str) - { - int n,ret; - - n=strlen(str); - ret=conn_write(bp,str,n); - return(ret); - } - -BIO *BIO_new_connect(char *str) - { + return (ret); +} + +static int +conn_puts(BIO *bp, const char *str) +{ + int n, ret; + + n = strlen(str); + ret = conn_write(bp, str, n); + return (ret); +} + +BIO +*BIO_new_connect(char *str) +{ BIO *ret; - ret=BIO_new(BIO_s_connect()); - if (ret == NULL) return(NULL); - if (BIO_set_conn_hostname(ret,str)) - return(ret); - else - { + ret = BIO_new(BIO_s_connect()); + if (ret == NULL) + return (NULL); + if (BIO_set_conn_hostname(ret, str)) + return (ret); + else { BIO_free(ret); - return(NULL); - } + return (NULL); } +} #endif - diff --git a/src/lib/libcrypto/bio/bss_dgram.c b/src/lib/libcrypto/bio/bss_dgram.c index 67a13ae845..330f6fc404 100644 --- a/src/lib/libcrypto/bio/bss_dgram.c +++ b/src/lib/libcrypto/bio/bss_dgram.c @@ -113,7 +113,8 @@ static long dgram_sctp_ctrl(BIO *h, int cmd, long arg1, void *arg2); static int dgram_sctp_new(BIO *h); static int dgram_sctp_free(BIO *data); #ifdef SCTP_AUTHENTICATION_EVENT -static void dgram_sctp_handle_auth_free_key_event(BIO *b, union sctp_notification *snp); +static void dgram_sctp_handle_auth_free_key_event(BIO *b, + union sctp_notification *snp); #endif #endif @@ -121,8 +122,7 @@ static int BIO_dgram_should_retry(int s); static void get_current_time(struct timeval *t); -static BIO_METHOD methods_dgramp= - { +static BIO_METHOD methods_dgramp = { BIO_TYPE_DGRAM, "datagram socket", dgram_write, @@ -133,11 +133,10 @@ static BIO_METHOD methods_dgramp= dgram_new, dgram_free, NULL, - }; +}; #ifndef OPENSSL_NO_SCTP -static BIO_METHOD methods_dgramp_sctp= - { +static BIO_METHOD methods_dgramp_sctp = { BIO_TYPE_DGRAM_SCTP, "datagram sctp socket", dgram_sctp_write, @@ -148,11 +147,10 @@ static BIO_METHOD methods_dgramp_sctp= dgram_sctp_new, dgram_sctp_free, NULL, - }; +}; #endif -typedef struct bio_dgram_data_st - { +typedef struct bio_dgram_data_st { union { struct sockaddr sa; struct sockaddr_in sa_in; @@ -165,18 +163,16 @@ typedef struct bio_dgram_data_st unsigned int mtu; struct timeval next_timeout; struct timeval socket_timeout; - } bio_dgram_data; +} bio_dgram_data; #ifndef OPENSSL_NO_SCTP -typedef struct bio_dgram_sctp_save_message_st - { - BIO *bio; - char *data; - int length; - } bio_dgram_sctp_save_message; +typedef struct bio_dgram_sctp_save_message_st { + BIO *bio; + char *data; + int length; +} bio_dgram_sctp_save_message; -typedef struct bio_dgram_sctp_data_st - { +typedef struct bio_dgram_sctp_data_st { union { struct sockaddr sa; struct sockaddr_in sa_in; @@ -198,79 +194,88 @@ typedef struct bio_dgram_sctp_data_st int save_shutdown; int peer_auth_tested; bio_dgram_sctp_save_message saved_message; - } bio_dgram_sctp_data; +} bio_dgram_sctp_data; #endif -BIO_METHOD *BIO_s_datagram(void) - { - return(&methods_dgramp); - } +BIO_METHOD +*BIO_s_datagram(void) +{ + return (&methods_dgramp); +} -BIO *BIO_new_dgram(int fd, int close_flag) - { +BIO +*BIO_new_dgram(int fd, int close_flag) +{ BIO *ret; - ret=BIO_new(BIO_s_datagram()); - if (ret == NULL) return(NULL); - BIO_set_fd(ret,fd,close_flag); - return(ret); - } + ret = BIO_new(BIO_s_datagram()); + if (ret == NULL) + return (NULL); + BIO_set_fd(ret, fd, close_flag); + return (ret); +} -static int dgram_new(BIO *bi) - { +static int +dgram_new(BIO *bi) +{ bio_dgram_data *data = NULL; - bi->init=0; - bi->num=0; + bi->init = 0; + bi->num = 0; data = OPENSSL_malloc(sizeof(bio_dgram_data)); if (data == NULL) return 0; memset(data, 0x00, sizeof(bio_dgram_data)); - bi->ptr = data; + bi->ptr = data; - bi->flags=0; - return(1); - } + bi->flags = 0; + return (1); +} -static int dgram_free(BIO *a) - { +static int +dgram_free(BIO *a) +{ bio_dgram_data *data; - if (a == NULL) return(0); - if ( ! dgram_clear(a)) + if (a == NULL) + return (0); + if (!dgram_clear(a)) return 0; data = (bio_dgram_data *)a->ptr; - if(data != NULL) OPENSSL_free(data); + if (data != NULL) + OPENSSL_free(data); - return(1); - } + return (1); +} -static int dgram_clear(BIO *a) - { - if (a == NULL) return(0); - if (a->shutdown) - { - if (a->init) - { +static int +dgram_clear(BIO *a) +{ + if (a == NULL) + return (0); + if (a->shutdown) { + if (a->init) { shutdown(a->num, SHUT_RDWR); close(a->num); - } - a->init=0; - a->flags=0; } - return(1); + a->init = 0; + a->flags = 0; } + return (1); +} -static void dgram_adjust_rcv_timeout(BIO *b) - { +static void +dgram_adjust_rcv_timeout(BIO *b) +{ #if defined(SO_RCVTIMEO) bio_dgram_data *data = (bio_dgram_data *)b->ptr; - union { size_t s; int i; } sz = {0}; + union { size_t s; + int i; + } sz = {0}; /* Is a timer active? */ - if (data->next_timeout.tv_sec > 0 || data->next_timeout.tv_usec > 0) - { + if (data->next_timeout.tv_sec > 0 || data->next_timeout.tv_usec > 0) { struct timeval timenow, timeleft; /* Read current socket timeout */ @@ -279,20 +284,19 @@ static void dgram_adjust_rcv_timeout(BIO *b) sz.i = sizeof(timeout); if (getsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO, - (void*)&timeout, &sz.i) < 0) - { perror("getsockopt"); } - else - { + (void*)&timeout, &sz.i) < 0) { + perror("getsockopt"); + } else { data->socket_timeout.tv_sec = timeout / 1000; data->socket_timeout.tv_usec = (timeout % 1000) * 1000; - } + } #else sz.i = sizeof(data->socket_timeout); - if ( getsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO, - &(data->socket_timeout), (void *)&sz) < 0) - { perror("getsockopt"); } - else if (sizeof(sz.s)!=sizeof(sz.i) && sz.i==0) - OPENSSL_assert(sz.s<=sizeof(data->socket_timeout)); + if (getsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO, + &(data->socket_timeout), (void *)&sz) < 0) { + perror("getsockopt"); + } else if (sizeof(sz.s) != sizeof(sz.i) && sz.i == 0) + OPENSSL_assert(sz.s <= sizeof(data->socket_timeout)); #endif /* Get current time */ @@ -302,126 +306,128 @@ static void dgram_adjust_rcv_timeout(BIO *b) memcpy(&timeleft, &(data->next_timeout), sizeof(struct timeval)); timeleft.tv_sec -= timenow.tv_sec; timeleft.tv_usec -= timenow.tv_usec; - if (timeleft.tv_usec < 0) - { + if (timeleft.tv_usec < 0) { timeleft.tv_sec--; timeleft.tv_usec += 1000000; - } + } - if (timeleft.tv_sec < 0) - { + if (timeleft.tv_sec < 0) { timeleft.tv_sec = 0; timeleft.tv_usec = 1; - } + } /* Adjust socket timeout if next handhake message timer * will expire earlier. */ - if ((data->socket_timeout.tv_sec == 0 && data->socket_timeout.tv_usec == 0) || - (data->socket_timeout.tv_sec > timeleft.tv_sec) || - (data->socket_timeout.tv_sec == timeleft.tv_sec && - data->socket_timeout.tv_usec >= timeleft.tv_usec)) - { + if ((data->socket_timeout.tv_sec == 0 && + data->socket_timeout.tv_usec == 0) || + (data->socket_timeout.tv_sec > timeleft.tv_sec) || + (data->socket_timeout.tv_sec == timeleft.tv_sec && + data->socket_timeout.tv_usec >= timeleft.tv_usec)) { #ifdef OPENSSL_SYS_WINDOWS timeout = timeleft.tv_sec * 1000 + timeleft.tv_usec / 1000; if (setsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO, - (void*)&timeout, sizeof(timeout)) < 0) - { perror("setsockopt"); } + (void*)&timeout, sizeof(timeout)) < 0) { + perror("setsockopt"); + } #else - if ( setsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO, &timeleft, - sizeof(struct timeval)) < 0) - { perror("setsockopt"); } -#endif + if (setsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO, + &timeleft, sizeof(struct timeval)) < 0) { + perror("setsockopt"); } - } #endif + } } +#endif +} -static void dgram_reset_rcv_timeout(BIO *b) - { +static void +dgram_reset_rcv_timeout(BIO *b) +{ #if defined(SO_RCVTIMEO) bio_dgram_data *data = (bio_dgram_data *)b->ptr; /* Is a timer active? */ - if (data->next_timeout.tv_sec > 0 || data->next_timeout.tv_usec > 0) - { + if (data->next_timeout.tv_sec > 0 || data->next_timeout.tv_usec > 0) { #ifdef OPENSSL_SYS_WINDOWS int timeout = data->socket_timeout.tv_sec * 1000 + - data->socket_timeout.tv_usec / 1000; + data->socket_timeout.tv_usec / 1000; if (setsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO, - (void*)&timeout, sizeof(timeout)) < 0) - { perror("setsockopt"); } + (void*)&timeout, sizeof(timeout)) < 0) { + perror("setsockopt"); + } #else - if ( setsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO, &(data->socket_timeout), - sizeof(struct timeval)) < 0) - { perror("setsockopt"); } -#endif + if (setsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO, + &(data->socket_timeout), sizeof(struct timeval)) < 0) { + perror("setsockopt"); } #endif } +#endif +} -static int dgram_read(BIO *b, char *out, int outl) - { - int ret=0; +static int +dgram_read(BIO *b, char *out, int outl) +{ + int ret = 0; bio_dgram_data *data = (bio_dgram_data *)b->ptr; struct { - /* - * See commentary in b_sock.c. - */ - union { size_t s; int i; } len; - union { - struct sockaddr sa; - struct sockaddr_in sa_in; + /* + * See commentary in b_sock.c. + */ + union { + size_t s; + int i; + } len; + union { + struct sockaddr sa; + struct sockaddr_in sa_in; #if OPENSSL_USE_IPV6 - struct sockaddr_in6 sa_in6; + struct sockaddr_in6 sa_in6; #endif } peer; } sa; - sa.len.s=0; - sa.len.i=sizeof(sa.peer); + sa.len.s = 0; + sa.len.i = sizeof(sa.peer); - if (out != NULL) - { + if (out != NULL) { errno = 0; memset(&sa.peer, 0x00, sizeof(sa.peer)); dgram_adjust_rcv_timeout(b); - ret=recvfrom(b->num,out,outl,0,&sa.peer.sa,(void *)&sa.len); - if (sizeof(sa.len.i)!=sizeof(sa.len.s) && sa.len.i==0) - { - OPENSSL_assert(sa.len.s<=sizeof(sa.peer)); + ret = recvfrom(b->num, out, outl, 0, &sa.peer.sa,(void *)&sa.len); + if (sizeof(sa.len.i) != sizeof(sa.len.s) && sa.len.i == 0) { + OPENSSL_assert(sa.len.s <= sizeof(sa.peer)); sa.len.i = (int)sa.len.s; - } + } - if ( ! data->connected && ret >= 0) + if (! data->connected && ret >= 0) BIO_ctrl(b, BIO_CTRL_DGRAM_SET_PEER, 0, &sa.peer); BIO_clear_retry_flags(b); - if (ret < 0) - { - if (BIO_dgram_should_retry(ret)) - { + if (ret < 0) { + if (BIO_dgram_should_retry(ret)) { BIO_set_retry_read(b); data->_errno = errno; - } } + } dgram_reset_rcv_timeout(b); - } - return(ret); } + return (ret); +} -static int dgram_write(BIO *b, const char *in, int inl) - { +static int +dgram_write(BIO *b, const char *in, int inl) +{ int ret; bio_dgram_data *data = (bio_dgram_data *)b->ptr; errno = 0; - if ( data->connected ) - ret=write(b->num,in,inl); - else - { + if (data->connected) + ret = write(b->num, in, inl); + else { int peerlen = sizeof(data->peer); if (data->peer.sa.sa_family == AF_INET) @@ -431,33 +437,33 @@ static int dgram_write(BIO *b, const char *in, int inl) peerlen = sizeof(data->peer.sa_in6); #endif #if defined(NETWARE_CLIB) && defined(NETWARE_BSDSOCK) - ret=sendto(b->num, (char *)in, inl, 0, &data->peer.sa, peerlen); + ret = sendto(b->num, (char *)in, inl, 0, &data->peer.sa, peerlen); #else - ret=sendto(b->num, in, inl, 0, &data->peer.sa, peerlen); + ret = sendto(b->num, in, inl, 0, &data->peer.sa, peerlen); #endif - } + } BIO_clear_retry_flags(b); - if (ret <= 0) - { - if (BIO_dgram_should_retry(ret)) - { - BIO_set_retry_write(b); + if (ret <= 0) { + if (BIO_dgram_should_retry(ret)) { + BIO_set_retry_write(b); + data->_errno = errno; #if 0 /* higher layers are responsible for querying MTU, if necessary */ - if ( data->_errno == EMSGSIZE) + if (data->_errno == EMSGSIZE) /* retrieve the new MTU */ - BIO_ctrl(b, BIO_CTRL_DGRAM_QUERY_MTU, 0, NULL); + BIO_ctrl(b, BIO_CTRL_DGRAM_QUERY_MTU, 0, NULL); #endif - } } - return(ret); } + return (ret); +} -static long dgram_ctrl(BIO *b, int cmd, long num, void *ptr) - { - long ret=1; +static long +dgram_ctrl(BIO *b, int cmd, long num, void *ptr) +{ + long ret = 1; int *ip; struct sockaddr *to = NULL; bio_dgram_data *data = NULL; @@ -472,76 +478,73 @@ static long dgram_ctrl(BIO *b, int cmd, long num, void *ptr) #if OPENSSL_USE_IPV6 struct sockaddr_in6 s6; #endif - } addr; + } addr; #endif data = (bio_dgram_data *)b->ptr; - switch (cmd) - { + switch (cmd) { case BIO_CTRL_RESET: - num=0; + num = 0; case BIO_C_FILE_SEEK: - ret=0; + ret = 0; break; case BIO_C_FILE_TELL: case BIO_CTRL_INFO: - ret=0; + ret = 0; break; case BIO_C_SET_FD: dgram_clear(b); b->num= *((int *)ptr); - b->shutdown=(int)num; - b->init=1; + b->shutdown = (int)num; + b->init = 1; break; case BIO_C_GET_FD: - if (b->init) - { - ip=(int *)ptr; - if (ip != NULL) *ip=b->num; - ret=b->num; - } - else - ret= -1; + if (b->init) { + ip = (int *)ptr; + if (ip != NULL) + *ip = b->num; + ret = b->num; + } else + ret = -1; break; case BIO_CTRL_GET_CLOSE: - ret=b->shutdown; + ret = b->shutdown; break; case BIO_CTRL_SET_CLOSE: - b->shutdown=(int)num; + b->shutdown = (int)num; break; case BIO_CTRL_PENDING: case BIO_CTRL_WPENDING: - ret=0; + ret = 0; break; case BIO_CTRL_DUP: case BIO_CTRL_FLUSH: - ret=1; + ret = 1; break; case BIO_CTRL_DGRAM_CONNECT: to = (struct sockaddr *)ptr; #if 0 - if (connect(b->num, to, sizeof(struct sockaddr)) < 0) - { perror("connect"); ret = 0; } - else - { + if (connect(b->num, to, sizeof(struct sockaddr)) < 0) { + perror("connect"); + ret = 0; + } else { #endif - switch (to->sa_family) - { - case AF_INET: - memcpy(&data->peer,to,sizeof(data->peer.sa_in)); - break; + switch (to->sa_family) { + case AF_INET: + memcpy(&data->peer, to, sizeof(data->peer.sa_in)); + break; #if OPENSSL_USE_IPV6 - case AF_INET6: - memcpy(&data->peer,to,sizeof(data->peer.sa_in6)); - break; + case AF_INET6: + memcpy(&data->peer, to, sizeof(data->peer.sa_in6)); + break; #endif - default: - memcpy(&data->peer,to,sizeof(data->peer.sa)); - break; - } -#if 0 + default: + memcpy(&data->peer, to, sizeof(data->peer.sa)); + break; } +#if 0 + } #endif break; /* (Linux)kernel sets DF bit on outgoing IP packets */ @@ -549,31 +552,31 @@ static long dgram_ctrl(BIO *b, int cmd, long num, void *ptr) #if defined(OPENSSL_SYS_LINUX) && defined(IP_MTU_DISCOVER) && defined(IP_PMTUDISC_DO) addr_len = (socklen_t)sizeof(addr); memset((void *)&addr, 0, sizeof(addr)); - if (getsockname(b->num, &addr.sa, &addr_len) < 0) - { + if (getsockname(b->num, &addr.sa, &addr_len) < 0) { ret = 0; break; - } - switch (addr.sa.sa_family) - { + } + switch (addr.sa.sa_family) { case AF_INET: sockopt_val = IP_PMTUDISC_DO; - if ((ret = setsockopt(b->num, IPPROTO_IP, IP_MTU_DISCOVER, - &sockopt_val, sizeof(sockopt_val))) < 0) + if ((ret = setsockopt(b->num, IPPROTO_IP, + IP_MTU_DISCOVER, &sockopt_val, + sizeof(sockopt_val))) < 0) perror("setsockopt"); break; #if OPENSSL_USE_IPV6 && defined(IPV6_MTU_DISCOVER) && defined(IPV6_PMTUDISC_DO) case AF_INET6: sockopt_val = IPV6_PMTUDISC_DO; - if ((ret = setsockopt(b->num, IPPROTO_IPV6, IPV6_MTU_DISCOVER, - &sockopt_val, sizeof(sockopt_val))) < 0) + if ((ret = setsockopt(b->num, IPPROTO_IPV6, + IPV6_MTU_DISCOVER, &sockopt_val, + sizeof(sockopt_val))) < 0) perror("setsockopt"); break; #endif default: ret = -1; break; - } + } ret = -1; #else break; @@ -582,74 +585,67 @@ static long dgram_ctrl(BIO *b, int cmd, long num, void *ptr) #if defined(OPENSSL_SYS_LINUX) && defined(IP_MTU) addr_len = (socklen_t)sizeof(addr); memset((void *)&addr, 0, sizeof(addr)); - if (getsockname(b->num, &addr.sa, &addr_len) < 0) - { + if (getsockname(b->num, &addr.sa, &addr_len) < 0) { ret = 0; break; - } + } sockopt_len = sizeof(sockopt_val); - switch (addr.sa.sa_family) - { + switch (addr.sa.sa_family) { case AF_INET: - if ((ret = getsockopt(b->num, IPPROTO_IP, IP_MTU, (void *)&sockopt_val, - &sockopt_len)) < 0 || sockopt_val < 0) - { + if ((ret = getsockopt(b->num, IPPROTO_IP, IP_MTU, + (void *)&sockopt_val, &sockopt_len)) < 0 || + sockopt_val < 0) { ret = 0; - } - else - { + } else { /* we assume that the transport protocol is UDP and no * IP options are used. */ data->mtu = sockopt_val - 8 - 20; ret = data->mtu; - } + } break; #if OPENSSL_USE_IPV6 && defined(IPV6_MTU) case AF_INET6: - if ((ret = getsockopt(b->num, IPPROTO_IPV6, IPV6_MTU, (void *)&sockopt_val, - &sockopt_len)) < 0 || sockopt_val < 0) - { + if ((ret = getsockopt(b->num, IPPROTO_IPV6, IPV6_MTU, + (void *)&sockopt_val, &sockopt_len)) < 0 || + sockopt_val < 0) { ret = 0; - } - else - { + } else { /* we assume that the transport protocol is UDP and no * IPV6 options are used. */ data->mtu = sockopt_val - 8 - 40; ret = data->mtu; - } + } break; #endif - default: +default: ret = 0; break; - } + } #else ret = 0; #endif break; case BIO_CTRL_DGRAM_GET_FALLBACK_MTU: - switch (data->peer.sa.sa_family) - { - case AF_INET: - ret = 576 - 20 - 8; - break; + switch (data->peer.sa.sa_family) { + case AF_INET: + ret = 576 - 20 - 8; + break; #if OPENSSL_USE_IPV6 - case AF_INET6: + case AF_INET6: #ifdef IN6_IS_ADDR_V4MAPPED - if (IN6_IS_ADDR_V4MAPPED(&data->peer.sa_in6.sin6_addr)) - ret = 576 - 20 - 8; - else + if (IN6_IS_ADDR_V4MAPPED(&data->peer.sa_in6.sin6_addr)) + ret = 576 - 20 - 8; + else #endif - ret = 1280 - 40 - 8; - break; + ret = 1280 - 40 - 8; + break; #endif - default: - ret = 576 - 20 - 8; - break; - } + default: + ret = 576 - 20 - 8; + break; + } break; case BIO_CTRL_DGRAM_GET_MTU: return data->mtu; @@ -661,65 +657,59 @@ static long dgram_ctrl(BIO *b, int cmd, long num, void *ptr) case BIO_CTRL_DGRAM_SET_CONNECTED: to = (struct sockaddr *)ptr; - if ( to != NULL) - { + if (to != NULL) { data->connected = 1; - switch (to->sa_family) - { - case AF_INET: - memcpy(&data->peer,to,sizeof(data->peer.sa_in)); - break; -#if OPENSSL_USE_IPV6 - case AF_INET6: - memcpy(&data->peer,to,sizeof(data->peer.sa_in6)); - break; -#endif - default: - memcpy(&data->peer,to,sizeof(data->peer.sa)); - break; - } - } - else - { - data->connected = 0; - memset(&(data->peer), 0x00, sizeof(data->peer)); - } - break; - case BIO_CTRL_DGRAM_GET_PEER: - switch (data->peer.sa.sa_family) - { + switch (to->sa_family) { case AF_INET: - ret=sizeof(data->peer.sa_in); + memcpy(&data->peer, to, sizeof(data->peer.sa_in)); break; #if OPENSSL_USE_IPV6 case AF_INET6: - ret=sizeof(data->peer.sa_in6); + memcpy(&data->peer, to, sizeof(data->peer.sa_in6)); break; #endif default: - ret=sizeof(data->peer.sa); + memcpy(&data->peer, to, sizeof(data->peer.sa)); break; } - if (num==0 || num>ret) - num=ret; - memcpy(ptr,&data->peer,(ret=num)); + } else { + data->connected = 0; + memset(&(data->peer), 0x00, sizeof(data->peer)); + } + break; + case BIO_CTRL_DGRAM_GET_PEER: + switch (data->peer.sa.sa_family) { + case AF_INET: + ret = sizeof(data->peer.sa_in); + break; +#if OPENSSL_USE_IPV6 + case AF_INET6: + ret = sizeof(data->peer.sa_in6); + break; +#endif + default: + ret = sizeof(data->peer.sa); + break; + } + if (num == 0 || num > ret) + num = ret; + memcpy(ptr, &data->peer, (ret = num)); break; case BIO_CTRL_DGRAM_SET_PEER: to = (struct sockaddr *) ptr; - switch (to->sa_family) - { - case AF_INET: - memcpy(&data->peer,to,sizeof(data->peer.sa_in)); - break; + switch (to->sa_family) { + case AF_INET: + memcpy(&data->peer, to, sizeof(data->peer.sa_in)); + break; #if OPENSSL_USE_IPV6 - case AF_INET6: - memcpy(&data->peer,to,sizeof(data->peer.sa_in6)); - break; + case AF_INET6: + memcpy(&data->peer, to, sizeof(data->peer.sa_in6)); + break; #endif - default: - memcpy(&data->peer,to,sizeof(data->peer.sa)); - break; - } + default: + memcpy(&data->peer, to, sizeof(data->peer.sa)); + break; + } break; case BIO_CTRL_DGRAM_SET_NEXT_TIMEOUT: memcpy(&(data->next_timeout), ptr, sizeof(struct timeval)); @@ -728,47 +718,53 @@ static long dgram_ctrl(BIO *b, int cmd, long num, void *ptr) case BIO_CTRL_DGRAM_SET_RECV_TIMEOUT: #ifdef OPENSSL_SYS_WINDOWS { - struct timeval *tv = (struct timeval *)ptr; - int timeout = tv->tv_sec * 1000 + tv->tv_usec/1000; - if (setsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO, - (void*)&timeout, sizeof(timeout)) < 0) - { perror("setsockopt"); ret = -1; } + struct timeval *tv = (struct timeval *)ptr; + int timeout = tv->tv_sec * 1000 + tv->tv_usec/1000; + if (setsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO, + (void*)&timeout, sizeof(timeout)) < 0) { + perror("setsockopt"); + ret = -1; + } } #else - if ( setsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO, ptr, - sizeof(struct timeval)) < 0) - { perror("setsockopt"); ret = -1; } + if (setsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO, ptr, + sizeof(struct timeval)) < 0) { + perror("setsockopt"); + ret = -1; + } #endif break; case BIO_CTRL_DGRAM_GET_RECV_TIMEOUT: { - union { size_t s; int i; } sz = {0}; + union { + size_t s; + int i; + } sz = {0}; #ifdef OPENSSL_SYS_WINDOWS - int timeout; - struct timeval *tv = (struct timeval *)ptr; - - sz.i = sizeof(timeout); - if (getsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO, - (void*)&timeout, &sz.i) < 0) - { perror("getsockopt"); ret = -1; } - else - { - tv->tv_sec = timeout / 1000; - tv->tv_usec = (timeout % 1000) * 1000; - ret = sizeof(*tv); + int timeout; + struct timeval *tv = (struct timeval *)ptr; + + sz.i = sizeof(timeout); + if (getsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO, + (void*)&timeout, &sz.i) < 0) { + perror("getsockopt"); + ret = -1; + } else { + tv->tv_sec = timeout / 1000; + tv->tv_usec = (timeout % 1000) * 1000; + ret = sizeof(*tv); } #else - sz.i = sizeof(struct timeval); - if ( getsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO, - ptr, (void *)&sz) < 0) - { perror("getsockopt"); ret = -1; } - else if (sizeof(sz.s)!=sizeof(sz.i) && sz.i==0) - { - OPENSSL_assert(sz.s<=sizeof(struct timeval)); - ret = (int)sz.s; - } - else - ret = sz.i; + sz.i = sizeof(struct timeval); + if (getsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO, + ptr, (void *)&sz) < 0) { + perror("getsockopt"); + ret = -1; + } else if (sizeof(sz.s)!=sizeof(sz.i) && sz.i==0) { + OPENSSL_assert(sz.s <= sizeof(struct timeval)); + ret = (int)sz.s; + } else + ret = sz.i; #endif } break; @@ -777,47 +773,53 @@ static long dgram_ctrl(BIO *b, int cmd, long num, void *ptr) case BIO_CTRL_DGRAM_SET_SEND_TIMEOUT: #ifdef OPENSSL_SYS_WINDOWS { - struct timeval *tv = (struct timeval *)ptr; - int timeout = tv->tv_sec * 1000 + tv->tv_usec/1000; - if (setsockopt(b->num, SOL_SOCKET, SO_SNDTIMEO, - (void*)&timeout, sizeof(timeout)) < 0) - { perror("setsockopt"); ret = -1; } + struct timeval *tv = (struct timeval *)ptr; + int timeout = tv->tv_sec * 1000 + tv->tv_usec/1000; + if (setsockopt(b->num, SOL_SOCKET, SO_SNDTIMEO, + (void*)&timeout, sizeof(timeout)) < 0) { + perror("setsockopt"); + ret = -1; + } } #else - if ( setsockopt(b->num, SOL_SOCKET, SO_SNDTIMEO, ptr, - sizeof(struct timeval)) < 0) - { perror("setsockopt"); ret = -1; } + if (setsockopt(b->num, SOL_SOCKET, SO_SNDTIMEO, ptr, + sizeof(struct timeval)) < 0) { + perror("setsockopt"); + ret = -1; + } #endif break; case BIO_CTRL_DGRAM_GET_SEND_TIMEOUT: { - union { size_t s; int i; } sz = {0}; + union { + size_t s; + int i; + } sz = {0}; #ifdef OPENSSL_SYS_WINDOWS - int timeout; - struct timeval *tv = (struct timeval *)ptr; - - sz.i = sizeof(timeout); - if (getsockopt(b->num, SOL_SOCKET, SO_SNDTIMEO, - (void*)&timeout, &sz.i) < 0) - { perror("getsockopt"); ret = -1; } - else - { - tv->tv_sec = timeout / 1000; - tv->tv_usec = (timeout % 1000) * 1000; - ret = sizeof(*tv); + int timeout; + struct timeval *tv = (struct timeval *)ptr; + + sz.i = sizeof(timeout); + if (getsockopt(b->num, SOL_SOCKET, SO_SNDTIMEO, + (void*)&timeout, &sz.i) < 0) { + perror("getsockopt"); + ret = -1; + } else { + tv->tv_sec = timeout / 1000; + tv->tv_usec = (timeout % 1000) * 1000; + ret = sizeof(*tv); } #else - sz.i = sizeof(struct timeval); - if ( getsockopt(b->num, SOL_SOCKET, SO_SNDTIMEO, - ptr, (void *)&sz) < 0) - { perror("getsockopt"); ret = -1; } - else if (sizeof(sz.s)!=sizeof(sz.i) && sz.i==0) - { - OPENSSL_assert(sz.s<=sizeof(struct timeval)); - ret = (int)sz.s; - } - else - ret = sz.i; + sz.i = sizeof(struct timeval); + if (getsockopt(b->num, SOL_SOCKET, SO_SNDTIMEO, + ptr, (void *)&sz) < 0) { + perror("getsockopt"); + ret = -1; + } else if (sizeof(sz.s) != sizeof(sz.i) && sz.i == 0) { + OPENSSL_assert(sz.s <= sizeof(struct timeval)); + ret = (int)sz.s; + } else + ret = sz.i; #endif } break; @@ -826,52 +828,52 @@ static long dgram_ctrl(BIO *b, int cmd, long num, void *ptr) /* fall-through */ case BIO_CTRL_DGRAM_GET_RECV_TIMER_EXP: #ifdef OPENSSL_SYS_WINDOWS - if ( data->_errno == WSAETIMEDOUT) + if (data->_errno == WSAETIMEDOUT) #else - if ( data->_errno == EAGAIN) + if (data->_errno == EAGAIN) #endif - { + { ret = 1; data->_errno = 0; - } - else + } else ret = 0; break; #ifdef EMSGSIZE case BIO_CTRL_DGRAM_MTU_EXCEEDED: - if ( data->_errno == EMSGSIZE) - { + if (data->_errno == EMSGSIZE) { ret = 1; data->_errno = 0; - } - else + } else ret = 0; break; #endif default: - ret=0; + ret = 0; break; - } - return(ret); } + return (ret); +} -static int dgram_puts(BIO *bp, const char *str) - { - int n,ret; +static int +dgram_puts(BIO *bp, const char *str) +{ + int n, ret; - n=strlen(str); - ret=dgram_write(bp,str,n); - return(ret); - } + n = strlen(str); + ret = dgram_write(bp, str, n); + return (ret); +} #ifndef OPENSSL_NO_SCTP -BIO_METHOD *BIO_s_datagram_sctp(void) - { - return(&methods_dgramp_sctp); - } +BIO_METHOD +*BIO_s_datagram_sctp(void) +{ + return (&methods_dgramp_sctp); +} -BIO *BIO_new_dgram_sctp(int fd, int close_flag) - { +BIO +*BIO_new_dgram_sctp(int fd, int close_flag) +{ BIO *bio; int ret, optval = 20000; int auth_data = 0, auth_forward = 0; @@ -887,9 +889,10 @@ BIO *BIO_new_dgram_sctp(int fd, int close_flag) #endif #endif - bio=BIO_new(BIO_s_datagram_sctp()); - if (bio == NULL) return(NULL); - BIO_set_fd(bio,fd,close_flag); + bio = BIO_new(BIO_s_datagram_sctp()); + if (bio == NULL) + return (NULL); + BIO_set_fd(bio, fd, close_flag); /* Activate SCTP-AUTH for DATA and FORWARD-TSN chunks */ auth.sauth_chunk = OPENSSL_SCTP_DATA_CHUNK_TYPE; @@ -909,13 +912,14 @@ BIO *BIO_new_dgram_sctp(int fd, int close_flag) OPENSSL_assert(ret >= 0); for (p = (unsigned char*) authchunks->gauth_chunks; - p < (unsigned char*) authchunks + sockopt_len; - p += sizeof(uint8_t)) - { - if (*p == OPENSSL_SCTP_DATA_CHUNK_TYPE) auth_data = 1; - if (*p == OPENSSL_SCTP_FORWARD_CUM_TSN_CHUNK_TYPE) auth_forward = 1; - } - + p < (unsigned char*) authchunks + sockopt_len; + p += sizeof(uint8_t)) { + if (*p == OPENSSL_SCTP_DATA_CHUNK_TYPE) + auth_data = 1; + if (*p == OPENSSL_SCTP_FORWARD_CUM_TSN_CHUNK_TYPE) + auth_forward = 1; + } + OPENSSL_free(authchunks); OPENSSL_assert(auth_data); @@ -947,20 +951,22 @@ BIO *BIO_new_dgram_sctp(int fd, int close_flag) ret = setsockopt(fd, IPPROTO_SCTP, SCTP_PARTIAL_DELIVERY_POINT, &optval, sizeof(optval)); OPENSSL_assert(ret >= 0); - return(bio); - } + return (bio); +} -int BIO_dgram_is_sctp(BIO *bio) - { +int +BIO_dgram_is_sctp(BIO *bio) +{ return (BIO_method_type(bio) == BIO_TYPE_DGRAM_SCTP); - } +} -static int dgram_sctp_new(BIO *bi) - { +static int +dgram_sctp_new(BIO *bi) +{ bio_dgram_sctp_data *data = NULL; - bi->init=0; - bi->num=0; + bi->init = 0; + bi->num = 0; data = OPENSSL_malloc(sizeof(bio_dgram_sctp_data)); if (data == NULL) return 0; @@ -968,46 +974,50 @@ static int dgram_sctp_new(BIO *bi) #ifdef SCTP_PR_SCTP_NONE data->prinfo.pr_policy = SCTP_PR_SCTP_NONE; #endif - bi->ptr = data; + bi->ptr = data; - bi->flags=0; - return(1); - } + bi->flags = 0; + return (1); +} -static int dgram_sctp_free(BIO *a) - { +static int +dgram_sctp_free(BIO *a) +{ bio_dgram_sctp_data *data; - if (a == NULL) return(0); - if ( ! dgram_clear(a)) + if (a == NULL) + return (0); + if (! dgram_clear(a)) return 0; data = (bio_dgram_sctp_data *)a->ptr; - if(data != NULL) OPENSSL_free(data); + if (data != NULL) + OPENSSL_free(data); - return(1); - } + return (1); +} #ifdef SCTP_AUTHENTICATION_EVENT -void dgram_sctp_handle_auth_free_key_event(BIO *b, union sctp_notification *snp) - { +void +dgram_sctp_handle_auth_free_key_event(BIO *b, union sctp_notification *snp) +{ int ret; struct sctp_authkey_event* authkeyevent = &snp->sn_auth_event; - if (authkeyevent->auth_indication == SCTP_AUTH_FREE_KEY) - { + if (authkeyevent->auth_indication == SCTP_AUTH_FREE_KEY) { struct sctp_authkeyid authkeyid; /* delete key */ authkeyid.scact_keynumber = authkeyevent->auth_keynumber; ret = setsockopt(b->num, IPPROTO_SCTP, SCTP_AUTH_DELETE_KEY, - &authkeyid, sizeof(struct sctp_authkeyid)); - } + &authkeyid, sizeof(struct sctp_authkeyid)); } +} #endif -static int dgram_sctp_read(BIO *b, char *out, int outl) - { +static int +dgram_sctp_read(BIO *b, char *out, int outl) +{ int ret = 0, n = 0, i, optval; socklen_t optlen; bio_dgram_sctp_data *data = (bio_dgram_sctp_data *)b->ptr; @@ -1017,12 +1027,10 @@ static int dgram_sctp_read(BIO *b, char *out, int outl) struct cmsghdr *cmsg; char cmsgbuf[512]; - if (out != NULL) - { + if (out != NULL) { errno = 0; - do - { + do { memset(&data->rcvinfo, 0x00, sizeof(struct bio_dgram_sctp_rcvinfo)); iov.iov_base = out; iov.iov_len = outl; @@ -1035,15 +1043,12 @@ static int dgram_sctp_read(BIO *b, char *out, int outl) msg.msg_flags = 0; n = recvmsg(b->num, &msg, 0); - if (msg.msg_controllen > 0) - { - for (cmsg = CMSG_FIRSTHDR(&msg); cmsg; cmsg = CMSG_NXTHDR(&msg, cmsg)) - { + if (msg.msg_controllen > 0) { + for (cmsg = CMSG_FIRSTHDR(&msg); cmsg; cmsg = CMSG_NXTHDR(&msg, cmsg)) { if (cmsg->cmsg_level != IPPROTO_SCTP) continue; #ifdef SCTP_RCVINFO - if (cmsg->cmsg_type == SCTP_RCVINFO) - { + if (cmsg->cmsg_type == SCTP_RCVINFO) { struct sctp_rcvinfo *rcvinfo; rcvinfo = (struct sctp_rcvinfo *)CMSG_DATA(cmsg); @@ -1054,11 +1059,10 @@ static int dgram_sctp_read(BIO *b, char *out, int outl) data->rcvinfo.rcv_tsn = rcvinfo->rcv_tsn; data->rcvinfo.rcv_cumtsn = rcvinfo->rcv_cumtsn; data->rcvinfo.rcv_context = rcvinfo->rcv_context; - } + } #endif #ifdef SCTP_SNDRCV - if (cmsg->cmsg_type == SCTP_SNDRCV) - { + if (cmsg->cmsg_type == SCTP_SNDRCV) { struct sctp_sndrcvinfo *sndrcvinfo; sndrcvinfo = (struct sctp_sndrcvinfo *)CMSG_DATA(cmsg); @@ -1069,23 +1073,20 @@ static int dgram_sctp_read(BIO *b, char *out, int outl) data->rcvinfo.rcv_tsn = sndrcvinfo->sinfo_tsn; data->rcvinfo.rcv_cumtsn = sndrcvinfo->sinfo_cumtsn; data->rcvinfo.rcv_context = sndrcvinfo->sinfo_context; - } -#endif } +#endif } + } - if (n <= 0) - { + if (n <= 0) { if (n < 0) ret = n; break; - } + } - if (msg.msg_flags & MSG_NOTIFICATION) - { + if (msg.msg_flags & MSG_NOTIFICATION) { snp = (union sctp_notification*) out; - if (snp->sn_header.sn_type == SCTP_SENDER_DRY_EVENT) - { + if (snp->sn_header.sn_type == SCTP_SENDER_DRY_EVENT) { #ifdef SCTP_EVENT struct sctp_event event; #else @@ -1095,13 +1096,12 @@ static int dgram_sctp_read(BIO *b, char *out, int outl) /* If a message has been delayed until the socket * is dry, it can be sent now. */ - if (data->saved_message.length > 0) - { + if (data->saved_message.length > 0) { dgram_sctp_write(data->saved_message.bio, data->saved_message.data, - data->saved_message.length); + data->saved_message.length); OPENSSL_free(data->saved_message.data); data->saved_message.length = 0; - } + } /* disable sender dry event */ #ifdef SCTP_EVENT @@ -1121,7 +1121,7 @@ static int dgram_sctp_read(BIO *b, char *out, int outl) i = setsockopt(b->num, IPPROTO_SCTP, SCTP_EVENTS, &event, sizeof(struct sctp_event_subscribe)); OPENSSL_assert(i >= 0); #endif - } + } #ifdef SCTP_AUTHENTICATION_EVENT if (snp->sn_header.sn_type == SCTP_AUTHENTICATION_EVENT) @@ -1132,14 +1132,12 @@ static int dgram_sctp_read(BIO *b, char *out, int outl) data->handle_notifications(b, data->notification_context, (void*) out); memset(out, 0, outl); - } - else + } else ret += n; - } + } while ((msg.msg_flags & MSG_NOTIFICATION) && (msg.msg_flags & MSG_EOR) && (ret < outl)); - if (ret > 0 && !(msg.msg_flags & MSG_EOR)) - { + if (ret > 0 && !(msg.msg_flags & MSG_EOR)) { /* Partial message read, this should never happen! */ /* The buffer was too small, this means the peer sent @@ -1159,8 +1157,8 @@ static int dgram_sctp_read(BIO *b, char *out, int outl) * max record size (2^14 + 2048 + 13) */ optlen = (socklen_t) sizeof(int); - ret = getsockopt(b->num, IPPROTO_SCTP, SCTP_PARTIAL_DELIVERY_POINT, - &optval, &optlen); + ret = getsockopt(b->num, IPPROTO_SCTP, + SCTP_PARTIAL_DELIVERY_POINT, &optval, &optlen); OPENSSL_assert(ret >= 0); OPENSSL_assert(optval >= 18445); @@ -1173,21 +1171,18 @@ static int dgram_sctp_read(BIO *b, char *out, int outl) memset(out, 0, outl); BIO_set_retry_read(b); return -1; - } + } BIO_clear_retry_flags(b); - if (ret < 0) - { - if (BIO_dgram_should_retry(ret)) - { + if (ret < 0) { + if (BIO_dgram_should_retry(ret)) { BIO_set_retry_read(b); data->_errno = errno; - } } + } /* Test if peer uses SCTP-AUTH before continuing */ - if (!data->peer_auth_tested) - { + if (!data->peer_auth_tested) { int ii, auth_data = 0, auth_forward = 0; unsigned char *p; struct sctp_authchunks *authchunks; @@ -1199,29 +1194,30 @@ static int dgram_sctp_read(BIO *b, char *out, int outl) OPENSSL_assert(ii >= 0); for (p = (unsigned char*) authchunks->gauth_chunks; - p < (unsigned char*) authchunks + optlen; - p += sizeof(uint8_t)) - { - if (*p == OPENSSL_SCTP_DATA_CHUNK_TYPE) auth_data = 1; - if (*p == OPENSSL_SCTP_FORWARD_CUM_TSN_CHUNK_TYPE) auth_forward = 1; - } + p < (unsigned char*) authchunks + optlen; + p += sizeof(uint8_t)) { + if (*p == OPENSSL_SCTP_DATA_CHUNK_TYPE) + auth_data = 1; + if (*p == OPENSSL_SCTP_FORWARD_CUM_TSN_CHUNK_TYPE) + auth_forward = 1; + } OPENSSL_free(authchunks); - if (!auth_data || !auth_forward) - { - BIOerr(BIO_F_DGRAM_SCTP_READ,BIO_R_CONNECT_ERROR); + if (!auth_data || !auth_forward) { + BIOerr(BIO_F_DGRAM_SCTP_READ, BIO_R_CONNECT_ERROR); return -1; - } + } data->peer_auth_tested = 1; - } } - return(ret); } + return (ret); +} -static int dgram_sctp_write(BIO *b, const char *in, int inl) - { +static int +dgram_sctp_write(BIO *b, const char *in, int inl) +{ int ret; bio_dgram_sctp_data *data = (bio_dgram_sctp_data *)b->ptr; struct bio_dgram_sctp_sndinfo *sinfo = &(data->sndinfo); @@ -1256,8 +1252,7 @@ static int dgram_sctp_write(BIO *b, const char *in, int inl) * socket is not dry yet, we have to save it and send it * as soon as the socket gets dry. */ - if (data->save_shutdown && !BIO_dgram_sctp_wait_for_dry(b)) - { + if (data->save_shutdown && !BIO_dgram_sctp_wait_for_dry(b)) { data->saved_message.bio = b; data->saved_message.length = inl; data->saved_message.data = OPENSSL_malloc(inl); @@ -1317,20 +1312,20 @@ static int dgram_sctp_write(BIO *b, const char *in, int inl) ret = sendmsg(b->num, &msg, 0); BIO_clear_retry_flags(b); - if (ret <= 0) - { - if (BIO_dgram_should_retry(ret)) - { - BIO_set_retry_write(b); + if (ret <= 0) { + if (BIO_dgram_should_retry(ret)) { + BIO_set_retry_write(b); + data->_errno = errno; - } } - return(ret); } + return (ret); +} -static long dgram_sctp_ctrl(BIO *b, int cmd, long num, void *ptr) - { - long ret=1; +static long +dgram_sctp_ctrl(BIO *b, int cmd, long num, void *ptr) +{ + long ret = 1; bio_dgram_sctp_data *data = NULL; socklen_t sockopt_len = 0; struct sctp_authkeyid authkeyid; @@ -1338,8 +1333,7 @@ static long dgram_sctp_ctrl(BIO *b, int cmd, long num, void *ptr) data = (bio_dgram_sctp_data *)b->ptr; - switch (cmd) - { + switch (cmd) { case BIO_CTRL_DGRAM_QUERY_MTU: /* Set to maximum (2^14) * and ignore user input to enable transport @@ -1384,7 +1378,8 @@ static long dgram_sctp_ctrl(BIO *b, int cmd, long num, void *ptr) /* Get active key */ sockopt_len = sizeof(struct sctp_authkeyid); ret = getsockopt(b->num, IPPROTO_SCTP, SCTP_AUTH_ACTIVE_KEY, &authkeyid, &sockopt_len); - if (ret < 0) break; + if (ret < 0) + break; /* Add new key */ sockopt_len = sizeof(struct sctp_authkey) + 64 * sizeof(uint8_t); @@ -1400,12 +1395,14 @@ static long dgram_sctp_ctrl(BIO *b, int cmd, long num, void *ptr) memcpy(&authkey->sca_key[0], ptr, 64 * sizeof(uint8_t)); ret = setsockopt(b->num, IPPROTO_SCTP, SCTP_AUTH_KEY, authkey, sockopt_len); - if (ret < 0) break; + if (ret < 0) + break; /* Reset active key */ ret = setsockopt(b->num, IPPROTO_SCTP, SCTP_AUTH_ACTIVE_KEY, - &authkeyid, sizeof(struct sctp_authkeyid)); - if (ret < 0) break; + &authkeyid, sizeof(struct sctp_authkeyid)); + if (ret < 0) + break; break; case BIO_CTRL_DGRAM_SCTP_NEXT_AUTH_KEY: @@ -1414,13 +1411,15 @@ static long dgram_sctp_ctrl(BIO *b, int cmd, long num, void *ptr) /* Get active key */ sockopt_len = sizeof(struct sctp_authkeyid); ret = getsockopt(b->num, IPPROTO_SCTP, SCTP_AUTH_ACTIVE_KEY, &authkeyid, &sockopt_len); - if (ret < 0) break; + if (ret < 0) + break; /* Set active key */ authkeyid.scact_keynumber = authkeyid.scact_keynumber + 1; ret = setsockopt(b->num, IPPROTO_SCTP, SCTP_AUTH_ACTIVE_KEY, - &authkeyid, sizeof(struct sctp_authkeyid)); - if (ret < 0) break; + &authkeyid, sizeof(struct sctp_authkeyid)); + if (ret < 0) + break; /* CCS has been sent, so remember that and fall through * to check if we need to deactivate an old key @@ -1435,12 +1434,12 @@ static long dgram_sctp_ctrl(BIO *b, int cmd, long num, void *ptr) data->ccs_rcvd = 1; /* CSS has been both, received and sent, so deactivate an old key */ - if (data->ccs_rcvd == 1 && data->ccs_sent == 1) - { + if (data->ccs_rcvd == 1 && data->ccs_sent == 1) { /* Get active key */ sockopt_len = sizeof(struct sctp_authkeyid); ret = getsockopt(b->num, IPPROTO_SCTP, SCTP_AUTH_ACTIVE_KEY, &authkeyid, &sockopt_len); - if (ret < 0) break; + if (ret < 0) + break; /* Deactivate key or delete second last key if * SCTP_AUTHENTICATION_EVENT is not available. @@ -1449,22 +1448,23 @@ static long dgram_sctp_ctrl(BIO *b, int cmd, long num, void *ptr) #ifdef SCTP_AUTH_DEACTIVATE_KEY sockopt_len = sizeof(struct sctp_authkeyid); ret = setsockopt(b->num, IPPROTO_SCTP, SCTP_AUTH_DEACTIVATE_KEY, - &authkeyid, sockopt_len); - if (ret < 0) break; + &authkeyid, sockopt_len); + if (ret < 0) + break; #endif #ifndef SCTP_AUTHENTICATION_EVENT - if (authkeyid.scact_keynumber > 0) - { + if (authkeyid.scact_keynumber > 0) { authkeyid.scact_keynumber = authkeyid.scact_keynumber - 1; ret = setsockopt(b->num, IPPROTO_SCTP, SCTP_AUTH_DELETE_KEY, - &authkeyid, sizeof(struct sctp_authkeyid)); - if (ret < 0) break; - } + &authkeyid, sizeof(struct sctp_authkeyid)); + if (ret < 0) + break; + } #endif data->ccs_rcvd = 0; data->ccs_sent = 0; - } + } break; case BIO_CTRL_DGRAM_SCTP_GET_SNDINFO: /* Returns the size of the copied struct. */ @@ -1524,30 +1524,30 @@ static long dgram_sctp_ctrl(BIO *b, int cmd, long num, void *ptr) /* Pass to default ctrl function to * process SCTP unspecific commands */ - ret=dgram_ctrl(b, cmd, num, ptr); + ret = dgram_ctrl(b, cmd, num, ptr); break; - } - return(ret); } + return (ret); +} -int BIO_dgram_sctp_notification_cb(BIO *b, - void (*handle_notifications)(BIO *bio, void *context, void *buf), - void *context) - { +int +BIO_dgram_sctp_notification_cb(BIO *b, + void (*handle_notifications)(BIO *bio, void *context, void *buf), + void *context) +{ bio_dgram_sctp_data *data = (bio_dgram_sctp_data *) b->ptr; - if (handle_notifications != NULL) - { + if (handle_notifications != NULL) { data->handle_notifications = handle_notifications; data->notification_context = context; - } - else + } else return -1; return 0; - } +} -int BIO_dgram_sctp_wait_for_dry(BIO *b) +int +BIO_dgram_sctp_wait_for_dry(BIO *b) { int is_dry = 0; int n, sockflags, ret; @@ -1574,9 +1574,9 @@ int BIO_dgram_sctp_wait_for_dry(BIO *b) ret = getsockopt(b->num, IPPROTO_SCTP, SCTP_EVENTS, &event, &eventsize); if (ret < 0) return -1; - + event.sctp_sender_dry_event = 1; - + ret = setsockopt(b->num, IPPROTO_SCTP, SCTP_EVENTS, &event, sizeof(struct sctp_event_subscribe)); #endif if (ret < 0) @@ -1595,17 +1595,15 @@ int BIO_dgram_sctp_wait_for_dry(BIO *b) msg.msg_flags = 0; n = recvmsg(b->num, &msg, MSG_PEEK); - if (n <= 0) - { + if (n <= 0) { if ((n < 0) && (errno != EAGAIN) && (errno != EWOULDBLOCK)) return -1; else return 0; - } + } /* if we find a notification, process it and try again if necessary */ - while (msg.msg_flags & MSG_NOTIFICATION) - { + while (msg.msg_flags & MSG_NOTIFICATION) { memset(&snp, 0x00, sizeof(union sctp_notification)); iov.iov_base = (char *)&snp; iov.iov_len = sizeof(union sctp_notification); @@ -1618,16 +1616,14 @@ int BIO_dgram_sctp_wait_for_dry(BIO *b) msg.msg_flags = 0; n = recvmsg(b->num, &msg, 0); - if (n <= 0) - { + if (n <= 0) { if ((n < 0) && (errno != EAGAIN) && (errno != EWOULDBLOCK)) return -1; else return is_dry; - } - - if (snp.sn_header.sn_type == SCTP_SENDER_DRY_EVENT) - { + } + + if (snp.sn_header.sn_type == SCTP_SENDER_DRY_EVENT) { is_dry = 1; /* disable sender dry event */ @@ -1649,7 +1645,7 @@ int BIO_dgram_sctp_wait_for_dry(BIO *b) #endif if (ret < 0) return -1; - } + } #ifdef SCTP_AUTHENTICATION_EVENT if (snp.sn_header.sn_type == SCTP_AUTHENTICATION_EVENT) @@ -1672,34 +1668,32 @@ int BIO_dgram_sctp_wait_for_dry(BIO *b) msg.msg_flags = 0; /* if we have seen the dry already, don't wait */ - if (is_dry) - { + if (is_dry) { sockflags = fcntl(b->num, F_GETFL, 0); fcntl(b->num, F_SETFL, O_NONBLOCK); - } + } n = recvmsg(b->num, &msg, MSG_PEEK); - if (is_dry) - { + if (is_dry) { fcntl(b->num, F_SETFL, sockflags); - } + } - if (n <= 0) - { + if (n <= 0) { if ((n < 0) && (errno != EAGAIN) && (errno != EWOULDBLOCK)) return -1; else return is_dry; - } } + } /* read anything else */ return is_dry; } -int BIO_dgram_sctp_msg_waiting(BIO *b) - { +int +BIO_dgram_sctp_msg_waiting(BIO *b) +{ int n, sockflags; union sctp_notification snp; struct msghdr msg; @@ -1708,7 +1702,7 @@ int BIO_dgram_sctp_msg_waiting(BIO *b) /* Check if there are any messages waiting to be read */ do - { + { memset(&snp, 0x00, sizeof(union sctp_notification)); iov.iov_base = (char *)&snp; iov.iov_len = sizeof(union sctp_notification); @@ -1726,8 +1720,7 @@ int BIO_dgram_sctp_msg_waiting(BIO *b) fcntl(b->num, F_SETFL, sockflags); /* if notification, process and try again */ - if (n > 0 && (msg.msg_flags & MSG_NOTIFICATION)) - { + if (n > 0 && (msg.msg_flags & MSG_NOTIFICATION)) { #ifdef SCTP_AUTHENTICATION_EVENT if (snp.sn_header.sn_type == SCTP_AUTHENTICATION_EVENT) dgram_sctp_handle_auth_free_key_event(b, &snp); @@ -1747,34 +1740,35 @@ int BIO_dgram_sctp_msg_waiting(BIO *b) if (data->handle_notifications != NULL) data->handle_notifications(b, data->notification_context, (void*) &snp); - } + } - } while (n > 0 && (msg.msg_flags & MSG_NOTIFICATION)); + } while (n > 0 && (msg.msg_flags & MSG_NOTIFICATION)); /* Return 1 if there is a message to be read, return 0 otherwise. */ if (n > 0) return 1; else return 0; - } +} -static int dgram_sctp_puts(BIO *bp, const char *str) - { - int n,ret; +static int +dgram_sctp_puts(BIO *bp, const char *str) +{ + int n, ret; - n=strlen(str); - ret=dgram_sctp_write(bp,str,n); - return(ret); - } + n = strlen(str); + ret = dgram_sctp_write(bp, str, n); + return (ret); +} #endif -static int BIO_dgram_should_retry(int i) - { +static int +BIO_dgram_should_retry(int i) +{ int err; - if ((i == 0) || (i == -1)) - { - err=errno; + if ((i == 0) || (i == -1)) { + err = errno; #if defined(OPENSSL_SYS_WINDOWS) /* If the socket return value (i) is -1 @@ -1785,15 +1779,15 @@ static int BIO_dgram_should_retry(int i) */ #endif - return(BIO_dgram_non_fatal_error(err)); - } - return(0); + return (BIO_dgram_non_fatal_error(err)); } + return (0); +} -int BIO_dgram_non_fatal_error(int err) - { - switch (err) - { +int +BIO_dgram_non_fatal_error(int err) +{ + switch (err) { #if defined(OPENSSL_SYS_WINDOWS) # if defined(WSAEWOULDBLOCK) case WSAEWOULDBLOCK: @@ -1838,17 +1832,17 @@ int BIO_dgram_non_fatal_error(int err) case EALREADY: #endif - return(1); + return (1); /* break; */ default: break; - } - return(0); } + return (0); +} -static void get_current_time(struct timeval *t) - { +static void +get_current_time(struct timeval *t) { gettimeofday(t, NULL); - } +} #endif diff --git a/src/lib/libcrypto/bio/bss_fd.c b/src/lib/libcrypto/bio/bss_fd.c index ab18a56310..35ddd61359 100644 --- a/src/lib/libcrypto/bio/bss_fd.c +++ b/src/lib/libcrypto/bio/bss_fd.c @@ -90,9 +90,8 @@ static int fd_new(BIO *h); static int fd_free(BIO *data); int BIO_fd_should_retry(int s); -static BIO_METHOD methods_fdp= - { - BIO_TYPE_FD,"file descriptor", +static BIO_METHOD methods_fdp = { + BIO_TYPE_FD, "file descriptor", fd_write, fd_read, fd_puts, @@ -101,178 +100,182 @@ static BIO_METHOD methods_fdp= fd_new, fd_free, NULL, - }; +}; -BIO_METHOD *BIO_s_fd(void) - { - return(&methods_fdp); - } +BIO_METHOD +*BIO_s_fd(void) +{ + return (&methods_fdp); +} -BIO *BIO_new_fd(int fd,int close_flag) - { +BIO +*BIO_new_fd(int fd, int close_flag) +{ BIO *ret; - ret=BIO_new(BIO_s_fd()); - if (ret == NULL) return(NULL); - BIO_set_fd(ret,fd,close_flag); - return(ret); - } + ret = BIO_new(BIO_s_fd()); + if (ret == NULL) + return (NULL); + BIO_set_fd(ret, fd, close_flag); + return (ret); +} -static int fd_new(BIO *bi) - { - bi->init=0; - bi->num=-1; - bi->ptr=NULL; +static int +fd_new(BIO *bi) +{ + bi->init = 0; + bi->num = -1; + bi->ptr = NULL; bi->flags=BIO_FLAGS_UPLINK; /* essentially redundant */ - return(1); - } + return (1); +} -static int fd_free(BIO *a) - { - if (a == NULL) return(0); - if (a->shutdown) - { - if (a->init) - { +static int +fd_free(BIO *a) +{ + if (a == NULL) + return (0); + if (a->shutdown) { + if (a->init) { UP_close(a->num); - } - a->init=0; - a->flags=BIO_FLAGS_UPLINK; } - return(1); + a->init = 0; + a->flags = BIO_FLAGS_UPLINK; } - -static int fd_read(BIO *b, char *out,int outl) - { - int ret=0; + return (1); +} - if (out != NULL) - { +static int +fd_read(BIO *b, char *out, int outl) +{ + int ret = 0; + + if (out != NULL) { errno = 0; - ret=UP_read(b->num,out,outl); + ret = UP_read(b->num, out, outl); BIO_clear_retry_flags(b); - if (ret <= 0) - { + if (ret <= 0) { if (BIO_fd_should_retry(ret)) BIO_set_retry_read(b); - } } - return(ret); } + return (ret); +} -static int fd_write(BIO *b, const char *in, int inl) - { +static int +fd_write(BIO *b, const char *in, int inl) +{ int ret; errno = 0; - ret=UP_write(b->num,in,inl); + ret = UP_write(b->num, in, inl); BIO_clear_retry_flags(b); - if (ret <= 0) - { + if (ret <= 0) { if (BIO_fd_should_retry(ret)) BIO_set_retry_write(b); - } - return(ret); } + return (ret); +} -static long fd_ctrl(BIO *b, int cmd, long num, void *ptr) - { - long ret=1; +static long +fd_ctrl(BIO *b, int cmd, long num, void *ptr) +{ + long ret = 1; int *ip; - switch (cmd) - { + switch (cmd) { case BIO_CTRL_RESET: - num=0; + num = 0; case BIO_C_FILE_SEEK: - ret=(long)UP_lseek(b->num,num,0); + ret = (long)UP_lseek(b->num, num, 0); break; case BIO_C_FILE_TELL: case BIO_CTRL_INFO: - ret=(long)UP_lseek(b->num,0,1); + ret = (long)UP_lseek(b->num, 0, 1); break; case BIO_C_SET_FD: fd_free(b); b->num= *((int *)ptr); - b->shutdown=(int)num; - b->init=1; + b->shutdown = (int)num; + b->init = 1; break; case BIO_C_GET_FD: - if (b->init) - { - ip=(int *)ptr; - if (ip != NULL) *ip=b->num; - ret=b->num; - } - else - ret= -1; + if (b->init) { + ip = (int *)ptr; + if (ip != NULL) + *ip = b->num; + ret = b->num; + } else + ret = -1; break; case BIO_CTRL_GET_CLOSE: - ret=b->shutdown; + ret = b->shutdown; break; case BIO_CTRL_SET_CLOSE: - b->shutdown=(int)num; + b->shutdown = (int)num; break; case BIO_CTRL_PENDING: case BIO_CTRL_WPENDING: - ret=0; + ret = 0; break; case BIO_CTRL_DUP: case BIO_CTRL_FLUSH: - ret=1; + ret = 1; break; default: - ret=0; + ret = 0; break; - } - return(ret); } + return (ret); +} -static int fd_puts(BIO *bp, const char *str) - { - int n,ret; +static int +fd_puts(BIO *bp, const char *str) +{ + int n, ret; - n=strlen(str); - ret=fd_write(bp,str,n); - return(ret); - } + n = strlen(str); + ret = fd_write(bp, str, n); + return (ret); +} -static int fd_gets(BIO *bp, char *buf, int size) - { - int ret=0; - char *ptr=buf; - char *end=buf+size-1; +static int +fd_gets(BIO *bp, char *buf, int size) +{ + int ret = 0; + char *ptr = buf; + char *end = buf + size - 1; - while ( (ptr < end) && (fd_read(bp, ptr, 1) > 0) && (ptr[0] != '\n') ) + while ((ptr < end) && (fd_read(bp, ptr, 1) > 0) && (ptr[0] != '\n')) ptr++; - ptr[0]='\0'; + ptr[0] = '\0'; if (buf[0] != '\0') - ret=strlen(buf); - return(ret); - } + ret = strlen(buf); + return (ret); +} -int BIO_fd_should_retry(int i) - { +int +BIO_fd_should_retry(int i) +{ int err; - if ((i == 0) || (i == -1)) - { - err=errno; + if ((i == 0) || (i == -1)) { + err = errno; #if defined(OPENSSL_SYS_WINDOWS) && 0 /* more microsoft stupidity? perhaps not? Ben 4/1/99 */ if ((i == -1) && (err == 0)) - return(1); + return (1); #endif - return(BIO_fd_non_fatal_error(err)); - } - return(0); + return (BIO_fd_non_fatal_error(err)); } + return (0); +} -int BIO_fd_non_fatal_error(int err) - { - switch (err) - { +int +BIO_fd_non_fatal_error(int err) +{ + switch (err) { #ifdef EWOULDBLOCK # ifdef WSAEWOULDBLOCK @@ -309,11 +312,11 @@ int BIO_fd_non_fatal_error(int err) #ifdef EALREADY case EALREADY: #endif - return(1); + return (1); /* break; */ default: break; - } - return(0); } + return (0); +} #endif diff --git a/src/lib/libcrypto/bio/bss_file.c b/src/lib/libcrypto/bio/bss_file.c index 638572ab7f..794f503a69 100644 --- a/src/lib/libcrypto/bio/bss_file.c +++ b/src/lib/libcrypto/bio/bss_file.c @@ -102,8 +102,8 @@ static int file_gets(BIO *h, char *str, int size); static long file_ctrl(BIO *h, int cmd, long arg1, void *arg2); static int file_new(BIO *h); static int file_free(BIO *data); -static BIO_METHOD methods_filep= - { + +static BIO_METHOD methods_filep = { BIO_TYPE_FILE, "FILE pointer", file_write, @@ -114,15 +114,16 @@ static BIO_METHOD methods_filep= file_new, file_free, NULL, - }; +}; -BIO *BIO_new_file(const char *filename, const char *mode) - { +BIO +*BIO_new_file(const char *filename, const char *mode) +{ BIO *ret; - FILE *file=NULL; + FILE *file = NULL; #if defined(_WIN32) && defined(CP_UTF8) - int sz, len_0 = (int)strlen(filename)+1; + int sz, len_0 = (int)strlen(filename) + 1; DWORD flags; /* @@ -137,173 +138,171 @@ BIO *BIO_new_file(const char *filename, const char *mode) * ERROR_NO_UNICODE_TRANSLATION, in which case we fall * back to fopen... */ - if ((sz=MultiByteToWideChar(CP_UTF8,(flags=MB_ERR_INVALID_CHARS), - filename,len_0,NULL,0))>0 || - (GetLastError()==ERROR_INVALID_FLAGS && - (sz=MultiByteToWideChar(CP_UTF8,(flags=0), - filename,len_0,NULL,0))>0) - ) - { + if ((sz = MultiByteToWideChar(CP_UTF8,(flags = MB_ERR_INVALID_CHARS), + filename, len_0, NULL, 0)) > 0 || + (GetLastError() == ERROR_INVALID_FLAGS && + (sz = MultiByteToWideChar(CP_UTF8,(flags = 0), + filename, len_0, NULL, 0)) > 0)) { WCHAR wmode[8]; WCHAR *wfilename = _alloca(sz*sizeof(WCHAR)); - if (MultiByteToWideChar(CP_UTF8,flags, - filename,len_0,wfilename,sz) && - MultiByteToWideChar(CP_UTF8,0,mode,strlen(mode)+1, - wmode,sizeof(wmode)/sizeof(wmode[0])) && - (file=_wfopen(wfilename,wmode))==NULL && - (errno==ENOENT || errno==EBADF) - ) /* UTF-8 decode succeeded, but no file, filename + if (MultiByteToWideChar(CP_UTF8, flags, filename, len_0, + wfilename, sz) && MultiByteToWideChar(CP_UTF8, 0, mode, + strlen(mode) + 1, wmode, + sizeof(wmode) / sizeof(wmode[0])) && + (file = _wfopen(wfilename, wmode)) == NULL && + (errno == ENOENT || errno == EBADF) + ) /* UTF - 8 decode succeeded, but no file, filename * could still have been locale-ized... */ - file = fopen(filename,mode); - } - else if (GetLastError()==ERROR_NO_UNICODE_TRANSLATION) - { - file = fopen(filename,mode); - } + file = fopen(filename, mode); + } else if (GetLastError() == ERROR_NO_UNICODE_TRANSLATION) { + file = fopen(filename, mode); + } #else - file=fopen(filename,mode); + file = fopen(filename, mode); + #endif - if (file == NULL) - { + if (file == NULL) { SYSerr(SYS_F_FOPEN, errno); - ERR_add_error_data(5,"fopen('",filename,"','",mode,"')"); + ERR_add_error_data(5, "fopen('", filename, "', '", mode, "')"); if (errno == ENOENT) - BIOerr(BIO_F_BIO_NEW_FILE,BIO_R_NO_SUCH_FILE); + 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) - { + 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,BIO_CLOSE); - return(ret); + return (NULL); } -BIO *BIO_new_fp(FILE *stream, int close_flag) - { - BIO *ret; - - if ((ret=BIO_new(BIO_s_file())) == NULL) - return(NULL); - - BIO_set_flags(ret,BIO_FLAGS_UPLINK); /* redundant, left for documentation puposes */ - BIO_set_fp(ret,stream,close_flag); - return(ret); - } + BIO_clear_flags(ret, BIO_FLAGS_UPLINK); /* we did fopen -> we disengage UPLINK */ + BIO_set_fp(ret, file, BIO_CLOSE); + return (ret); +} -BIO_METHOD *BIO_s_file(void) - { - return(&methods_filep); - } +BIO +*BIO_new_fp(FILE *stream, int close_flag) +{ + BIO *ret; -static int file_new(BIO *bi) - { - bi->init=0; - bi->num=0; - bi->ptr=NULL; + if ((ret = BIO_new(BIO_s_file())) == NULL) + return (NULL); + + BIO_set_flags(ret, BIO_FLAGS_UPLINK); /* redundant, left for documentation puposes */ + BIO_set_fp(ret, stream, close_flag); + return (ret); +} + +BIO_METHOD +*BIO_s_file(void) +{ + return (&methods_filep); +} + +static int +file_new(BIO *bi) +{ + bi->init = 0; + bi->num = 0; + bi->ptr = NULL; bi->flags=BIO_FLAGS_UPLINK; /* default to UPLINK */ - return(1); - } - -static int file_free(BIO *a) - { - if (a == NULL) return(0); - if (a->shutdown) - { - if ((a->init) && (a->ptr != NULL)) - { + return (1); +} + +static int +file_free(BIO *a) +{ + if (a == NULL) + return (0); + if (a->shutdown) { + if ((a->init) && (a->ptr != NULL)) { if (a->flags&BIO_FLAGS_UPLINK) UP_fclose (a->ptr); else fclose (a->ptr); - a->ptr=NULL; - a->flags=BIO_FLAGS_UPLINK; - } - a->init=0; + a->ptr = NULL; + a->flags = BIO_FLAGS_UPLINK; } - return(1); + a->init = 0; } - -static int file_read(BIO *b, char *out, int outl) - { - int ret=0; + return (1); +} - if (b->init && (out != NULL)) - { +static int +file_read(BIO *b, char *out, int outl) +{ + int ret = 0; + + if (b->init && (out != NULL)) { if (b->flags&BIO_FLAGS_UPLINK) - ret=UP_fread(out,1,(int)outl,b->ptr); + ret = UP_fread(out, 1,(int)outl, b->ptr); else - ret=fread(out,1,(int)outl,(FILE *)b->ptr); - if(ret == 0 && (b->flags&BIO_FLAGS_UPLINK)?UP_ferror((FILE *)b->ptr):ferror((FILE *)b->ptr)) - { + ret = fread(out, 1,(int)outl,(FILE *)b->ptr); + if (ret == 0 && (b->flags & BIO_FLAGS_UPLINK) ? + UP_ferror((FILE *)b->ptr) : ferror((FILE *)b->ptr)) { SYSerr(SYS_F_FREAD, errno); - BIOerr(BIO_F_FILE_READ,ERR_R_SYS_LIB); - ret=-1; - } + BIOerr(BIO_F_FILE_READ, ERR_R_SYS_LIB); + ret = -1; } - return(ret); } + return (ret); +} -static int file_write(BIO *b, const char *in, int inl) - { - int ret=0; +static int +file_write(BIO *b, const char *in, int inl) +{ + int ret = 0; - if (b->init && (in != NULL)) - { + if (b->init && (in != NULL)) { if (b->flags&BIO_FLAGS_UPLINK) - ret=UP_fwrite(in,(int)inl,1,b->ptr); + ret = UP_fwrite(in,(int)inl, 1, b->ptr); else - ret=fwrite(in,(int)inl,1,(FILE *)b->ptr); + ret = fwrite(in,(int)inl, 1,(FILE *)b->ptr); if (ret) - ret=inl; + ret = inl; /* ret=fwrite(in,1,(int)inl,(FILE *)b->ptr); */ /* according to Tim Hudson , the commented * out version above can cause 'inl' write calls under * some stupid stdio implementations (VMS) */ - } - return(ret); } - -static long file_ctrl(BIO *b, int cmd, long num, void *ptr) - { - long ret=1; - FILE *fp=(FILE *)b->ptr; + return (ret); +} + +static long +file_ctrl(BIO *b, int cmd, long num, void *ptr) +{ + long ret = 1; + FILE *fp = (FILE *)b->ptr; FILE **fpp; char p[4]; - switch (cmd) - { + switch (cmd) { case BIO_C_FILE_SEEK: case BIO_CTRL_RESET: if (b->flags&BIO_FLAGS_UPLINK) - ret=(long)UP_fseek(b->ptr,num,0); + ret = (long)UP_fseek(b->ptr, num, 0); else - ret=(long)fseek(fp,num,0); + ret = (long)fseek(fp, num, 0); break; case BIO_CTRL_EOF: if (b->flags&BIO_FLAGS_UPLINK) - ret=(long)UP_feof(fp); + ret = (long)UP_feof(fp); else - ret=(long)feof(fp); + ret = (long)feof(fp); break; case BIO_C_FILE_TELL: case BIO_CTRL_INFO: if (b->flags&BIO_FLAGS_UPLINK) - ret=UP_ftell(b->ptr); + ret = UP_ftell(b->ptr); else - ret=ftell(fp); + ret = ftell(fp); break; case BIO_C_SET_FILE_PTR: file_free(b); - b->shutdown=(int)num&BIO_CLOSE; - b->ptr=ptr; - b->init=1; + b->shutdown = (int)num&BIO_CLOSE; + b->ptr = ptr; + b->init = 1; #if BIO_FLAGS_UPLINK!=0 #if defined(__MINGW32__) && defined(__MSVCRT__) && !defined(_IOB_ENTRIES) #define _IOB_ENTRIES 20 @@ -311,8 +310,8 @@ static long file_ctrl(BIO *b, int cmd, long num, void *ptr) #if defined(_IOB_ENTRIES) /* Safety net to catch purely internal BIO_set_fp calls */ if ((size_t)ptr >= (size_t)stdin && - (size_t)ptr < (size_t)(stdin+_IOB_ENTRIES)) - BIO_clear_flags(b,BIO_FLAGS_UPLINK); + (size_t)ptr < (size_t)(stdin + _IOB_ENTRIES)) + BIO_clear_flags(b, BIO_FLAGS_UPLINK); #endif #endif #ifdef UP_fsetmod @@ -322,102 +321,94 @@ static long file_ctrl(BIO *b, int cmd, long num, void *ptr) #endif { #if defined(OPENSSL_SYS_WINDOWS) - int fd = _fileno((FILE*)ptr); - if (num & BIO_FP_TEXT) - _setmode(fd,_O_TEXT); - else - _setmode(fd,_O_BINARY); + int fd = _fileno((FILE*)ptr); + if (num & BIO_FP_TEXT) + _setmode(fd, _O_TEXT); + else + _setmode(fd, _O_BINARY); #elif defined(OPENSSL_SYS_NETWARE) && defined(NETWARE_CLIB) - int fd = fileno((FILE*)ptr); - /* Under CLib there are differences in file modes */ - if (num & BIO_FP_TEXT) - setmode(fd,O_TEXT); - else - setmode(fd,O_BINARY); -#elif defined(OPENSSL_SYS_MSDOS) - int fd = fileno((FILE*)ptr); - /* Set correct text/binary mode */ - if (num & BIO_FP_TEXT) - _setmode(fd,_O_TEXT); - /* Dangerous to set stdin/stdout to raw (unless redirected) */ - else - { - if (fd == STDIN_FILENO || fd == STDOUT_FILENO) - { - if (isatty(fd) <= 0) - _setmode(fd,_O_BINARY); - } + int fd = fileno((FILE*)ptr); + /* Under CLib there are differences in file modes */ + if (num & BIO_FP_TEXT) + setmode(fd, O_TEXT); else - _setmode(fd,_O_BINARY); + setmode(fd, O_BINARY); +#elif defined(OPENSSL_SYS_MSDOS) + int fd = fileno((FILE*)ptr); + /* Set correct text/binary mode */ + if (num & BIO_FP_TEXT) + _setmode(fd, _O_TEXT); + /* Dangerous to set stdin/stdout to raw (unless redirected) */ + else { + if (fd == STDIN_FILENO || fd == STDOUT_FILENO) { + if (isatty(fd) <= 0) + _setmode(fd, _O_BINARY); + } else + _setmode(fd, _O_BINARY); } #elif defined(OPENSSL_SYS_OS2) || defined(OPENSSL_SYS_WIN32_CYGWIN) - int fd = fileno((FILE*)ptr); - if (num & BIO_FP_TEXT) - setmode(fd, O_TEXT); - else - setmode(fd, O_BINARY); + int fd = fileno((FILE*)ptr); + if (num & BIO_FP_TEXT) + setmode(fd, O_TEXT); + else + setmode(fd, O_BINARY); #endif } break; case BIO_C_SET_FILENAME: file_free(b); - b->shutdown=(int)num&BIO_CLOSE; - if (num & BIO_FP_APPEND) - { + b->shutdown = (int)num&BIO_CLOSE; + if (num & BIO_FP_APPEND) { if (num & BIO_FP_READ) - BUF_strlcpy(p,"a+",sizeof p); - else BUF_strlcpy(p,"a",sizeof p); - } - else if ((num & BIO_FP_READ) && (num & BIO_FP_WRITE)) - BUF_strlcpy(p,"r+",sizeof p); + BUF_strlcpy(p, "a+", sizeof p); + else BUF_strlcpy(p, "a", sizeof p); + } else if ((num & BIO_FP_READ) && (num & BIO_FP_WRITE)) + BUF_strlcpy(p, "r+", sizeof p); else if (num & BIO_FP_WRITE) - BUF_strlcpy(p,"w",sizeof p); + BUF_strlcpy(p, "w", sizeof p); else if (num & BIO_FP_READ) - BUF_strlcpy(p,"r",sizeof p); - else - { - BIOerr(BIO_F_FILE_CTRL,BIO_R_BAD_FOPEN_MODE); - ret=0; + BUF_strlcpy(p, "r", sizeof p); + else { + BIOerr(BIO_F_FILE_CTRL, BIO_R_BAD_FOPEN_MODE); + ret = 0; break; - } + } #if defined(OPENSSL_SYS_MSDOS) || defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_OS2) || defined(OPENSSL_SYS_WIN32_CYGWIN) if (!(num & BIO_FP_TEXT)) - strcat(p,"b"); + strcat(p, "b"); else - strcat(p,"t"); + strcat(p, "t"); #endif #if defined(OPENSSL_SYS_NETWARE) if (!(num & BIO_FP_TEXT)) - strcat(p,"b"); + strcat(p, "b"); else - strcat(p,"t"); + strcat(p, "t"); #endif - fp=fopen(ptr,p); - if (fp == NULL) - { + fp = fopen(ptr, p); + if (fp == NULL) { SYSerr(SYS_F_FOPEN, errno); - ERR_add_error_data(5,"fopen('",ptr,"','",p,"')"); - BIOerr(BIO_F_FILE_CTRL,ERR_R_SYS_LIB); - ret=0; + ERR_add_error_data(5, "fopen('", ptr, "', '", p, "')"); + BIOerr(BIO_F_FILE_CTRL, ERR_R_SYS_LIB); + ret = 0; break; - } - b->ptr=fp; - b->init=1; - BIO_clear_flags(b,BIO_FLAGS_UPLINK); /* we did fopen -> we disengage UPLINK */ + } + b->ptr = fp; + b->init = 1; + BIO_clear_flags(b, BIO_FLAGS_UPLINK); /* we did fopen -> we disengage UPLINK */ break; case BIO_C_GET_FILE_PTR: /* the ptr parameter is actually a FILE ** in this case. */ - if (ptr != NULL) - { - fpp=(FILE **)ptr; - *fpp=(FILE *)b->ptr; - } + if (ptr != NULL) { + fpp = (FILE **)ptr; + *fpp = (FILE *)b->ptr; + } break; case BIO_CTRL_GET_CLOSE: - ret=(long)b->shutdown; + ret = (long)b->shutdown; break; case BIO_CTRL_SET_CLOSE: - b->shutdown=(int)num; + b->shutdown = (int)num; break; case BIO_CTRL_FLUSH: if (b->flags&BIO_FLAGS_UPLINK) @@ -426,7 +417,7 @@ static long file_ctrl(BIO *b, int cmd, long num, void *ptr) fflush((FILE *)b->ptr); break; case BIO_CTRL_DUP: - ret=1; + ret = 1; break; case BIO_CTRL_WPENDING: @@ -434,44 +425,41 @@ static long file_ctrl(BIO *b, int cmd, long num, void *ptr) case BIO_CTRL_PUSH: case BIO_CTRL_POP: default: - ret=0; + ret = 0; break; - } - return(ret); } + return (ret); +} -static int file_gets(BIO *bp, char *buf, int size) - { - int ret=0; +static int +file_gets(BIO *bp, char *buf, int size) +{ + int ret = 0; - buf[0]='\0'; - if (bp->flags&BIO_FLAGS_UPLINK) - { - if (!UP_fgets(buf,size,bp->ptr)) + buf[0] = '\0'; + if (bp->flags&BIO_FLAGS_UPLINK) { + if (!UP_fgets(buf, size, bp->ptr)) goto err; - } - else - { - if (!fgets(buf,size,(FILE *)bp->ptr)) + } else { + if (!fgets(buf, size,(FILE *)bp->ptr)) goto err; - } - if (buf[0] != '\0') - ret=strlen(buf); - err: - return(ret); } + if (buf[0] != '\0') + ret = strlen(buf); +err: + return (ret); +} -static int file_puts(BIO *bp, const char *str) - { - int n,ret; +static int +file_puts(BIO *bp, const char *str) +{ + int n, ret; - n=strlen(str); - ret=file_write(bp,str,n); - return(ret); - } + n = strlen(str); + ret = file_write(bp, str, n); + return (ret); +} #endif /* OPENSSL_NO_STDIO */ #endif /* HEADER_BSS_FILE_C */ - - diff --git a/src/lib/libcrypto/bio/bss_log.c b/src/lib/libcrypto/bio/bss_log.c index 1cc413a916..9225af4df2 100644 --- a/src/lib/libcrypto/bio/bss_log.c +++ b/src/lib/libcrypto/bio/bss_log.c @@ -80,7 +80,7 @@ # if __INITIAL_POINTER_SIZE == 64 # pragma pointer_size save # pragma pointer_size 32 - void * _malloc32 (__size_t); +void * _malloc32 (__size_t); # pragma pointer_size restore # endif /* __INITIAL_POINTER_SIZE == 64 */ # endif /* __INITIAL_POINTER_SIZE && defined _ANSI_C_SOURCE */ @@ -131,9 +131,8 @@ static void xopenlog(BIO* bp, char* name, int level); static void xsyslog(BIO* bp, int priority, const char* string); static void xcloselog(BIO* bp); -static BIO_METHOD methods_slg= - { - BIO_TYPE_MEM,"syslog", +static BIO_METHOD methods_slg = { + BIO_TYPE_MEM, "syslog", slg_write, NULL, slg_puts, @@ -142,43 +141,46 @@ static BIO_METHOD methods_slg= slg_new, slg_free, NULL, - }; +}; -BIO_METHOD *BIO_s_log(void) - { - return(&methods_slg); - } +BIO_METHOD +*BIO_s_log(void) +{ + return (&methods_slg); +} -static int slg_new(BIO *bi) - { - bi->init=1; - bi->num=0; - bi->ptr=NULL; +static int +slg_new(BIO *bi) +{ + bi->init = 1; + bi->num = 0; + bi->ptr = NULL; xopenlog(bi, "application", LOG_DAEMON); - return(1); - } + return (1); +} -static int slg_free(BIO *a) - { - if (a == NULL) return(0); +static int +slg_free(BIO *a) +{ + if (a == NULL) + return (0); xcloselog(a); - return(1); - } - -static int slg_write(BIO *b, const char *in, int inl) - { - int ret= inl; + return (1); +} + +static int +slg_write(BIO *b, const char *in, int inl) +{ + int ret = inl; char* buf; char* pp; int priority, i; - static const struct - { + static const struct { int strl; char str[10]; int log_level; - } - mapping[] = - { + } + mapping[] = { { 6, "PANIC ", LOG_EMERG }, { 6, "EMERG ", LOG_EMERG }, { 4, "EMR ", LOG_EMERG }, @@ -199,69 +201,72 @@ static int slg_write(BIO *b, const char *in, int inl) { 6, "DEBUG ", LOG_DEBUG }, { 4, "DBG ", LOG_DEBUG }, { 0, "", LOG_ERR } /* The default */ - }; + }; - if((buf= (char *)OPENSSL_malloc(inl+ 1)) == NULL){ - return(0); + if ((buf = (char *)OPENSSL_malloc(inl + 1)) == NULL) { + return (0); } strncpy(buf, in, inl); - buf[inl]= '\0'; + buf[inl] = '\0'; i = 0; - while(strncmp(buf, mapping[i].str, mapping[i].strl) != 0) i++; + while (strncmp(buf, mapping[i].str, mapping[i].strl) != 0) + i++; priority = mapping[i].log_level; pp = buf + mapping[i].strl; xsyslog(b, priority, pp); OPENSSL_free(buf); - return(ret); - } + return (ret); +} -static long slg_ctrl(BIO *b, int cmd, long num, void *ptr) - { - switch (cmd) - { +static long +slg_ctrl(BIO *b, int cmd, long num, void *ptr) +{ + switch (cmd) { case BIO_CTRL_SET: xcloselog(b); xopenlog(b, ptr, num); break; default: break; - } - return(0); } + return (0); +} -static int slg_puts(BIO *bp, const char *str) - { - int n,ret; +static int +slg_puts(BIO *bp, const char *str) +{ + int n, ret; - n=strlen(str); - ret=slg_write(bp,str,n); - return(ret); - } + n = strlen(str); + ret = slg_write(bp, str, n); + return (ret); +} #if defined(OPENSSL_SYS_WIN32) -static void xopenlog(BIO* bp, char* name, int level) +static void +xopenlog(BIO* bp, char* name, int level) { if (check_winnt()) - bp->ptr = RegisterEventSourceA(NULL,name); + bp->ptr = RegisterEventSourceA(NULL, name); else bp->ptr = NULL; } -static void xsyslog(BIO *bp, int priority, const char *string) +static void +xsyslog(BIO *bp, int priority, const char *string) { LPCSTR lpszStrings[2]; - WORD evtype= EVENTLOG_ERROR_TYPE; - char pidbuf[DECIMAL_SIZE(DWORD)+4]; + WORD evtype = EVENTLOG_ERROR_TYPE; + char pidbuf[DECIMAL_SIZE(DWORD) + 4]; if (bp->ptr == NULL) return; - switch (priority) - { + switch (priority) { case LOG_EMERG: case LOG_ALERT: case LOG_CRIT: @@ -280,33 +285,37 @@ static void xsyslog(BIO *bp, int priority, const char *string) as error anyway. */ evtype = EVENTLOG_ERROR_TYPE; break; - } + } sprintf(pidbuf, "[%u] ", GetCurrentProcessId()); lpszStrings[0] = pidbuf; lpszStrings[1] = string; ReportEventA(bp->ptr, evtype, 0, 1024, NULL, 2, 0, - lpszStrings, NULL); + lpszStrings, NULL); } - -static void xcloselog(BIO* bp) + +static void +xcloselog(BIO* bp) { - if(bp->ptr) + if (bp->ptr) DeregisterEventSource((HANDLE)(bp->ptr)); - bp->ptr= NULL; + bp->ptr = NULL; } #elif defined(OPENSSL_SYS_VMS) static int VMS_OPC_target = LOG_DAEMON; -static void xopenlog(BIO* bp, char* name, int level) +static void +xopenlog(BIO* bp, char* name, int level) { - VMS_OPC_target = level; + VMS_OPC_target = level; + } -static void xsyslog(BIO *bp, int priority, const char *string) +static void +xsyslog(BIO *bp, int priority, const char *string) { struct dsc$descriptor_s opc_dsc; @@ -329,21 +338,28 @@ static void xsyslog(BIO *bp, int priority, const char *string) char buf[10240]; unsigned int len; - struct dsc$descriptor_s buf_dsc; + struct dsc$descriptor_s buf_dsc; $DESCRIPTOR(fao_cmd, "!AZ: !AZ"); char *priority_tag; - switch (priority) - { - case LOG_EMERG: priority_tag = "Emergency"; break; - case LOG_ALERT: priority_tag = "Alert"; break; - case LOG_CRIT: priority_tag = "Critical"; break; - case LOG_ERR: priority_tag = "Error"; break; - case LOG_WARNING: priority_tag = "Warning"; break; - case LOG_NOTICE: priority_tag = "Notice"; break; - case LOG_INFO: priority_tag = "Info"; break; - case LOG_DEBUG: priority_tag = "DEBUG"; break; - } + switch (priority) { + case LOG_EMERG: + priority_tag = "Emergency"; break; + case LOG_ALERT: + priority_tag = "Alert"; break; + case LOG_CRIT: + priority_tag = "Critical"; break; + case LOG_ERR: + priority_tag = "Error"; break; + case LOG_WARNING: + priority_tag = "Warning"; break; + case LOG_NOTICE: + priority_tag = "Notice"; break; + case LOG_INFO: + priority_tag = "Info"; break; + case LOG_DEBUG: + priority_tag = "DEBUG"; break; + } buf_dsc.dsc$b_dtype = DSC$K_DTYPE_T; buf_dsc.dsc$b_class = DSC$K_CLASS_S; @@ -353,7 +369,7 @@ static void xsyslog(BIO *bp, int priority, const char *string) lib$sys_fao(&fao_cmd, &len, &buf_dsc, priority_tag, string); /* We know there's an 8-byte header. That's documented. */ - opcdef_p = OPCDEF_MALLOC( 8+ len); + opcdef_p = OPCDEF_MALLOC( 8 + len); opcdef_p->opc$b_ms_type = OPC$_RQ_RQST; memcpy(opcdef_p->opc$z_ms_target_classes, &VMS_OPC_target, 3); opcdef_p->opc$l_ms_rqstid = 0; @@ -369,13 +385,15 @@ static void xsyslog(BIO *bp, int priority, const char *string) OPENSSL_free(opcdef_p); } -static void xcloselog(BIO* bp) +static void +xcloselog(BIO* bp) { } #else /* Unix/Watt32 */ -static void xopenlog(BIO* bp, char* name, int level) +static void +xopenlog(BIO* bp, char* name, int level) { #ifdef WATT32 /* djgpp/DOS */ openlog(name, LOG_PID|LOG_CONS|LOG_NDELAY, level); @@ -384,12 +402,14 @@ static void xopenlog(BIO* bp, char* name, int level) #endif } -static void xsyslog(BIO *bp, int priority, const char *string) +static void +xsyslog(BIO *bp, int priority, const char *string) { syslog(priority, "%s", string); } -static void xcloselog(BIO* bp) +static void +xcloselog(BIO* bp) { closelog(); } diff --git a/src/lib/libcrypto/bio/bss_mem.c b/src/lib/libcrypto/bio/bss_mem.c index 37d4194e4b..a5192202bd 100644 --- a/src/lib/libcrypto/bio/bss_mem.c +++ b/src/lib/libcrypto/bio/bss_mem.c @@ -68,8 +68,8 @@ static int mem_gets(BIO *h, char *str, int size); static long mem_ctrl(BIO *h, int cmd, long arg1, void *arg2); static int mem_new(BIO *h); static int mem_free(BIO *data); -static BIO_METHOD mem_method= - { + +static BIO_METHOD mem_method = { BIO_TYPE_MEM, "memory buffer", mem_write, @@ -80,28 +80,31 @@ static BIO_METHOD mem_method= mem_new, mem_free, NULL, - }; +}; /* bio->num is used to hold the value to return on 'empty', if it is * 0, should_retry is not set */ -BIO_METHOD *BIO_s_mem(void) - { - return(&mem_method); - } +BIO_METHOD +*BIO_s_mem(void) +{ + return (&mem_method); +} -BIO *BIO_new_mem_buf(void *buf, int len) +BIO +*BIO_new_mem_buf(void *buf, int len) { BIO *ret; BUF_MEM *b; size_t sz; if (!buf) { - BIOerr(BIO_F_BIO_NEW_MEM_BUF,BIO_R_NULL_PARAMETER); + BIOerr(BIO_F_BIO_NEW_MEM_BUF, BIO_R_NULL_PARAMETER); return NULL; } - sz = (len<0) ? strlen(buf) : (size_t)len; - if(!(ret = BIO_new(BIO_s_mem())) ) return NULL; + sz = (len < 0) ? strlen(buf) : (size_t)len; + if (!(ret = BIO_new(BIO_s_mem()))) + return NULL; b = (BUF_MEM *)ret->ptr; b->data = buf; b->length = sz; @@ -112,208 +115,205 @@ BIO *BIO_new_mem_buf(void *buf, int len) return ret; } -static int mem_new(BIO *bi) - { +static int +mem_new(BIO *bi) +{ BUF_MEM *b; - if ((b=BUF_MEM_new()) == NULL) - return(0); - bi->shutdown=1; - bi->init=1; - bi->num= -1; - bi->ptr=(char *)b; - return(1); - } + if ((b = BUF_MEM_new()) == NULL) + return (0); + bi->shutdown = 1; + bi->init = 1; + bi->num = -1; + bi->ptr = (char *)b; + return (1); +} -static int mem_free(BIO *a) - { - if (a == NULL) return(0); - if (a->shutdown) - { - if ((a->init) && (a->ptr != NULL)) - { +static int +mem_free(BIO *a) +{ + if (a == NULL) + return (0); + if (a->shutdown) { + if ((a->init) && (a->ptr != NULL)) { BUF_MEM *b; b = (BUF_MEM *)a->ptr; - if(a->flags & BIO_FLAGS_MEM_RDONLY) b->data = NULL; - BUF_MEM_free(b); - a->ptr=NULL; - } + if (a->flags & BIO_FLAGS_MEM_RDONLY) + b->data = NULL; + BUF_MEM_free(b); + a->ptr = NULL; } - return(1); } - -static int mem_read(BIO *b, char *out, int outl) - { - int ret= -1; + return (1); +} + +static int +mem_read(BIO *b, char *out, int outl) +{ + int ret = -1; BUF_MEM *bm; - bm=(BUF_MEM *)b->ptr; + bm = (BUF_MEM *)b->ptr; BIO_clear_retry_flags(b); - ret=(outl >=0 && (size_t)outl > bm->length)?(int)bm->length:outl; + ret = (outl >=0 && (size_t)outl > bm->length) ? (int)bm->length : outl; if ((out != NULL) && (ret > 0)) { - memcpy(out,bm->data,ret); - bm->length-=ret; - if(b->flags & BIO_FLAGS_MEM_RDONLY) bm->data += ret; + memcpy(out, bm->data, ret); + bm->length -= ret; + if (b->flags & BIO_FLAGS_MEM_RDONLY) + bm->data += ret; else { - memmove(&(bm->data[0]),&(bm->data[ret]),bm->length); + memmove(&(bm->data[0]), &(bm->data[ret]), bm->length); } - } else if (bm->length == 0) - { + } else if (bm->length == 0) { ret = b->num; if (ret != 0) BIO_set_retry_read(b); - } - return(ret); } + return (ret); +} -static int mem_write(BIO *b, const char *in, int inl) - { - int ret= -1; +static int +mem_write(BIO *b, const char *in, int inl) +{ + int ret = -1; int blen; BUF_MEM *bm; - bm=(BUF_MEM *)b->ptr; - if (in == NULL) - { - BIOerr(BIO_F_MEM_WRITE,BIO_R_NULL_PARAMETER); + bm = (BUF_MEM *)b->ptr; + if (in == NULL) { + BIOerr(BIO_F_MEM_WRITE, BIO_R_NULL_PARAMETER); goto end; - } + } - if(b->flags & BIO_FLAGS_MEM_RDONLY) { - BIOerr(BIO_F_MEM_WRITE,BIO_R_WRITE_TO_READ_ONLY_BIO); + if (b->flags & BIO_FLAGS_MEM_RDONLY) { + BIOerr(BIO_F_MEM_WRITE, BIO_R_WRITE_TO_READ_ONLY_BIO); goto end; } BIO_clear_retry_flags(b); - blen=bm->length; - if (BUF_MEM_grow_clean(bm,blen+inl) != (blen+inl)) + blen = bm->length; + if (BUF_MEM_grow_clean(bm, blen + inl) != (blen + inl)) goto end; - memcpy(&(bm->data[blen]),in,inl); - ret=inl; + memcpy(&(bm->data[blen]), in, inl); + ret = inl; end: - return(ret); - } + return (ret); +} -static long mem_ctrl(BIO *b, int cmd, long num, void *ptr) - { - long ret=1; +static long +mem_ctrl(BIO *b, int cmd, long num, void *ptr) +{ + long ret = 1; char **pptr; - BUF_MEM *bm=(BUF_MEM *)b->ptr; + BUF_MEM *bm = (BUF_MEM *)b->ptr; - switch (cmd) - { + switch (cmd) { case BIO_CTRL_RESET: - if (bm->data != NULL) - { + if (bm->data != NULL) { /* For read only case reset to the start again */ - if(b->flags & BIO_FLAGS_MEM_RDONLY) - { + if (b->flags & BIO_FLAGS_MEM_RDONLY) { bm->data -= bm->max - bm->length; bm->length = bm->max; - } - else - { - memset(bm->data,0,bm->max); - bm->length=0; - } + } else { + memset(bm->data, 0, bm->max); + bm->length = 0; } + } break; case BIO_CTRL_EOF: - ret=(long)(bm->length == 0); + ret = (long)(bm->length == 0); break; case BIO_C_SET_BUF_MEM_EOF_RETURN: - b->num=(int)num; + b->num = (int)num; break; case BIO_CTRL_INFO: - ret=(long)bm->length; - if (ptr != NULL) - { - pptr=(char **)ptr; - *pptr=(char *)&(bm->data[0]); - } + ret = (long)bm->length; + if (ptr != NULL) { + pptr = (char **)ptr; + *pptr = (char *)&(bm->data[0]); + } break; case BIO_C_SET_BUF_MEM: mem_free(b); - b->shutdown=(int)num; - b->ptr=ptr; + b->shutdown = (int)num; + b->ptr = ptr; break; case BIO_C_GET_BUF_MEM_PTR: - if (ptr != NULL) - { - pptr=(char **)ptr; - *pptr=(char *)bm; - } + if (ptr != NULL) { + pptr = (char **)ptr; + *pptr = (char *)bm; + } break; case BIO_CTRL_GET_CLOSE: - ret=(long)b->shutdown; + ret = (long)b->shutdown; break; case BIO_CTRL_SET_CLOSE: - b->shutdown=(int)num; + b->shutdown = (int)num; break; case BIO_CTRL_WPENDING: - ret=0L; + ret = 0L; break; case BIO_CTRL_PENDING: - ret=(long)bm->length; + ret = (long)bm->length; break; case BIO_CTRL_DUP: case BIO_CTRL_FLUSH: - ret=1; + ret = 1; break; case BIO_CTRL_PUSH: case BIO_CTRL_POP: default: - ret=0; + ret = 0; break; - } - return(ret); } + return (ret); +} -static int mem_gets(BIO *bp, char *buf, int size) - { - int i,j; - int ret= -1; +static int +mem_gets(BIO *bp, char *buf, int size) +{ + int i, j; + int ret = -1; char *p; - BUF_MEM *bm=(BUF_MEM *)bp->ptr; + BUF_MEM *bm = (BUF_MEM *)bp->ptr; BIO_clear_retry_flags(bp); - j=bm->length; - if ((size-1) < j) j=size-1; - if (j <= 0) - { - *buf='\0'; + j = bm->length; + if ((size - 1) < j) + j = size - 1; + if (j <= 0) { + *buf = '\0'; return 0; - } - p=bm->data; - for (i=0; idata; + for (i = 0; i < j; i++) { + if (p[i] == '\n') { i++; break; - } } + } /* * i is now the max num of bytes to copy, either j or up to * and including the first newline */ - i=mem_read(bp,buf,i); - if (i > 0) buf[i]='\0'; - ret=i; - return(ret); - } + i = mem_read(bp, buf, i); + if (i > 0) + buf[i] = '\0'; + ret = i; + return (ret); +} -static int mem_puts(BIO *bp, const char *str) - { - int n,ret; +static int +mem_puts(BIO *bp, const char *str) +{ + int n, ret; - n=strlen(str); - ret=mem_write(bp,str,n); + n = strlen(str); + ret = mem_write(bp, str, n); /* memory semantics is that it will always work */ - return(ret); - } - + return (ret); +} diff --git a/src/lib/libcrypto/bio/bss_null.c b/src/lib/libcrypto/bio/bss_null.c index 46b73339df..51aed2ac4b 100644 --- a/src/lib/libcrypto/bio/bss_null.c +++ b/src/lib/libcrypto/bio/bss_null.c @@ -68,8 +68,8 @@ static int null_gets(BIO *h, char *str, int size); static long null_ctrl(BIO *h, int cmd, long arg1, void *arg2); static int null_new(BIO *h); static int null_free(BIO *data); -static BIO_METHOD null_method= - { + +static BIO_METHOD null_method = { BIO_TYPE_NULL, "NULL", null_write, @@ -80,50 +80,56 @@ static BIO_METHOD null_method= null_new, null_free, NULL, - }; +}; -BIO_METHOD *BIO_s_null(void) - { - return(&null_method); - } +BIO_METHOD +*BIO_s_null(void) +{ + return (&null_method); +} -static int null_new(BIO *bi) - { - bi->init=1; - bi->num=0; - bi->ptr=(NULL); - return(1); - } +static int +null_new(BIO *bi) +{ + bi->init = 1; + bi->num = 0; + bi->ptr = (NULL); + return (1); +} -static int null_free(BIO *a) - { - if (a == NULL) return(0); - return(1); - } - -static int null_read(BIO *b, char *out, int outl) - { - return(0); - } +static int +null_free(BIO *a) +{ + if (a == NULL) + return (0); + return (1); +} -static int null_write(BIO *b, const char *in, int inl) - { - return(inl); - } +static int +null_read(BIO *b, char *out, int outl) +{ + return (0); +} + +static int +null_write(BIO *b, const char *in, int inl) +{ + return (inl); +} -static long null_ctrl(BIO *b, int cmd, long num, void *ptr) - { - long ret=1; +static long +null_ctrl(BIO *b, int cmd, long num, void *ptr) +{ + long ret = 1; - switch (cmd) - { + switch (cmd) { case BIO_CTRL_RESET: case BIO_CTRL_EOF: case BIO_CTRL_SET: case BIO_CTRL_SET_CLOSE: case BIO_CTRL_FLUSH: case BIO_CTRL_DUP: - ret=1; + ret = 1; break; case BIO_CTRL_GET_CLOSE: case BIO_CTRL_INFO: @@ -131,20 +137,22 @@ static long null_ctrl(BIO *b, int cmd, long num, void *ptr) case BIO_CTRL_PENDING: case BIO_CTRL_WPENDING: default: - ret=0; + ret = 0; break; - } - return(ret); } + return (ret); +} -static int null_gets(BIO *bp, char *buf, int size) - { - return(0); - } - -static int null_puts(BIO *bp, const char *str) - { - if (str == NULL) return(0); - return(strlen(str)); - } +static int +null_gets(BIO *bp, char *buf, int size) +{ + return (0); +} +static int +null_puts(BIO *bp, const char *str) +{ + if (str == NULL) + return (0); + return (strlen(str)); +} diff --git a/src/lib/libcrypto/bio/bss_rtcp.c b/src/lib/libcrypto/bio/bss_rtcp.c index 7dae485564..84d01e58b4 100644 --- a/src/lib/libcrypto/bio/bss_rtcp.c +++ b/src/lib/libcrypto/bio/bss_rtcp.c @@ -73,31 +73,32 @@ typedef unsigned short io_channel; /*************************************************************************/ -struct io_status { short status, count; long flags; }; + struct io_status { short status, count; + long flags; +}; -struct rpc_msg { /* Should have member alignment inhibited */ - char channel; /* 'A'-app data. 'R'-remote client 'G'-global */ - char function; /* 'G'-get, 'P'-put, 'C'-confirm, 'X'-close */ - unsigned short int length; /* Amount of data returned or max to return */ - char data[4092]; /* variable data */ + struct rpc_msg { /* Should have member alignment inhibited */ + char channel; /* 'A'-app data. 'R'-remote client 'G'-global */ + char function; /* 'G'-get, 'P'-put, 'C'-confirm, 'X'-close */ + unsigned short int length; /* Amount of data returned or max to return */ + char data[4092]; /* variable data */ }; #define RPC_HDR_SIZE (sizeof(struct rpc_msg) - 4092) struct rpc_ctx { - int filled, pos; - struct rpc_msg msg; + int filled, pos; + struct rpc_msg msg; }; -static int rtcp_write(BIO *h,const char *buf,int num); -static int rtcp_read(BIO *h,char *buf,int size); -static int rtcp_puts(BIO *h,const char *str); -static int rtcp_gets(BIO *h,char *str,int size); -static long rtcp_ctrl(BIO *h,int cmd,long arg1,void *arg2); +static int rtcp_write(BIO *h, const char *buf, int num); +static int rtcp_read(BIO *h, char *buf, int size); +static int rtcp_puts(BIO *h, const char *str); +static int rtcp_gets(BIO *h, char *str, int size); +static long rtcp_ctrl(BIO *h, int cmd, long arg1, void *arg2); static int rtcp_new(BIO *h); static int rtcp_free(BIO *data); -static BIO_METHOD rtcp_method= - { +static BIO_METHOD rtcp_method = { BIO_TYPE_FD, "RTCP", rtcp_write, @@ -108,12 +109,13 @@ static BIO_METHOD rtcp_method= rtcp_new, rtcp_free, NULL, - }; +}; -BIO_METHOD *BIO_s_rtcp(void) - { - return(&rtcp_method); - } +BIO_METHOD +*BIO_s_rtcp(void) +{ + return (&rtcp_method); +} /*****************************************************************************/ /* Decnet I/O routines. */ @@ -123,25 +125,28 @@ BIO_METHOD *BIO_s_rtcp(void) #pragma message disable DOLLARID #endif -static int get ( io_channel chan, char *buffer, int maxlen, int *length ) +static int get(io_channel chan, char *buffer, int maxlen, int *length) { - int status; - struct io_status iosb; - status = sys$qiow ( 0, chan, IO$_READVBLK, &iosb, 0, 0, - buffer, maxlen, 0, 0, 0, 0 ); - if ( (status&1) == 1 ) status = iosb.status; - if ( (status&1) == 1 ) *length = iosb.count; - return status; + int status; + struct io_status iosb; + status = sys$qiow(0, chan, IO$_READVBLK, &iosb, 0, 0, buffer, maxlen, + 0, 0, 0, 0 ); + if ((status & 1) == 1) + status = iosb.status; + if ((status & 1) == 1 ) + *length = iosb.count; + return status; } -static int put ( io_channel chan, char *buffer, int length ) +static int put(io_channel chan, char *buffer, int length) { - int status; - struct io_status iosb; - status = sys$qiow ( 0, chan, IO$_WRITEVBLK, &iosb, 0, 0, - buffer, length, 0, 0, 0, 0 ); - if ( (status&1) == 1 ) status = iosb.status; - return status; + int status; + struct io_status iosb; + status = sys$qiow ( 0, chan, IO$_WRITEVBLK, &iosb, 0, 0, buffer, + length, 0, 0, 0, 0 ); + if ((status & 1) == 1) + status = iosb.status; + return status; } #ifdef __DECC @@ -150,109 +155,127 @@ static int put ( io_channel chan, char *buffer, int length ) /***************************************************************************/ -static int rtcp_new(BIO *bi) +static int +rtcp_new(BIO *bi) { - struct rpc_ctx *ctx; - bi->init=1; - bi->num=0; + struct rpc_ctx *ctx; + bi->init = 1; + bi->num = 0; bi->flags = 0; - bi->ptr=OPENSSL_malloc(sizeof(struct rpc_ctx)); - ctx = (struct rpc_ctx *) bi->ptr; + bi->ptr = OPENSSL_malloc(sizeof(struct rpc_ctx)); + ctx = (struct rpc_ctx *)bi->ptr; ctx->filled = 0; ctx->pos = 0; - return(1); + return (1); } -static int rtcp_free(BIO *a) +static int +rtcp_free(BIO *a) { - if (a == NULL) return(0); - if ( a->ptr ) OPENSSL_free ( a->ptr ); + if (a == NULL) + return (0); + if (a->ptr) + OPENSSL_free(a->ptr); a->ptr = NULL; - return(1); + return (1); } - -static int rtcp_read(BIO *b, char *out, int outl) + +static int +rtcp_read(BIO *b, char *out, int outl) { - int status, length; - struct rpc_ctx *ctx; - /* - * read data, return existing. - */ - ctx = (struct rpc_ctx *) b->ptr; - if ( ctx->pos < ctx->filled ) { - length = ctx->filled - ctx->pos; - if ( length > outl ) length = outl; - memmove ( out, &ctx->msg.data[ctx->pos], length ); - ctx->pos += length; - return length; - } - /* - * Requst more data from R channel. - */ - ctx->msg.channel = 'R'; - ctx->msg.function = 'G'; - ctx->msg.length = sizeof(ctx->msg.data); - status = put ( b->num, (char *) &ctx->msg, RPC_HDR_SIZE ); - if ( (status&1) == 0 ) { - return -1; - } - /* - * Read. - */ - ctx->pos = ctx->filled = 0; - status = get ( b->num, (char *) &ctx->msg, sizeof(ctx->msg), &length ); - if ( (status&1) == 0 ) length = -1; - if ( ctx->msg.channel != 'R' || ctx->msg.function != 'C' ) { - length = -1; - } - ctx->filled = length - RPC_HDR_SIZE; - - if ( ctx->pos < ctx->filled ) { - length = ctx->filled - ctx->pos; - if ( length > outl ) length = outl; - memmove ( out, ctx->msg.data, length ); - ctx->pos += length; - return length; - } + int status, length; + struct rpc_ctx *ctx; + /* + * read data, return existing. + */ + ctx = (struct rpc_ctx *)b->ptr; + if (ctx->pos < ctx->filled) { + length = ctx->filled - ctx->pos; + if (length > outl) + length = outl; + memmove(out, &ctx->msg.data[ctx->pos], length); + ctx->pos += length; + return length; + } + /* + * Requst more data from R channel. + */ + ctx->msg.channel = 'R'; + ctx->msg.function = 'G'; + ctx->msg.length = sizeof(ctx->msg.data); + status = put(b->num, (char *)&ctx->msg, RPC_HDR_SIZE); + if ((status & 1) == 0 ) { + return -1; + } + /* + * Read. + */ + ctx->pos = ctx->filled = 0; + status = get(b->num, (char *)&ctx->msg, sizeof(ctx->msg), &length); + if ((status & 1) == 0) + length = -1; + if (ctx->msg.channel != 'R' || ctx->msg.function != 'C') { + length = -1; + } + ctx->filled = length - RPC_HDR_SIZE; + + if (ctx->pos < ctx->filled) { + length = ctx->filled - ctx->pos; + if (length > outl) + length = outl; + memmove(out, ctx->msg.data, length); + ctx->pos += length; + return length; + } - return length; + return length; } -static int rtcp_write(BIO *b, const char *in, int inl) +static int +rtcp_write(BIO *b, const char *in, int inl) { - int status, i, segment, length; - struct rpc_ctx *ctx; - /* - * Output data, send in chunks no larger that sizeof(ctx->msg.data). - */ - ctx = (struct rpc_ctx *) b->ptr; - for ( i = 0; i < inl; i += segment ) { - segment = inl - i; - if ( segment > sizeof(ctx->msg.data) ) segment = sizeof(ctx->msg.data); - ctx->msg.channel = 'R'; - ctx->msg.function = 'P'; - ctx->msg.length = segment; - memmove ( ctx->msg.data, &in[i], segment ); - status = put ( b->num, (char *) &ctx->msg, segment + RPC_HDR_SIZE ); - if ((status&1) == 0 ) { i = -1; break; } + int status, i, segment, length; + struct rpc_ctx *ctx; + /* + * Output data, send in chunks no larger that sizeof(ctx->msg.data). + */ + ctx = (struct rpc_ctx *)b->ptr; + for (i = 0; i < inl; i += segment) { + segment = inl - i; + if (segment > sizeof(ctx->msg.data)) + segment = sizeof(ctx->msg.data); + ctx->msg.channel = 'R'; + ctx->msg.function = 'P'; + ctx->msg.length = segment; + memmove(ctx->msg.data, &in[i], segment); + status = put(b->num, (char *) &ctx->msg, + segment + RPC_HDR_SIZE); + if ((status & 1) == 0) { + i = -1; + break; + } - status = get ( b->num, (char *) &ctx->msg, sizeof(ctx->msg), &length ); - if ( ((status&1) == 0) || (length < RPC_HDR_SIZE) ) { i = -1; break; } - if ( (ctx->msg.channel != 'R') || (ctx->msg.function != 'C') ) { - printf("unexpected response when confirming put %c %c\n", - ctx->msg.channel, ctx->msg.function ); + status = get(b->num, (char *)&ctx->msg, sizeof(ctx->msg), + &length ); + if (((status&1) == 0) || (length < RPC_HDR_SIZE)) { + i = -1; + break; + } + if ((ctx->msg.channel != 'R') || (ctx->msg.function != 'C')) { + printf("unexpected response when confirming put %c %c\n", + ctx->msg.channel, ctx->msg.function ); + } } - } - return(i); + return (i); } -static long rtcp_ctrl(BIO *b, int cmd, long num, void *ptr) - { - long ret=1; +static long +rtcp_ctrl(BIO *b, int cmd, long num, void *ptr) +{ + long ret = 1; - switch (cmd) - { + switch (cmd) { case BIO_CTRL_RESET: case BIO_CTRL_EOF: ret = 1; @@ -260,11 +283,11 @@ static long rtcp_ctrl(BIO *b, int cmd, long num, void *ptr) case BIO_C_SET_FD: b->num = num; ret = 1; - break; + break; case BIO_CTRL_SET_CLOSE: case BIO_CTRL_FLUSH: case BIO_CTRL_DUP: - ret=1; + ret = 1; break; case BIO_CTRL_GET_CLOSE: case BIO_CTRL_INFO: @@ -272,23 +295,26 @@ static long rtcp_ctrl(BIO *b, int cmd, long num, void *ptr) case BIO_CTRL_PENDING: case BIO_CTRL_WPENDING: default: - ret=0; + ret = 0; break; - } - return(ret); - } - -static int rtcp_gets(BIO *bp, char *buf, int size) - { - return(0); } + return (ret); +} -static int rtcp_puts(BIO *bp, const char *str) +static int +rtcp_gets(BIO *bp, char *buf, int size) { - int length; - if (str == NULL) return(0); - length = strlen ( str ); - if ( length == 0 ) return (0); - return rtcp_write ( bp,str, length ); + return (0); } +static int +rtcp_puts(BIO *bp, const char *str) +{ + int length; + if (str == NULL) + return (0); + length = strlen(str); + if (length == 0) + return (0); + return rtcp_write(bp, str, length); +} diff --git a/src/lib/libcrypto/bio/bss_sock.c b/src/lib/libcrypto/bio/bss_sock.c index eb2965970c..f6d3bf7365 100644 --- a/src/lib/libcrypto/bio/bss_sock.c +++ b/src/lib/libcrypto/bio/bss_sock.c @@ -79,8 +79,7 @@ static int sock_new(BIO *h); static int sock_free(BIO *data); int BIO_sock_should_retry(int s); -static BIO_METHOD methods_sockp= - { +static BIO_METHOD methods_sockp = { BIO_TYPE_SOCKET, "socket", sock_write, @@ -91,152 +90,155 @@ static BIO_METHOD methods_sockp= sock_new, sock_free, NULL, - }; +}; -BIO_METHOD *BIO_s_socket(void) - { - return(&methods_sockp); - } +BIO_METHOD +*BIO_s_socket(void) +{ + return (&methods_sockp); +} -BIO *BIO_new_socket(int fd, int close_flag) - { +BIO +*BIO_new_socket(int fd, int close_flag) +{ BIO *ret; - ret=BIO_new(BIO_s_socket()); - if (ret == NULL) return(NULL); - BIO_set_fd(ret,fd,close_flag); - return(ret); - } + ret = BIO_new(BIO_s_socket()); + if (ret == NULL) + return (NULL); + BIO_set_fd(ret, fd, close_flag); + return (ret); +} -static int sock_new(BIO *bi) - { - bi->init=0; - bi->num=0; - bi->ptr=NULL; - bi->flags=0; - return(1); - } +static int +sock_new(BIO *bi) +{ + bi->init = 0; + bi->num = 0; + bi->ptr = NULL; + bi->flags = 0; + return (1); +} -static int sock_free(BIO *a) - { - if (a == NULL) return(0); - if (a->shutdown) - { - if (a->init) - { +static int +sock_free(BIO *a) +{ + if (a == NULL) + return (0); + if (a->shutdown) { + if (a->init) { shutdown(a->num, SHUT_RDWR); close(a->num); - } - a->init=0; - a->flags=0; } - return(1); + a->init = 0; + a->flags = 0; } - -static int sock_read(BIO *b, char *out, int outl) - { - int ret=0; + return (1); +} - if (out != NULL) - { +static int +sock_read(BIO *b, char *out, int outl) +{ + int ret = 0; + + if (out != NULL) { errno = 0; - ret=read(b->num,out,outl); + ret = read(b->num, out, outl); BIO_clear_retry_flags(b); - if (ret <= 0) - { + if (ret <= 0) { if (BIO_sock_should_retry(ret)) BIO_set_retry_read(b); - } } - return(ret); } + return (ret); +} -static int sock_write(BIO *b, const char *in, int inl) - { +static int +sock_write(BIO *b, const char *in, int inl) +{ int ret; - + errno = 0; - ret=write(b->num,in,inl); + ret = write(b->num, in, inl); BIO_clear_retry_flags(b); - if (ret <= 0) - { + if (ret <= 0) { if (BIO_sock_should_retry(ret)) BIO_set_retry_write(b); - } - return(ret); } + return (ret); +} -static long sock_ctrl(BIO *b, int cmd, long num, void *ptr) - { - long ret=1; +static long +sock_ctrl(BIO *b, int cmd, long num, void *ptr) +{ + long ret = 1; int *ip; - switch (cmd) - { + switch (cmd) { case BIO_C_SET_FD: sock_free(b); b->num= *((int *)ptr); - b->shutdown=(int)num; - b->init=1; + b->shutdown = (int)num; + b->init = 1; break; case BIO_C_GET_FD: - if (b->init) - { - ip=(int *)ptr; - if (ip != NULL) *ip=b->num; - ret=b->num; - } - else - ret= -1; + if (b->init) { + ip = (int *)ptr; + if (ip != NULL) + *ip = b->num; + ret = b->num; + } else + ret = -1; break; case BIO_CTRL_GET_CLOSE: - ret=b->shutdown; + ret = b->shutdown; break; case BIO_CTRL_SET_CLOSE: - b->shutdown=(int)num; + b->shutdown = (int)num; break; case BIO_CTRL_DUP: case BIO_CTRL_FLUSH: - ret=1; + ret = 1; break; default: - ret=0; + ret = 0; break; - } - return(ret); } + return (ret); +} -static int sock_puts(BIO *bp, const char *str) - { - int n,ret; +static int +sock_puts(BIO *bp, const char *str) +{ + int n, ret; - n=strlen(str); - ret=sock_write(bp,str,n); - return(ret); - } + n = strlen(str); + ret = sock_write(bp, str, n); + return (ret); +} -int BIO_sock_should_retry(int i) - { +int +BIO_sock_should_retry(int i) +{ int err; - if ((i == 0) || (i == -1)) - { - err=errno; + if ((i == 0) || (i == -1)) { + err = errno; #if defined(OPENSSL_SYS_WINDOWS) && 0 /* more microsoft stupidity? perhaps not? Ben 4/1/99 */ if ((i == -1) && (err == 0)) - return(1); + return (1); #endif - return(BIO_sock_non_fatal_error(err)); - } - return(0); + return (BIO_sock_non_fatal_error(err)); } + return (0); +} -int BIO_sock_non_fatal_error(int err) - { - switch (err) - { +int +BIO_sock_non_fatal_error(int err) +{ + switch (err) { #if defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_NETWARE) # if defined(WSAEWOULDBLOCK) case WSAEWOULDBLOCK: @@ -284,12 +286,12 @@ int BIO_sock_non_fatal_error(int err) #ifdef EALREADY case EALREADY: #endif - return(1); + return (1); /* break; */ default: break; - } - return(0); } + return (0); +} #endif /* #ifndef OPENSSL_NO_SOCK */ diff --git a/src/lib/libssl/src/crypto/bio/b_dump.c b/src/lib/libssl/src/crypto/bio/b_dump.c index 492ee09275..bea94969a2 100644 --- a/src/lib/libssl/src/crypto/bio/b_dump.c +++ b/src/lib/libssl/src/crypto/bio/b_dump.c @@ -66,122 +66,125 @@ #define TRUNCATE #define DUMP_WIDTH 16 -#define DUMP_WIDTH_LESS_INDENT(i) (DUMP_WIDTH-((i-(i>6?6:i)+3)/4)) +#define DUMP_WIDTH_LESS_INDENT(i) (DUMP_WIDTH - ((i - (i > 6 ? 6 : i) + 3) / 4)) -int BIO_dump_cb(int (*cb)(const void *data, size_t len, void *u), - void *u, const char *s, int len) - { +int +BIO_dump_cb(int (*cb)(const void *data, size_t len, void *u), + void *u, const char *s, int len) +{ return BIO_dump_indent_cb(cb, u, s, len, 0); - } +} -int BIO_dump_indent_cb(int (*cb)(const void *data, size_t len, void *u), - void *u, const char *s, int len, int indent) - { - int ret=0; - char buf[288+1],tmp[20],str[128+1]; - int i,j,rows,trc; +int +BIO_dump_indent_cb(int (*cb)(const void *data, size_t len, void *u), + void *u, const char *s, int len, int indent) +{ + int ret = 0; + char buf[288 + 1], tmp[20], str[128 + 1]; + int i, j, rows, trc; unsigned char ch; int dump_width; - trc=0; + trc = 0; #ifdef TRUNCATE - for(; (len > 0) && ((s[len-1] == ' ') || (s[len-1] == '\0')); len--) + for (; (len > 0) && ((s[len - 1] == ' ') || (s[len - 1] == '\0')); len--) trc++; #endif if (indent < 0) indent = 0; - if (indent) - { - if (indent > 128) indent=128; - memset(str,' ',indent); - } - str[indent]='\0'; + if (indent) { + if (indent > 128) + indent = 128; + memset(str, ' ', indent); + } + str[indent] = '\0'; - dump_width=DUMP_WIDTH_LESS_INDENT(indent); - rows=(len/dump_width); - if ((rows*dump_width)=len) - { - BUF_strlcat(buf," ",sizeof buf); - } - else - { - ch=((unsigned char)*(s+i*dump_width+j)) & 0xff; - (void) snprintf(tmp,sizeof tmp,"%02x%c",ch, - j==7?'-':' '); - BUF_strlcat(buf,tmp,sizeof buf); - } + for (i = 0; i < rows; i++) { + buf[0] = '\0'; /* start with empty string */ + BUF_strlcpy(buf, str, sizeof buf); + (void) snprintf(tmp, sizeof tmp, "%04x - ", i*dump_width); + BUF_strlcat(buf, tmp, sizeof buf); + for (j = 0; j < dump_width; j++) { + if (((i*dump_width) + j) >= len) { + BUF_strlcat(buf, " ", sizeof buf); + } else { + ch = ((unsigned char)*(s + i*dump_width + j)) & 0xff; + (void) snprintf(tmp, sizeof tmp, "%02x%c", ch, + j == 7 ? '-' : ' '); + BUF_strlcat(buf, tmp, sizeof buf); } - BUF_strlcat(buf," ",sizeof buf); - for(j=0;j=len) + } + BUF_strlcat(buf, " ", sizeof buf); + for (j = 0; j < dump_width; j++) { + if (((i*dump_width) + j) >= len) break; - ch=((unsigned char)*(s+i*dump_width+j)) & 0xff; + ch = ((unsigned char)*(s + i * dump_width + j)) & 0xff; #ifndef CHARSET_EBCDIC - (void) snprintf(tmp,sizeof tmp,"%c", - ((ch>=' ')&&(ch<='~'))?ch:'.'); + (void) snprintf(tmp, sizeof tmp, "%c", + ((ch >= ' ') && (ch <= '~')) ? ch : '.'); #else - (void) snprintf(tmp,sizeof tmp,"%c", - ((ch>=os_toascii[' '])&&(ch<=os_toascii['~'])) - ? os_toebcdic[ch] - : '.'); + (void) snprintf(tmp, sizeof tmp, "%c", + ((ch >= os_toascii[' ']) && (ch <= os_toascii['~'])) + ? os_toebcdic[ch] : '.'); #endif - BUF_strlcat(buf,tmp,sizeof buf); - } - BUF_strlcat(buf,"\n",sizeof buf); + BUF_strlcat(buf, tmp, sizeof buf); + } + BUF_strlcat(buf, "\n", sizeof buf); /* if this is the last call then update the ddt_dump thing so * that we will move the selection point in the debug window */ - ret+=cb((void *)buf,strlen(buf),u); - } + ret += cb((void *)buf, strlen(buf), u); + } #ifdef TRUNCATE - if (trc > 0) - { - (void) snprintf(buf,sizeof buf,"%s%04x - \n",str, - len+trc); - ret+=cb((void *)buf,strlen(buf),u); - } -#endif - return(ret); + if (trc > 0) { + (void) snprintf(buf, sizeof buf, "%s%04x - \n", + str, len + trc); + ret += cb((void *)buf, strlen(buf), u); } +#endif + return (ret); +} #ifndef OPENSSL_NO_FP_API -static int write_fp(const void *data, size_t len, void *fp) - { +static int +write_fp(const void *data, size_t len, void *fp) +{ return UP_fwrite(data, len, 1, fp); - } -int BIO_dump_fp(FILE *fp, const char *s, int len) - { +} + +int +BIO_dump_fp(FILE *fp, const char *s, int len) +{ return BIO_dump_cb(write_fp, fp, s, len); - } -int BIO_dump_indent_fp(FILE *fp, const char *s, int len, int indent) - { +} + +int +BIO_dump_indent_fp(FILE *fp, const char *s, int len, int indent) +{ return BIO_dump_indent_cb(write_fp, fp, s, len, indent); - } +} #endif -static int write_bio(const void *data, size_t len, void *bp) - { +static int +write_bio(const void *data, size_t len, void *bp) +{ return BIO_write((BIO *)bp, (const char *)data, len); - } -int BIO_dump(BIO *bp, const char *s, int len) - { +} + +int +BIO_dump(BIO *bp, const char *s, int len) +{ return BIO_dump_cb(write_bio, bp, s, len); - } -int BIO_dump_indent(BIO *bp, const char *s, int len, int indent) - { - return BIO_dump_indent_cb(write_bio, bp, s, len, indent); - } +} +int +BIO_dump_indent(BIO *bp, const char *s, int len, int indent) +{ + return BIO_dump_indent_cb(write_bio, bp, s, len, indent); +} diff --git a/src/lib/libssl/src/crypto/bio/b_print.c b/src/lib/libssl/src/crypto/bio/b_print.c index 143a7cfefa..b3b0d45ee6 100644 --- a/src/lib/libssl/src/crypto/bio/b_print.c +++ b/src/lib/libssl/src/crypto/bio/b_print.c @@ -125,16 +125,15 @@ #define LLONG long #endif -static void fmtstr (char **, char **, size_t *, size_t *, - const char *, int, int, int); -static void fmtint (char **, char **, size_t *, size_t *, - LLONG, int, int, int, int); -static void fmtfp (char **, char **, size_t *, size_t *, - LDOUBLE, int, int, int); -static void doapr_outch (char **, char **, size_t *, size_t *, int); -static void _dopr(char **sbuffer, char **buffer, - size_t *maxlen, size_t *retlen, int *truncated, - const char *format, va_list args); +static void fmtstr(char **, char **, size_t *, size_t *, const char *, + int, int, int); +static void fmtint(char **, char **, size_t *, size_t *, LLONG, int, + int, int, int); +static void fmtfp(char **, char **, size_t *, size_t *, LDOUBLE, + int, int, int); +static void doapr_outch(char **, char **, size_t *, size_t *, int); +static void _dopr(char **sbuffer, char **buffer, size_t *maxlen, + size_t *retlen, int *truncated, const char *format, va_list args); /* format read states */ #define DP_S_DEFAULT 0 @@ -166,607 +165,576 @@ static void _dopr(char **sbuffer, char **buffer, #define OSSL_MAX(p,q) ((p >= q) ? p : q) static void -_dopr( - char **sbuffer, - char **buffer, - size_t *maxlen, - size_t *retlen, - int *truncated, - const char *format, - va_list args) +_dopr(char **sbuffer, char **buffer, size_t *maxlen, size_t *retlen, + int *truncated, const char *format, va_list args) { - char ch; - LLONG value; - LDOUBLE fvalue; - char *strvalue; - int min; - int max; - int state; - int flags; - int cflags; - size_t currlen; - - state = DP_S_DEFAULT; - flags = currlen = cflags = min = 0; - max = -1; - ch = *format++; - - while (state != DP_S_DONE) { - if (ch == '\0' || (buffer == NULL && currlen >= *maxlen)) - state = DP_S_DONE; - - switch (state) { - case DP_S_DEFAULT: - if (ch == '%') - state = DP_S_FLAGS; - else - doapr_outch(sbuffer,buffer, &currlen, maxlen, ch); - ch = *format++; - break; - case DP_S_FLAGS: - switch (ch) { - case '-': - flags |= DP_F_MINUS; - ch = *format++; - break; - case '+': - flags |= DP_F_PLUS; - ch = *format++; - break; - case ' ': - flags |= DP_F_SPACE; - ch = *format++; - break; - case '#': - flags |= DP_F_NUM; - ch = *format++; - break; - case '0': - flags |= DP_F_ZERO; - ch = *format++; - break; - default: - state = DP_S_MIN; - break; - } - break; - case DP_S_MIN: - if (isdigit((unsigned char)ch)) { - min = 10 * min + char_to_int(ch); - ch = *format++; - } else if (ch == '*') { - min = va_arg(args, int); - ch = *format++; - state = DP_S_DOT; - } else - state = DP_S_DOT; - break; - case DP_S_DOT: - if (ch == '.') { - state = DP_S_MAX; - ch = *format++; - } else - state = DP_S_MOD; - break; - case DP_S_MAX: - if (isdigit((unsigned char)ch)) { - if (max < 0) - max = 0; - max = 10 * max + char_to_int(ch); - ch = *format++; - } else if (ch == '*') { - max = va_arg(args, int); - ch = *format++; - state = DP_S_MOD; - } else - state = DP_S_MOD; - break; - case DP_S_MOD: - switch (ch) { - case 'h': - cflags = DP_C_SHORT; - ch = *format++; - break; - case 'l': - if (*format == 'l') { - cflags = DP_C_LLONG; - format++; - } else - cflags = DP_C_LONG; - ch = *format++; - break; - case 'q': - cflags = DP_C_LLONG; - ch = *format++; - break; - case 'L': - cflags = DP_C_LDOUBLE; - ch = *format++; - break; - default: - break; - } - state = DP_S_CONV; - break; - case DP_S_CONV: - switch (ch) { - case 'd': - case 'i': - switch (cflags) { - case DP_C_SHORT: - value = (short int)va_arg(args, int); - break; - case DP_C_LONG: - value = va_arg(args, long int); - break; - case DP_C_LLONG: - value = va_arg(args, LLONG); - break; - default: - value = va_arg(args, int); - break; - } - fmtint(sbuffer, buffer, &currlen, maxlen, - value, 10, min, max, flags); - break; - case 'X': - flags |= DP_F_UP; - /* FALLTHROUGH */ - case 'x': - case 'o': - case 'u': - flags |= DP_F_UNSIGNED; - switch (cflags) { - case DP_C_SHORT: - value = (unsigned short int)va_arg(args, unsigned int); - break; - case DP_C_LONG: - value = (LLONG) va_arg(args, - unsigned long int); - break; - case DP_C_LLONG: - value = va_arg(args, unsigned LLONG); - break; - default: - value = (LLONG) va_arg(args, - unsigned int); - break; - } - fmtint(sbuffer, buffer, &currlen, maxlen, value, - ch == 'o' ? 8 : (ch == 'u' ? 10 : 16), - min, max, flags); - break; - case 'f': - if (cflags == DP_C_LDOUBLE) - fvalue = va_arg(args, LDOUBLE); - else - fvalue = va_arg(args, double); - fmtfp(sbuffer, buffer, &currlen, maxlen, - fvalue, min, max, flags); - break; - case 'E': - flags |= DP_F_UP; - case 'e': - if (cflags == DP_C_LDOUBLE) - fvalue = va_arg(args, LDOUBLE); - else - fvalue = va_arg(args, double); - break; - case 'G': - flags |= DP_F_UP; - case 'g': - if (cflags == DP_C_LDOUBLE) - fvalue = va_arg(args, LDOUBLE); - else - fvalue = va_arg(args, double); - break; - case 'c': - doapr_outch(sbuffer, buffer, &currlen, maxlen, - va_arg(args, int)); - break; - case 's': - strvalue = va_arg(args, char *); - if (max < 0) { - if (buffer) - max = INT_MAX; - else - max = *maxlen; + char ch; + LLONG value; + LDOUBLE fvalue; + char *strvalue; + int min; + int max; + int state; + int flags; + int cflags; + size_t currlen; + + state = DP_S_DEFAULT; + flags = currlen = cflags = min = 0; + max = -1; + ch = *format++; + + while (state != DP_S_DONE) { + if (ch == '\0' || (buffer == NULL && currlen >= *maxlen)) + state = DP_S_DONE; + + switch (state) { + case DP_S_DEFAULT: + if (ch == '%') + state = DP_S_FLAGS; + else + doapr_outch(sbuffer, buffer, &currlen, maxlen, ch); + ch = *format++; + break; + case DP_S_FLAGS: + switch (ch) { + case '-': + flags |= DP_F_MINUS; + ch = *format++; + break; + case '+': + flags |= DP_F_PLUS; + ch = *format++; + break; + case ' ': + flags |= DP_F_SPACE; + ch = *format++; + break; + case '#': + flags |= DP_F_NUM; + ch = *format++; + break; + case '0': + flags |= DP_F_ZERO; + ch = *format++; + break; + default: + state = DP_S_MIN; + break; + } + break; + case DP_S_MIN: + if (isdigit((unsigned char)ch)) { + min = 10 * min + char_to_int(ch); + ch = *format++; + } else if (ch == '*') { + min = va_arg(args, int); + ch = *format++; + state = DP_S_DOT; + } else + state = DP_S_DOT; + break; + case DP_S_DOT: + if (ch == '.') { + state = DP_S_MAX; + ch = *format++; + } else + state = DP_S_MOD; + break; + case DP_S_MAX: + if (isdigit((unsigned char)ch)) { + if (max < 0) + max = 0; + max = 10 * max + char_to_int(ch); + ch = *format++; + } else if (ch == '*') { + max = va_arg(args, int); + ch = *format++; + state = DP_S_MOD; + } else + state = DP_S_MOD; + break; + case DP_S_MOD: + switch (ch) { + case 'h': + cflags = DP_C_SHORT; + ch = *format++; + break; + case 'l': + if (*format == 'l') { + cflags = DP_C_LLONG; + format++; + } else + cflags = DP_C_LONG; + ch = *format++; + break; + case 'q': + cflags = DP_C_LLONG; + ch = *format++; + break; + case 'L': + cflags = DP_C_LDOUBLE; + ch = *format++; + break; + default: + break; + } + state = DP_S_CONV; + break; + case DP_S_CONV: + switch (ch) { + case 'd': + case 'i': + switch (cflags) { + case DP_C_SHORT: + value = (short int)va_arg(args, int); + break; + case DP_C_LONG: + value = va_arg(args, long int); + break; + case DP_C_LLONG: + value = va_arg(args, LLONG); + break; + default: + value = va_arg(args, int); + break; + } + fmtint(sbuffer, buffer, &currlen, maxlen, + value, 10, min, max, flags); + break; + case 'X': + flags |= DP_F_UP; + /* FALLTHROUGH */ + case 'x': + case 'o': + case 'u': + flags |= DP_F_UNSIGNED; + switch (cflags) { + case DP_C_SHORT: + value = (unsigned short int)va_arg( + args, unsigned int); + break; + case DP_C_LONG: + value = (LLONG)va_arg(args, + unsigned long int); + break; + case DP_C_LLONG: + value = va_arg(args, unsigned LLONG); + break; + default: + value = (LLONG)va_arg(args, + unsigned int); + break; + } + fmtint(sbuffer, buffer, &currlen, maxlen, value, + ch == 'o' ? 8 : (ch == 'u' ? 10 : 16), + min, max, flags); + break; + case 'f': + if (cflags == DP_C_LDOUBLE) + fvalue = va_arg(args, LDOUBLE); + else + fvalue = va_arg(args, double); + fmtfp(sbuffer, buffer, &currlen, maxlen, + fvalue, min, max, flags); + break; + case 'E': + flags |= DP_F_UP; + case 'e': + if (cflags == DP_C_LDOUBLE) + fvalue = va_arg(args, LDOUBLE); + else + fvalue = va_arg(args, double); + break; + case 'G': + flags |= DP_F_UP; + case 'g': + if (cflags == DP_C_LDOUBLE) + fvalue = va_arg(args, LDOUBLE); + else + fvalue = va_arg(args, double); + break; + case 'c': + doapr_outch(sbuffer, buffer, &currlen, maxlen, + va_arg(args, int)); + break; + case 's': + strvalue = va_arg(args, char *); + if (max < 0) { + if (buffer) + max = INT_MAX; + else + max = *maxlen; + } + fmtstr(sbuffer, buffer, &currlen, maxlen, + strvalue, flags, min, max); + break; + case 'p': + value = (long)va_arg(args, void *); + fmtint(sbuffer, buffer, &currlen, maxlen, + value, 16, min, max, flags|DP_F_NUM); + break; + case 'n': /* XXX */ + if (cflags == DP_C_SHORT) { + short int *num; + num = va_arg(args, short int *); + *num = currlen; + } else if (cflags == DP_C_LONG) { /* XXX */ + long int *num; + num = va_arg(args, long int *); + *num = (long int) currlen; + } else if (cflags == DP_C_LLONG) { /* XXX */ + LLONG *num; + num = va_arg(args, LLONG *); + *num = (LLONG) currlen; + } else { + int *num; + num = va_arg(args, int *); + *num = currlen; + } + break; + case '%': + doapr_outch(sbuffer, buffer, &currlen, maxlen, ch); + break; + case 'w': + /* not supported yet, treat as next char */ + ch = *format++; + break; + default: + /* unknown, skip */ + break; + } + ch = *format++; + state = DP_S_DEFAULT; + flags = cflags = min = 0; + max = -1; + break; + case DP_S_DONE: + break; + default: + break; } - fmtstr(sbuffer, buffer, &currlen, maxlen, strvalue, - flags, min, max); - break; - case 'p': - value = (long)va_arg(args, void *); - fmtint(sbuffer, buffer, &currlen, maxlen, - value, 16, min, max, flags|DP_F_NUM); - break; - case 'n': /* XXX */ - if (cflags == DP_C_SHORT) { - short int *num; - num = va_arg(args, short int *); - *num = currlen; - } else if (cflags == DP_C_LONG) { /* XXX */ - long int *num; - num = va_arg(args, long int *); - *num = (long int) currlen; - } else if (cflags == DP_C_LLONG) { /* XXX */ - LLONG *num; - num = va_arg(args, LLONG *); - *num = (LLONG) currlen; - } else { - int *num; - num = va_arg(args, int *); - *num = currlen; - } - break; - case '%': - doapr_outch(sbuffer, buffer, &currlen, maxlen, ch); - break; - case 'w': - /* not supported yet, treat as next char */ - ch = *format++; - break; - default: - /* unknown, skip */ - break; - } - ch = *format++; - state = DP_S_DEFAULT; - flags = cflags = min = 0; - max = -1; - break; - case DP_S_DONE: - break; - default: - break; - } - } - *truncated = (currlen > *maxlen - 1); - if (*truncated) - currlen = *maxlen - 1; - doapr_outch(sbuffer, buffer, &currlen, maxlen, '\0'); - *retlen = currlen - 1; - return; + } + *truncated = (currlen > *maxlen - 1); + if (*truncated) + currlen = *maxlen - 1; + doapr_outch(sbuffer, buffer, &currlen, maxlen, '\0'); + *retlen = currlen - 1; + return; } static void -fmtstr( - char **sbuffer, - char **buffer, - size_t *currlen, - size_t *maxlen, - const char *value, - int flags, - int min, - int max) +fmtstr(char **sbuffer, char **buffer, size_t *currlen, size_t *maxlen, + const char *value, int flags, int min, int max) { - int padlen, strln; - int cnt = 0; - - if (value == 0) - value = ""; - for (strln = 0; value[strln]; ++strln) - ; - padlen = min - strln; - if (padlen < 0) - padlen = 0; - if (flags & DP_F_MINUS) - padlen = -padlen; - - while ((padlen > 0) && (cnt < max)) { - doapr_outch(sbuffer, buffer, currlen, maxlen, ' '); - --padlen; - ++cnt; - } - while (*value && (cnt < max)) { - doapr_outch(sbuffer, buffer, currlen, maxlen, *value++); - ++cnt; - } - while ((padlen < 0) && (cnt < max)) { - doapr_outch(sbuffer, buffer, currlen, maxlen, ' '); - ++padlen; - ++cnt; - } + int padlen, strln; + int cnt = 0; + + if (value == 0) + value = ""; + for (strln = 0; value[strln]; ++strln) + ; + padlen = min - strln; + if (padlen < 0) + padlen = 0; + if (flags & DP_F_MINUS) + padlen = -padlen; + + while ((padlen > 0) && (cnt < max)) { + doapr_outch(sbuffer, buffer, currlen, maxlen, ' '); + --padlen; + ++cnt; + } + while (*value && (cnt < max)) { + doapr_outch(sbuffer, buffer, currlen, maxlen, *value++); + ++cnt; + } + while ((padlen < 0) && (cnt < max)) { + doapr_outch(sbuffer, buffer, currlen, maxlen, ' '); + ++padlen; + ++cnt; + } } static void -fmtint( - char **sbuffer, - char **buffer, - size_t *currlen, - size_t *maxlen, - LLONG value, - int base, - int min, - int max, - int flags) +fmtint(char **sbuffer, char **buffer, size_t *currlen, size_t *maxlen, + LLONG value, int base, int min, int max, int flags) { - int signvalue = 0; - const char *prefix = ""; - unsigned LLONG uvalue; - char convert[DECIMAL_SIZE(value)+3]; - int place = 0; - int spadlen = 0; - int zpadlen = 0; - int caps = 0; - - if (max < 0) - max = 0; - uvalue = value; - if (!(flags & DP_F_UNSIGNED)) { - if (value < 0) { - signvalue = '-'; - uvalue = -value; - } else if (flags & DP_F_PLUS) - signvalue = '+'; - else if (flags & DP_F_SPACE) - signvalue = ' '; - } - if (flags & DP_F_NUM) { - if (base == 8) prefix = "0"; - if (base == 16) prefix = "0x"; - } - if (flags & DP_F_UP) - caps = 1; - do { - convert[place++] = - (caps ? "0123456789ABCDEF" : "0123456789abcdef") - [uvalue % (unsigned) base]; - uvalue = (uvalue / (unsigned) base); - } while (uvalue && (place < (int)sizeof(convert))); - if (place == sizeof(convert)) - place--; - convert[place] = 0; - - zpadlen = max - place; - spadlen = min - OSSL_MAX(max, place) - (signvalue ? 1 : 0) - strlen(prefix); - if (zpadlen < 0) - zpadlen = 0; - if (spadlen < 0) - spadlen = 0; - if (flags & DP_F_ZERO) { - zpadlen = OSSL_MAX(zpadlen, spadlen); - spadlen = 0; - } - if (flags & DP_F_MINUS) - spadlen = -spadlen; - - /* spaces */ - while (spadlen > 0) { - doapr_outch(sbuffer, buffer, currlen, maxlen, ' '); - --spadlen; - } - - /* sign */ - if (signvalue) - doapr_outch(sbuffer, buffer, currlen, maxlen, signvalue); - - /* prefix */ - while (*prefix) { - doapr_outch(sbuffer, buffer, currlen, maxlen, *prefix); - prefix++; - } - - /* zeros */ - if (zpadlen > 0) { - while (zpadlen > 0) { - doapr_outch(sbuffer, buffer, currlen, maxlen, '0'); - --zpadlen; - } - } - /* digits */ - while (place > 0) - doapr_outch(sbuffer, buffer, currlen, maxlen, convert[--place]); - - /* left justified spaces */ - while (spadlen < 0) { - doapr_outch(sbuffer, buffer, currlen, maxlen, ' '); - ++spadlen; - } - return; + int signvalue = 0; + const char *prefix = ""; + unsigned LLONG uvalue; + char convert[DECIMAL_SIZE(value) + 3]; + int place = 0; + int spadlen = 0; + int zpadlen = 0; + int caps = 0; + + if (max < 0) + max = 0; + uvalue = value; + if (!(flags & DP_F_UNSIGNED)) { + if (value < 0) { + signvalue = '-'; + uvalue = -value; + } else if (flags & DP_F_PLUS) + signvalue = '+'; + else if (flags & DP_F_SPACE) + signvalue = ' '; + } + if (flags & DP_F_NUM) { + if (base == 8) + prefix = "0"; + if (base == 16) + prefix = "0x"; + } + if (flags & DP_F_UP) + caps = 1; + do { + convert[place++] = (caps ? "0123456789ABCDEF" : + "0123456789abcdef")[uvalue % (unsigned) base]; + uvalue = (uvalue / (unsigned) base); + } while (uvalue && (place < (int)sizeof(convert))); + if (place == sizeof(convert)) + place--; + convert[place] = 0; + + zpadlen = max - place; + spadlen = min - OSSL_MAX(max, place) - (signvalue ? 1 : 0) - + strlen(prefix); + if (zpadlen < 0) + zpadlen = 0; + if (spadlen < 0) + spadlen = 0; + if (flags & DP_F_ZERO) { + zpadlen = OSSL_MAX(zpadlen, spadlen); + spadlen = 0; + } + if (flags & DP_F_MINUS) + spadlen = -spadlen; + + /* spaces */ + while (spadlen > 0) { + doapr_outch(sbuffer, buffer, currlen, maxlen, ' '); + --spadlen; + } + + /* sign */ + if (signvalue) + doapr_outch(sbuffer, buffer, currlen, maxlen, signvalue); + + /* prefix */ + while (*prefix) { + doapr_outch(sbuffer, buffer, currlen, maxlen, *prefix); + prefix++; + } + + /* zeros */ + if (zpadlen > 0) { + while (zpadlen > 0) { + doapr_outch(sbuffer, buffer, currlen, maxlen, '0'); + --zpadlen; + } + } + /* digits */ + while (place > 0) + doapr_outch(sbuffer, buffer, currlen, maxlen, convert[--place]); + + /* left justified spaces */ + while (spadlen < 0) { + doapr_outch(sbuffer, buffer, currlen, maxlen, ' '); + ++spadlen; + } + return; } static LDOUBLE abs_val(LDOUBLE value) { - LDOUBLE result = value; - if (value < 0) - result = -value; - return result; + LDOUBLE result = value; + if (value < 0) + result = -value; + return result; } static LDOUBLE pow_10(int in_exp) { - LDOUBLE result = 1; - while (in_exp) { - result *= 10; - in_exp--; - } - return result; + LDOUBLE result = 1; + while (in_exp) { + result *= 10; + in_exp--; + } + return result; } static long roundv(LDOUBLE value) { - long intpart; - intpart = (long) value; - value = value - intpart; - if (value >= 0.5) - intpart++; - return intpart; + long intpart; + intpart = (long) value; + value = value - intpart; + if (value >= 0.5) + intpart++; + return intpart; } static void -fmtfp( - char **sbuffer, - char **buffer, - size_t *currlen, - size_t *maxlen, - LDOUBLE fvalue, - int min, - int max, - int flags) +fmtfp(char **sbuffer, char **buffer, size_t *currlen, size_t *maxlen, + LDOUBLE fvalue, int min, int max, int flags) { - int signvalue = 0; - LDOUBLE ufvalue; - char iconvert[20]; - char fconvert[20]; - int iplace = 0; - int fplace = 0; - int padlen = 0; - int zpadlen = 0; - int caps = 0; - long intpart; - long fracpart; - long max10; - - if (max < 0) - max = 6; - ufvalue = abs_val(fvalue); - if (fvalue < 0) - signvalue = '-'; - else if (flags & DP_F_PLUS) - signvalue = '+'; - else if (flags & DP_F_SPACE) - signvalue = ' '; - - intpart = (long)ufvalue; - - /* sorry, we only support 9 digits past the decimal because of our - conversion method */ - if (max > 9) - max = 9; - - /* we "cheat" by converting the fractional part to integer by - multiplying by a factor of 10 */ - max10 = roundv(pow_10(max)); - fracpart = roundv(pow_10(max) * (ufvalue - intpart)); - - if (fracpart >= max10) { - intpart++; - fracpart -= max10; - } - - /* convert integer part */ - do { - iconvert[iplace++] = - (caps ? "0123456789ABCDEF" - : "0123456789abcdef")[intpart % 10]; - intpart = (intpart / 10); - } while (intpart && (iplace < (int)sizeof(iconvert))); - if (iplace == sizeof iconvert) - iplace--; - iconvert[iplace] = 0; - - /* convert fractional part */ - do { - fconvert[fplace++] = - (caps ? "0123456789ABCDEF" - : "0123456789abcdef")[fracpart % 10]; - fracpart = (fracpart / 10); - } while (fplace < max); - if (fplace == sizeof fconvert) - fplace--; - fconvert[fplace] = 0; - - /* -1 for decimal point, another -1 if we are printing a sign */ - padlen = min - iplace - max - 1 - ((signvalue) ? 1 : 0); - zpadlen = max - fplace; - if (zpadlen < 0) - zpadlen = 0; - if (padlen < 0) - padlen = 0; - if (flags & DP_F_MINUS) - padlen = -padlen; - - if ((flags & DP_F_ZERO) && (padlen > 0)) { - if (signvalue) { - doapr_outch(sbuffer, buffer, currlen, maxlen, signvalue); - --padlen; - signvalue = 0; - } - while (padlen > 0) { - doapr_outch(sbuffer, buffer, currlen, maxlen, '0'); - --padlen; - } - } - while (padlen > 0) { - doapr_outch(sbuffer, buffer, currlen, maxlen, ' '); - --padlen; - } - if (signvalue) - doapr_outch(sbuffer, buffer, currlen, maxlen, signvalue); - - while (iplace > 0) - doapr_outch(sbuffer, buffer, currlen, maxlen, iconvert[--iplace]); - - /* - * Decimal point. This should probably use locale to find the correct - * char to print out. - */ - if (max > 0 || (flags & DP_F_NUM)) { - doapr_outch(sbuffer, buffer, currlen, maxlen, '.'); - - while (fplace > 0) - doapr_outch(sbuffer, buffer, currlen, maxlen, fconvert[--fplace]); - } - while (zpadlen > 0) { - doapr_outch(sbuffer, buffer, currlen, maxlen, '0'); - --zpadlen; - } - - while (padlen < 0) { - doapr_outch(sbuffer, buffer, currlen, maxlen, ' '); - ++padlen; - } + int signvalue = 0; + LDOUBLE ufvalue; + char iconvert[20]; + char fconvert[20]; + int iplace = 0; + int fplace = 0; + int padlen = 0; + int zpadlen = 0; + int caps = 0; + long intpart; + long fracpart; + long max10; + + if (max < 0) + max = 6; + ufvalue = abs_val(fvalue); + if (fvalue < 0) + signvalue = '-'; + else if (flags & DP_F_PLUS) + signvalue = '+'; + else if (flags & DP_F_SPACE) + signvalue = ' '; + + intpart = (long)ufvalue; + + /* sorry, we only support 9 digits past the decimal because of our + conversion method */ + if (max > 9) + max = 9; + + /* we "cheat" by converting the fractional part to integer by + multiplying by a factor of 10 */ + max10 = roundv(pow_10(max)); + fracpart = roundv(pow_10(max) * (ufvalue - intpart)); + + if (fracpart >= max10) { + intpart++; + fracpart -= max10; + } + + /* convert integer part */ + do { + iconvert[iplace++] = (caps ? "0123456789ABCDEF" : + "0123456789abcdef")[intpart % 10]; + intpart = (intpart / 10); + } while (intpart && (iplace < (int)sizeof(iconvert))); + if (iplace == sizeof iconvert) + iplace--; + iconvert[iplace] = 0; + + /* convert fractional part */ + do { + fconvert[fplace++] = (caps ? "0123456789ABCDEF" : + "0123456789abcdef")[fracpart % 10]; + fracpart = (fracpart / 10); + } while (fplace < max); + if (fplace == sizeof fconvert) + fplace--; + fconvert[fplace] = 0; + + /* -1 for decimal point, another -1 if we are printing a sign */ + padlen = min - iplace - max - 1 - ((signvalue) ? 1 : 0); + zpadlen = max - fplace; + if (zpadlen < 0) + zpadlen = 0; + if (padlen < 0) + padlen = 0; + if (flags & DP_F_MINUS) + padlen = -padlen; + + if ((flags & DP_F_ZERO) && (padlen > 0)) { + if (signvalue) { + doapr_outch(sbuffer, buffer, currlen, maxlen, signvalue); + --padlen; + signvalue = 0; + } + while (padlen > 0) { + doapr_outch(sbuffer, buffer, currlen, maxlen, '0'); + --padlen; + } + } + while (padlen > 0) { + doapr_outch(sbuffer, buffer, currlen, maxlen, ' '); + --padlen; + } + if (signvalue) + doapr_outch(sbuffer, buffer, currlen, maxlen, signvalue); + + while (iplace > 0) + doapr_outch(sbuffer, buffer, currlen, maxlen, iconvert[--iplace]); + + /* + * Decimal point. This should probably use locale to find the correct + * char to print out. + */ + if (max > 0 || (flags & DP_F_NUM)) { + doapr_outch(sbuffer, buffer, currlen, maxlen, '.'); + + while (fplace > 0) + doapr_outch(sbuffer, buffer, currlen, maxlen, fconvert[--fplace]); + } + while (zpadlen > 0) { + doapr_outch(sbuffer, buffer, currlen, maxlen, '0'); + --zpadlen; + } + + while (padlen < 0) { + doapr_outch(sbuffer, buffer, currlen, maxlen, ' '); + ++padlen; + } } static void -doapr_outch( - char **sbuffer, - char **buffer, - size_t *currlen, - size_t *maxlen, +doapr_outch(char **sbuffer, char **buffer, size_t *currlen, size_t *maxlen, int c) { - /* If we haven't at least one buffer, someone has doe a big booboo */ - assert(*sbuffer != NULL || buffer != NULL); - - if (buffer) { - while (*currlen >= *maxlen) { - if (*buffer == NULL) { - if (*maxlen == 0) - *maxlen = 1024; - *buffer = OPENSSL_malloc(*maxlen); - if (*currlen > 0) { - assert(*sbuffer != NULL); - memcpy(*buffer, *sbuffer, *currlen); + /* If we haven't at least one buffer, someone has doe a big booboo */ + assert(*sbuffer != NULL || buffer != NULL); + + if (buffer) { + while (*currlen >= *maxlen) { + if (*buffer == NULL) { + if (*maxlen == 0) + *maxlen = 1024; + *buffer = OPENSSL_malloc(*maxlen); + if (*currlen > 0) { + assert(*sbuffer != NULL); + memcpy(*buffer, *sbuffer, *currlen); + } + *sbuffer = NULL; + } else { + *maxlen += 1024; + *buffer = OPENSSL_realloc(*buffer, *maxlen); + } } - *sbuffer = NULL; - } else { - *maxlen += 1024; - *buffer = OPENSSL_realloc(*buffer, *maxlen); - } + /* What to do if *buffer is NULL? */ + assert(*sbuffer != NULL || *buffer != NULL); } - /* What to do if *buffer is NULL? */ - assert(*sbuffer != NULL || *buffer != NULL); - } - if (*currlen < *maxlen) { - if (*sbuffer) - (*sbuffer)[(*currlen)++] = (char)c; - else - (*buffer)[(*currlen)++] = (char)c; - } + if (*currlen < *maxlen) { + if (*sbuffer) + (*sbuffer)[(*currlen)++] = (char)c; + else + (*buffer)[(*currlen)++] = (char)c; + } - return; + return; } /***************************************************************************/ int BIO_printf (BIO *bio, const char *format, ...) - { +{ va_list args; int ret; @@ -775,15 +743,15 @@ int BIO_printf (BIO *bio, const char *format, ...) ret = BIO_vprintf(bio, format, args); va_end(args); - return(ret); - } + return (ret); +} int BIO_vprintf (BIO *bio, const char *format, va_list args) - { +{ int ret; size_t retlen; char hugebuf[1024*2]; /* Was previously 10k, which is unreasonable - in small-stack environments, like threads + in small - stack environments, like threads or DOS programs. */ char *hugebufp = hugebuf; size_t hugebufsize = sizeof(hugebuf); @@ -792,27 +760,25 @@ int BIO_vprintf (BIO *bio, const char *format, va_list args) dynbuf = NULL; CRYPTO_push_info("doapr()"); - _dopr(&hugebufp, &dynbuf, &hugebufsize, - &retlen, &ignored, format, args); - if (dynbuf) - { - ret=BIO_write(bio, dynbuf, (int)retlen); + _dopr(&hugebufp, &dynbuf, &hugebufsize, &retlen, &ignored, + format, args); + if (dynbuf) { + ret = BIO_write(bio, dynbuf, (int)retlen); OPENSSL_free(dynbuf); - } - else - { - ret=BIO_write(bio, hugebuf, (int)retlen); - } - CRYPTO_pop_info(); - return(ret); + } else { + ret = BIO_write(bio, hugebuf, (int)retlen); } + CRYPTO_pop_info(); + return (ret); +} /* As snprintf is not available everywhere, we provide our own implementation. * This function has nothing to do with BIOs, but it's closely related * to BIO_printf, and we need *some* name prefix ... * (XXX the function should be renamed, but to what?) */ -int BIO_snprintf(char *buf, size_t n, const char *format, ...) - { +int +BIO_snprintf(char *buf, size_t n, const char *format, ...) +{ va_list args; int ret; @@ -821,11 +787,12 @@ int BIO_snprintf(char *buf, size_t n, const char *format, ...) ret = BIO_vsnprintf(buf, n, format, args); va_end(args); - return(ret); - } + return (ret); +} -int BIO_vsnprintf(char *buf, size_t n, const char *format, va_list args) - { +int +BIO_vsnprintf(char *buf, size_t n, const char *format, va_list args) +{ size_t retlen; int truncated; @@ -839,4 +806,4 @@ int BIO_vsnprintf(char *buf, size_t n, const char *format, va_list args) return -1; else return (retlen <= INT_MAX) ? (int)retlen : -1; - } +} diff --git a/src/lib/libssl/src/crypto/bio/b_sock.c b/src/lib/libssl/src/crypto/bio/b_sock.c index bd43307456..d739452580 100644 --- a/src/lib/libssl/src/crypto/bio/b_sock.c +++ b/src/lib/libssl/src/crypto/bio/b_sock.c @@ -85,7 +85,7 @@ NETDB_DEFINE_CONTEXT #endif #if defined(OPENSSL_SYS_WINDOWS) || (defined(OPENSSL_SYS_NETWARE) && !defined(NETWARE_BSDSOCK)) -static int wsa_init_done=0; +static int wsa_init_done = 0; #endif /* @@ -100,36 +100,36 @@ static int wsa_init_done=0; #endif #if 0 -static unsigned long BIO_ghbn_hits=0L; -static unsigned long BIO_ghbn_miss=0L; +static unsigned long BIO_ghbn_hits = 0L; +static unsigned long BIO_ghbn_miss = 0L; #define GHBN_NUM 4 -static struct ghbn_cache_st - { +static struct ghbn_cache_st { char name[129]; struct hostent *ent; unsigned long order; - } ghbn_cache[GHBN_NUM]; +} ghbn_cache[GHBN_NUM]; #endif -static int get_ip(const char *str,unsigned char *ip); +static int get_ip(const char *str, unsigned char *ip); #if 0 static void ghbn_free(struct hostent *a); static struct hostent *ghbn_dup(struct hostent *a); #endif -int BIO_get_host_ip(const char *str, unsigned char *ip) - { + +int +BIO_get_host_ip(const char *str, unsigned char *ip) +{ int i; int err = 1; int locked = 0; struct hostent *he; - i=get_ip(str,ip); - if (i < 0) - { - BIOerr(BIO_F_BIO_GET_HOST_IP,BIO_R_INVALID_IP_ADDRESS); + i = get_ip(str, ip); + if (i < 0) { + BIOerr(BIO_F_BIO_GET_HOST_IP, BIO_R_INVALID_IP_ADDRESS); goto err; - } + } /* At this point, we have something that is most probably correct in some way, so let's init the socket. */ @@ -138,172 +138,169 @@ int BIO_get_host_ip(const char *str, unsigned char *ip) /* If the string actually contained an IP address, we need not do anything more */ - if (i > 0) return(1); + if (i > 0) + return (1); /* do a gethostbyname */ CRYPTO_w_lock(CRYPTO_LOCK_GETHOSTBYNAME); locked = 1; - he=BIO_gethostbyname(str); - if (he == NULL) - { - BIOerr(BIO_F_BIO_GET_HOST_IP,BIO_R_BAD_HOSTNAME_LOOKUP); + he = BIO_gethostbyname(str); + if (he == NULL) { + BIOerr(BIO_F_BIO_GET_HOST_IP, BIO_R_BAD_HOSTNAME_LOOKUP); goto err; - } + } /* cast to short because of win16 winsock definition */ - if ((short)he->h_addrtype != AF_INET) - { - BIOerr(BIO_F_BIO_GET_HOST_IP,BIO_R_GETHOSTBYNAME_ADDR_IS_NOT_AF_INET); + if ((short)he->h_addrtype != AF_INET) { + BIOerr(BIO_F_BIO_GET_HOST_IP, BIO_R_GETHOSTBYNAME_ADDR_IS_NOT_AF_INET); goto err; - } - for (i=0; i<4; i++) - ip[i]=he->h_addr_list[0][i]; + } + for (i = 0; i < 4; i++) + ip[i] = he->h_addr_list[0][i]; err = 0; - err: +err: if (locked) CRYPTO_w_unlock(CRYPTO_LOCK_GETHOSTBYNAME); - if (err) - { - ERR_add_error_data(2,"host=",str); + if (err) { + ERR_add_error_data(2, "host=", str); return 0; - } - else + } else return 1; - } +} -int BIO_get_port(const char *str, unsigned short *port_ptr) - { +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 (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 - { + *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 *' */ #ifndef CONST_STRICT - s=getservbyname((char *)str,"tcp"); + s = getservbyname((char *)str, "tcp"); #else - s=getservbyname(str,"tcp"); + s = getservbyname(str, "tcp"); #endif - if(s != NULL) - *port_ptr=ntohs((unsigned short)s->s_port); + 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 (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,errno); - ERR_add_error_data(3,"service='",str,"'"); - return(0); - } + else if (strcmp(str, "wais") == 0) + *port_ptr = 21; +#endif + else { + SYSerr(SYS_F_GETSERVBYNAME, errno); + ERR_add_error_data(3, "service = '", str, "'"); + return (0); } } - return(1); } + return (1); +} -int BIO_sock_error(int sock) - { - int j,i; +int +BIO_sock_error(int sock) +{ + int j, i; int size; - + #if defined(OPENSSL_SYS_BEOS_R5) return 0; #endif - - size=sizeof(int); + + size = sizeof(int); /* Note: under Windows the third parameter is of type (char *) * whereas under other systems it is (void *) if you don't have * a cast it will choke the compiler: if you do have a cast then * you can either go for (char *) or (void *). */ - i=getsockopt(sock,SOL_SOCKET,SO_ERROR,(void *)&j,(void *)&size); + i = getsockopt(sock, SOL_SOCKET, SO_ERROR,(void *)&j,(void *)&size); if (i < 0) - return(1); + return (1); else - return(j); - } + return (j); +} #if 0 -long BIO_ghbn_ctrl(int cmd, int iarg, char *parg) - { +long +BIO_ghbn_ctrl(int cmd, int iarg, char *parg) +{ int i; char **p; - switch (cmd) - { + switch (cmd) { case BIO_GHBN_CTRL_HITS: - return(BIO_ghbn_hits); + return (BIO_ghbn_hits); /* break; */ case BIO_GHBN_CTRL_MISSES: - return(BIO_ghbn_miss); + return (BIO_ghbn_miss); /* break; */ case BIO_GHBN_CTRL_CACHE_SIZE: - return(GHBN_NUM); + return (GHBN_NUM); /* break; */ case BIO_GHBN_CTRL_GET_ENTRY: - if ((iarg >= 0) && (iarg 0)) - { - p=(char **)parg; - if (p == NULL) return(0); - *p=ghbn_cache[iarg].name; - ghbn_cache[iarg].name[128]='\0'; - return(1); - } - return(0); + if ((iarg >= 0) && (iarg < GHBN_NUM) && + (ghbn_cache[iarg].order > 0)) { + p = (char **)parg; + if (p == NULL) + return (0); + *p = ghbn_cache[iarg].name; + ghbn_cache[iarg].name[128] = '\0'; + return (1); + } + return (0); /* break; */ case BIO_GHBN_CTRL_FLUSH: - for (i=0; ih_aliases[i] != NULL; i++) + for (i = 0; a->h_aliases[i] != NULL; i++) ; i++; ret->h_aliases = (char **)OPENSSL_malloc(i*sizeof(char *)); @@ -311,69 +308,66 @@ static struct hostent *ghbn_dup(struct hostent *a) goto err; memset(ret->h_aliases, 0, i*sizeof(char *)); - for (i=0; a->h_addr_list[i] != NULL; i++) + for (i = 0; a->h_addr_list[i] != NULL; i++) ; i++; - ret->h_addr_list=(char **)OPENSSL_malloc(i*sizeof(char *)); + ret->h_addr_list = (char **)OPENSSL_malloc(i*sizeof(char *)); if (ret->h_addr_list == NULL) goto err; memset(ret->h_addr_list, 0, i*sizeof(char *)); - j=strlen(a->h_name)+1; - if ((ret->h_name=OPENSSL_malloc(j)) == NULL) goto err; - memcpy((char *)ret->h_name,a->h_name,j); - for (i=0; a->h_aliases[i] != NULL; i++) - { - j=strlen(a->h_aliases[i])+1; - if ((ret->h_aliases[i]=OPENSSL_malloc(j)) == NULL) goto err; - memcpy(ret->h_aliases[i],a->h_aliases[i],j); - } - ret->h_length=a->h_length; - ret->h_addrtype=a->h_addrtype; - for (i=0; a->h_addr_list[i] != NULL; i++) - { - if ((ret->h_addr_list[i]=OPENSSL_malloc(a->h_length)) == NULL) + j = strlen(a->h_name) + 1; + if ((ret->h_name = OPENSSL_malloc(j)) == NULL) goto err; + memcpy((char *)ret->h_name, a->h_name, j); + for (i = 0; a->h_aliases[i] != NULL; i++) { + j = strlen(a->h_aliases[i]) + 1; + if ((ret->h_aliases[i] = OPENSSL_malloc(j)) == NULL) goto err; + memcpy(ret->h_aliases[i], a->h_aliases[i], j); + } + ret->h_length = a->h_length; + ret->h_addrtype = a->h_addrtype; + for (i = 0; a->h_addr_list[i] != NULL; i++) { + if ((ret->h_addr_list[i] = OPENSSL_malloc(a->h_length)) == NULL) goto err; - memcpy(ret->h_addr_list[i],a->h_addr_list[i],a->h_length); - } - if (0) - { -err: + memcpy(ret->h_addr_list[i], a->h_addr_list[i], a->h_length); + } + if (0) { +err: if (ret != NULL) ghbn_free(ret); - ret=NULL; - } - MemCheck_on(); - return(ret); + ret = NULL; } + MemCheck_on(); + return (ret); +} -static void ghbn_free(struct hostent *a) - { +static void +ghbn_free(struct hostent *a) +{ int i; - if(a == NULL) - return; + if (a == NULL) + return; - if (a->h_aliases != NULL) - { - for (i=0; a->h_aliases[i] != NULL; i++) + if (a->h_aliases != NULL) { + for (i = 0; a->h_aliases[i] != NULL; i++) OPENSSL_free(a->h_aliases[i]); OPENSSL_free(a->h_aliases); - } - if (a->h_addr_list != NULL) - { - for (i=0; a->h_addr_list[i] != NULL; i++) + } + if (a->h_addr_list != NULL) { + for (i = 0; a->h_addr_list[i] != NULL; i++) OPENSSL_free(a->h_addr_list[i]); OPENSSL_free(a->h_addr_list); - } - if (a->h_name != NULL) OPENSSL_free(a->h_name); - OPENSSL_free(a); } + if (a->h_name != NULL) + OPENSSL_free(a->h_name); + OPENSSL_free(a); +} #endif -struct hostent *BIO_gethostbyname(const char *name) - { +struct hostent +*BIO_gethostbyname(const char *name) { #if 1 /* Caching gethostbyname() results forever is wrong, * so we have to let the true gethostbyname() worry about this */ @@ -384,8 +378,8 @@ struct hostent *BIO_gethostbyname(const char *name) #endif #else struct hostent *ret; - int i,lowi=0,j; - unsigned long low= (unsigned long)-1; + int i, lowi = 0, j; + unsigned long low = (unsigned long) - 1; # if 0 @@ -395,42 +389,37 @@ struct hostent *BIO_gethostbyname(const char *name) */ CRYPTO_w_lock(CRYPTO_LOCK_GETHOSTBYNAME); # endif - j=strlen(name); - if (j < 128) - { - for (i=0; i ghbn_cache[i].order) - { - low=ghbn_cache[i].order; - lowi=i; - } - if (ghbn_cache[i].order > 0) - { - if (strncmp(name,ghbn_cache[i].name,128) == 0) + j = strlen(name); + if (j < 128) { + for (i = 0; i < GHBN_NUM; i++) { + if (low > ghbn_cache[i].order) { + low = ghbn_cache[i].order; + lowi = i; + } + if (ghbn_cache[i].order > 0) { + if (strncmp(name, ghbn_cache[i].name, 128) == 0) break; - } } } - else - i=GHBN_NUM; + } else + i = GHBN_NUM; if (i == GHBN_NUM) /* no hit*/ - { + { BIO_ghbn_miss++; /* Note: under VMS with SOCKETSHR, it seems like the first * parameter is 'char *', instead of 'const char *' */ # ifndef CONST_STRICT - ret=gethostbyname((char *)name); + ret = gethostbyname((char *)name); # else - ret=gethostbyname(name); + ret = gethostbyname(name); # endif if (ret == NULL) goto end; if (j > 128) /* too big to cache */ - { + { # if 0 /* If we were trying to make this function thread-safe (which * is bound to fail), we'd have to give up in this case @@ -438,118 +427,113 @@ struct hostent *BIO_gethostbyname(const char *name) ret = NULL; # endif goto end; - } + } /* else add to cache */ if (ghbn_cache[lowi].ent != NULL) ghbn_free(ghbn_cache[lowi].ent); /* XXX not thread-safe */ ghbn_cache[lowi].name[0] = '\0'; - if((ret=ghbn_cache[lowi].ent=ghbn_dup(ret)) == NULL) - { - BIOerr(BIO_F_BIO_GETHOSTBYNAME,ERR_R_MALLOC_FAILURE); + if ((ret = ghbn_cache[lowi].ent = ghbn_dup(ret)) == NULL) { + BIOerr(BIO_F_BIO_GETHOSTBYNAME, ERR_R_MALLOC_FAILURE); goto end; - } - strncpy(ghbn_cache[lowi].name,name,128); - ghbn_cache[lowi].order=BIO_ghbn_miss+BIO_ghbn_hits; } - else - { + strncpy(ghbn_cache[lowi].name, name, 128); + ghbn_cache[lowi].order = BIO_ghbn_miss + BIO_ghbn_hits; + } else { BIO_ghbn_hits++; - ret= ghbn_cache[i].ent; - ghbn_cache[i].order=BIO_ghbn_miss+BIO_ghbn_hits; - } + ret = ghbn_cache[i].ent; + ghbn_cache[i].order = BIO_ghbn_miss + BIO_ghbn_hits; + } end: # if 0 CRYPTO_w_unlock(CRYPTO_LOCK_GETHOSTBYNAME); # endif - return(ret); + return (ret); #endif - } +} -int BIO_sock_init(void) - { +int +BIO_sock_init(void) +{ #ifdef OPENSSL_SYS_WINDOWS static struct WSAData wsa_state; - if (!wsa_init_done) - { + if (!wsa_init_done) { int err; - - wsa_init_done=1; - memset(&wsa_state,0,sizeof(wsa_state)); + + 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); - } + 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() */ + _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); - } + 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); - } + return (1); +} -void BIO_sock_cleanup(void) - { +void +BIO_sock_cleanup(void) +{ #ifdef OPENSSL_SYS_WINDOWS - if (wsa_init_done) - { - wsa_init_done=0; + if (wsa_init_done) { + wsa_init_done = 0; #if 0 /* this call is claimed to be non-present in Winsock2 */ WSACancelBlockingCall(); #endif WSACleanup(); - } + } #elif defined(OPENSSL_SYS_NETWARE) && !defined(NETWARE_BSDSOCK) - if (wsa_init_done) - { - wsa_init_done=0; - WSACleanup(); - } -#endif + if (wsa_init_done) { + wsa_init_done = 0; + WSACleanup(); } +#endif +} #if !defined(OPENSSL_SYS_VMS) || __VMS_VER >= 70000000 -int BIO_socket_ioctl(int fd, long type, void *arg) - { +int +BIO_socket_ioctl(int fd, long type, void *arg) +{ int i; #ifdef __DJGPP__ - i=ioctl(fd,type,(char *)arg); + i = ioctl(fd, type,(char *)arg); #else # if defined(OPENSSL_SYS_VMS) /* 2011-02-18 SMS. @@ -574,402 +558,399 @@ int BIO_socket_ioctl(int fd, long type, void *arg) # define ARG arg # endif /* defined(OPENSSL_SYS_VMS) [else] */ - i=ioctl(fd,type,ARG); + i = ioctl(fd, type, ARG); #endif /* __DJGPP__ */ if (i < 0) - SYSerr(SYS_F_IOCTLSOCKET,errno); - return(i); - } + SYSerr(SYS_F_IOCTLSOCKET, errno); + return (i); +} #endif /* __VMS_VER */ /* The reason I have implemented this instead of using sscanf is because * Visual C 1.52c gives an unresolved external when linking a DLL :-( */ -static int get_ip(const char *str, unsigned char ip[4]) - { +static int +get_ip(const char *str, unsigned char ip[4]) +{ unsigned int tmp[4]; - int num=0,c,ok=0; + int num = 0, c, ok = 0; - tmp[0]=tmp[1]=tmp[2]=tmp[3]=0; + tmp[0] = tmp[1] = tmp[2] = tmp[3] = 0; - for (;;) - { + for (;;) { c= *(str++); - if ((c >= '0') && (c <= '9')) - { - ok=1; - tmp[num]=tmp[num]*10+c-'0'; - if (tmp[num] > 255) return(0); - } - else if (c == '.') - { - if (!ok) return(-1); - if (num == 3) return(0); + if ((c >= '0') && (c <= '9')) { + ok = 1; + tmp[num] = tmp[num]*10 + c-'0'; + if (tmp[num] > 255) + return (0); + } else if (c == '.') { + if (!ok) + return (-1); + if (num == 3) + return (0); num++; - ok=0; - } - else if (c == '\0' && (num == 3) && ok) - break; + ok = 0; + } else if (c == '\0' && (num == 3) && ok) + break; else - return(0); - } - ip[0]=tmp[0]; - ip[1]=tmp[1]; - ip[2]=tmp[2]; - ip[3]=tmp[3]; - return(1); + return (0); } - -int BIO_get_accept_socket(char *host, int bind_mode) - { - int ret=0; + ip[0] = tmp[0]; + ip[1] = tmp[1]; + ip[2] = tmp[2]; + ip[3] = tmp[3]; + return (1); +} + +int +BIO_get_accept_socket(char *host, int bind_mode) +{ + int ret = 0; union { struct sockaddr sa; struct sockaddr_in sa_in; #if OPENSSL_USE_IPV6 struct sockaddr_in6 sa_in6; #endif - } server,client; - int s=-1,cs,addrlen; + } server, client; + int s = -1, cs, addrlen; unsigned char ip[4]; unsigned short port; - char *str=NULL,*e; - char *h,*p; + char *str = NULL, *e; + char *h, *p; unsigned long l; int err_num; - if (BIO_sock_init() != 1) return(-1); + if (BIO_sock_init() != 1) + return (-1); - if ((str=BUF_strdup(host)) == NULL) return(-1); + if ((str = BUF_strdup(host)) == NULL) + return (-1); - h=p=NULL; - h=str; - for (e=str; *e; e++) - { - if (*e == ':') - { - p=e; - } - else if (*e == '/') - { - *e='\0'; + h = p = NULL; + h = str; + for (e = str; *e; e++) { + if (*e == ':') { + p = e; + } else if (*e == '/') { + *e = '\0'; break; - } } - if (p) *p++='\0'; /* points at last ':', '::port' is special [see below] */ - else p=h,h=NULL; + } + if (p) + *p++='\0'; /* points at last ':', '::port' is special [see below] */ + else + p = h, h = NULL; #ifdef EAI_FAMILY do { - static union { void *p; - int (WSAAPI *f)(const char *,const char *, - const struct addrinfo *, - struct addrinfo **); - } p_getaddrinfo = {NULL}; - static union { void *p; + static union { + void *p; + int (WSAAPI *f)(const char *, const char *, + const struct addrinfo *, + struct addrinfo **); + } p_getaddrinfo = {NULL}; + static union { + void *p; void (WSAAPI *f)(struct addrinfo *); - } p_freeaddrinfo = {NULL}; - struct addrinfo *res,hint; - - if (p_getaddrinfo.p==NULL) - { - if ((p_getaddrinfo.p=DSO_global_lookup("getaddrinfo"))==NULL || - (p_freeaddrinfo.p=DSO_global_lookup("freeaddrinfo"))==NULL) - p_getaddrinfo.p=(void*)-1; - } - if (p_getaddrinfo.p==(void *)-1) break; - - /* '::port' enforces IPv6 wildcard listener. Some OSes, - * e.g. Solaris, default to IPv6 without any hint. Also - * note that commonly IPv6 wildchard socket can service - * IPv4 connections just as well... */ - memset(&hint,0,sizeof(hint)); - hint.ai_flags = AI_PASSIVE; - if (h) - { - if (strchr(h,':')) - { - if (h[1]=='\0') h=NULL; + } p_freeaddrinfo = {NULL}; + struct addrinfo *res, hint; + + if (p_getaddrinfo.p == NULL) { + if ((p_getaddrinfo.p = DSO_global_lookup("getaddrinfo"))==NULL || + (p_freeaddrinfo.p = DSO_global_lookup("freeaddrinfo"))==NULL) + p_getaddrinfo.p = (void*) - 1; + } + if (p_getaddrinfo.p == (void *) - 1) break; + + /* '::port' enforces IPv6 wildcard listener. Some OSes, + * e.g. Solaris, default to IPv6 without any hint. Also + * note that commonly IPv6 wildchard socket can service + * IPv4 connections just as well... */ + memset(&hint, 0, sizeof(hint)); + hint.ai_flags = AI_PASSIVE; + if (h) { + if (strchr(h, ':')) { + if (h[1] == '\0') + h = NULL; #if OPENSSL_USE_IPV6 - hint.ai_family = AF_INET6; + hint.ai_family = AF_INET6; #else - h=NULL; + h = NULL; #endif - } - else if (h[0]=='*' && h[1]=='\0') - { - hint.ai_family = AF_INET; - h=NULL; + } else if (h[0] == '*' && h[1] == '\0') { + hint.ai_family = AF_INET; + h = NULL; } } - if ((*p_getaddrinfo.f)(h,p,&hint,&res)) break; + if ((*p_getaddrinfo.f)(h, p, &hint, &res)) + break; - addrlen = res->ai_addrlen<=sizeof(server) ? - res->ai_addrlen : - sizeof(server); - memcpy(&server, res->ai_addr, addrlen); + addrlen = res->ai_addrlen <= sizeof(server) ? + res->ai_addrlen : sizeof(server); + memcpy(&server, res->ai_addr, addrlen); - (*p_freeaddrinfo.f)(res); - goto again; + (*p_freeaddrinfo.f)(res); + goto again; } while (0); #endif - if (!BIO_get_port(p,&port)) goto err; + if (!BIO_get_port(p, &port)) + goto err; - memset((char *)&server,0,sizeof(server)); - server.sa_in.sin_family=AF_INET; - server.sa_in.sin_port=htons(port); + memset((char *)&server, 0, sizeof(server)); + server.sa_in.sin_family = AF_INET; + server.sa_in.sin_port = htons(port); addrlen = sizeof(server.sa_in); - if (h == NULL || strcmp(h,"*") == 0) - server.sa_in.sin_addr.s_addr=INADDR_ANY; - else - { - if (!BIO_get_host_ip(h,&(ip[0]))) goto err; - l=(unsigned long) - ((unsigned long)ip[0]<<24L)| - ((unsigned long)ip[1]<<16L)| - ((unsigned long)ip[2]<< 8L)| - ((unsigned long)ip[3]); - server.sa_in.sin_addr.s_addr=htonl(l); - } + if (h == NULL || strcmp(h, "*") == 0) + server.sa_in.sin_addr.s_addr = INADDR_ANY; + else { + if (!BIO_get_host_ip(h, &(ip[0]))) + goto err; + l = (unsigned long) + ((unsigned long)ip[0]<<24L)| + ((unsigned long)ip[1]<<16L)| + ((unsigned long)ip[2]<< 8L)| + ((unsigned long)ip[3]); + server.sa_in.sin_addr.s_addr = htonl(l); + } again: - s=socket(server.sa.sa_family,SOCK_STREAM,SOCKET_PROTOCOL); - if (s == -1) - { - SYSerr(SYS_F_SOCKET,errno); - ERR_add_error_data(3,"port='",host,"'"); - BIOerr(BIO_F_BIO_GET_ACCEPT_SOCKET,BIO_R_UNABLE_TO_CREATE_SOCKET); + s = socket(server.sa.sa_family, SOCK_STREAM, SOCKET_PROTOCOL); + if (s == -1) { + SYSerr(SYS_F_SOCKET, errno); + ERR_add_error_data(3, "port = '", host, "'"); + BIOerr(BIO_F_BIO_GET_ACCEPT_SOCKET, BIO_R_UNABLE_TO_CREATE_SOCKET); goto err; - } + } #ifdef SO_REUSEADDR - if (bind_mode == BIO_BIND_REUSEADDR) - { - int i=1; + if (bind_mode == BIO_BIND_REUSEADDR) { + int i = 1; - ret=setsockopt(s,SOL_SOCKET,SO_REUSEADDR,(char *)&i,sizeof(i)); - bind_mode=BIO_BIND_NORMAL; - } + ret = setsockopt(s, SOL_SOCKET, SO_REUSEADDR,(char *)&i, sizeof(i)); + bind_mode = BIO_BIND_NORMAL; + } #endif - if (bind(s,&server.sa,addrlen) == -1) - { + if (bind(s, &server.sa, addrlen) == -1) { #ifdef SO_REUSEADDR - err_num=errno; + err_num = errno; if ((bind_mode == BIO_BIND_REUSEADDR_IF_UNUSED) && #ifdef OPENSSL_SYS_WINDOWS /* Some versions of Windows define EADDRINUSE to * a dummy value. */ - (err_num == WSAEADDRINUSE)) + (err_num == WSAEADDRINUSE)) #else - (err_num == EADDRINUSE)) + (err_num == EADDRINUSE)) #endif - { + { client = server; - if (h == NULL || strcmp(h,"*") == 0) - { + if (h == NULL || strcmp(h, "*") == 0) { #if OPENSSL_USE_IPV6 - if (client.sa.sa_family == AF_INET6) - { - memset(&client.sa_in6.sin6_addr,0,sizeof(client.sa_in6.sin6_addr)); - client.sa_in6.sin6_addr.s6_addr[15]=1; - } - else -#endif - if (client.sa.sa_family == AF_INET) - { - client.sa_in.sin_addr.s_addr=htonl(0x7F000001); - } - else goto err; - } - cs=socket(client.sa.sa_family,SOCK_STREAM,SOCKET_PROTOCOL); - if (cs != -1) - { + if (client.sa.sa_family == AF_INET6) { + memset(&client.sa_in6.sin6_addr, 0, sizeof(client.sa_in6.sin6_addr)); + client.sa_in6.sin6_addr.s6_addr[15] = 1; + } else +#endif + if (client.sa.sa_family == AF_INET) { + client.sa_in.sin_addr.s_addr = htonl(0x7F000001); + } else + goto err; + } + cs = socket(client.sa.sa_family, SOCK_STREAM, SOCKET_PROTOCOL); + if (cs != -1) { int ii; - ii=connect(cs,&client.sa,addrlen); + ii = connect(cs, &client.sa, addrlen); close(cs); - if (ii == -1) - { - bind_mode=BIO_BIND_REUSEADDR; + if (ii == -1) { + bind_mode = BIO_BIND_REUSEADDR; close(s); goto again; - } - /* else error */ } - /* else error */ + /* else error */ } + /* else error */ + } #endif - SYSerr(SYS_F_BIND,err_num); - ERR_add_error_data(3,"port='",host,"'"); - BIOerr(BIO_F_BIO_GET_ACCEPT_SOCKET,BIO_R_UNABLE_TO_BIND_SOCKET); + SYSerr(SYS_F_BIND, err_num); + ERR_add_error_data(3, "port = '", host, "'"); + BIOerr(BIO_F_BIO_GET_ACCEPT_SOCKET, BIO_R_UNABLE_TO_BIND_SOCKET); goto err; - } - if (listen(s,MAX_LISTEN) == -1) - { - SYSerr(SYS_F_BIND,errno); - ERR_add_error_data(3,"port='",host,"'"); - BIOerr(BIO_F_BIO_GET_ACCEPT_SOCKET,BIO_R_UNABLE_TO_LISTEN_SOCKET); + } + if (listen(s, MAX_LISTEN) == -1) { + SYSerr(SYS_F_BIND, errno); + ERR_add_error_data(3, "port = '", host, "'"); + BIOerr(BIO_F_BIO_GET_ACCEPT_SOCKET, BIO_R_UNABLE_TO_LISTEN_SOCKET); goto err; - } - ret=1; + } + ret = 1; err: - if (str != NULL) OPENSSL_free(str); - if ((ret == 0) && (s != -1)) - { + if (str != NULL) + OPENSSL_free(str); + if ((ret == 0) && (s != -1)) { close(s); - s= -1; - } - return(s); + s = -1; } + return (s); +} -int BIO_accept(int sock, char **addr) - { - int ret=-1; +int +BIO_accept(int sock, char **addr) +{ + int ret = -1; unsigned long l; unsigned short port; char *p; struct { - /* - * As for following union. Trouble is that there are platforms - * that have socklen_t and there are platforms that don't, on - * some platforms socklen_t is int and on some size_t. So what - * one can do? One can cook #ifdef spaghetti, which is nothing - * but masochistic. Or one can do union between int and size_t. - * One naturally does it primarily for 64-bit platforms where - * sizeof(int) != sizeof(size_t). But would it work? Note that - * if size_t member is initialized to 0, then later int member - * assignment naturally does the job on little-endian platforms - * regardless accept's expectations! What about big-endians? - * If accept expects int*, then it works, and if size_t*, then - * length value would appear as unreasonably large. But this - * won't prevent it from filling in the address structure. The - * trouble of course would be if accept returns more data than - * actual buffer can accomodate and overwrite stack... That's - * where early OPENSSL_assert comes into picture. Besides, the - * only 64-bit big-endian platform found so far that expects - * size_t* is HP-UX, where stack grows towards higher address. - * - */ - union { size_t s; int i; } len; - union { - struct sockaddr sa; - struct sockaddr_in sa_in; + /* + * As for following union. Trouble is that there are platforms + * that have socklen_t and there are platforms that don't, on + * some platforms socklen_t is int and on some size_t. So what + * one can do? One can cook #ifdef spaghetti, which is nothing + * but masochistic. Or one can do union between int and size_t. + * One naturally does it primarily for 64-bit platforms where + * sizeof(int) != sizeof(size_t). But would it work? Note that + * if size_t member is initialized to 0, then later int member + * assignment naturally does the job on little-endian platforms + * regardless accept's expectations! What about big-endians? + * If accept expects int*, then it works, and if size_t*, then + * length value would appear as unreasonably large. But this + * won't prevent it from filling in the address structure. The + * trouble of course would be if accept returns more data than + * actual buffer can accomodate and overwrite stack... That's + * where early OPENSSL_assert comes into picture. Besides, the + * only 64-bit big-endian platform found so far that expects + * size_t* is HP-UX, where stack grows towards higher address. + * + */ + union { + size_t s; + int i; + } len; + union { + struct sockaddr sa; + struct sockaddr_in sa_in; #if OPENSSL_USE_IPV6 - struct sockaddr_in6 sa_in6; + struct sockaddr_in6 sa_in6; #endif } from; } sa; - sa.len.s=0; - sa.len.i=sizeof(sa.from); - memset(&sa.from,0,sizeof(sa.from)); - ret=accept(sock,&sa.from.sa,(void *)&sa.len); - if (sizeof(sa.len.i)!=sizeof(sa.len.s) && sa.len.i==0) - { - OPENSSL_assert(sa.len.s<=sizeof(sa.from)); + sa.len.s = 0; + sa.len.i = sizeof(sa.from); + memset(&sa.from, 0, sizeof(sa.from)); + ret = accept(sock, &sa.from.sa,(void *)&sa.len); + if (sizeof(sa.len.i) != sizeof(sa.len.s) && sa.len.i == 0) { + OPENSSL_assert(sa.len.s <= sizeof(sa.from)); sa.len.i = (int)sa.len.s; /* use sa.len.i from this point */ - } - if (ret == -1) - { - if(BIO_sock_should_retry(ret)) return -2; - SYSerr(SYS_F_ACCEPT,errno); - BIOerr(BIO_F_BIO_ACCEPT,BIO_R_ACCEPT_ERROR); + } + if (ret == -1) { + if (BIO_sock_should_retry(ret)) return -2; + SYSerr(SYS_F_ACCEPT, errno); + BIOerr(BIO_F_BIO_ACCEPT, BIO_R_ACCEPT_ERROR); goto end; - } + } - if (addr == NULL) goto end; + if (addr == NULL) + goto end; #ifdef EAI_FAMILY do { - char h[NI_MAXHOST],s[NI_MAXSERV]; - size_t nl; - static union { void *p; - int (WSAAPI *f)(const struct sockaddr *,size_t/*socklen_t*/, - char *,size_t,char *,size_t,int); - } p_getnameinfo = {NULL}; - /* 2nd argument to getnameinfo is specified to - * be socklen_t. Unfortunately there is a number - * of environments where socklen_t is not defined. - * As it's passed by value, it's safe to pass it - * as size_t... */ - - if (p_getnameinfo.p==NULL) - { - if ((p_getnameinfo.p=DSO_global_lookup("getnameinfo"))==NULL) - p_getnameinfo.p=(void*)-1; + char h[NI_MAXHOST], s[NI_MAXSERV]; + size_t nl; + static union { + void *p; + int (WSAAPI *f)(const struct sockaddr *, + size_t/*socklen_t*/, char *, size_t, + char *, size_t, int); + } p_getnameinfo = {NULL}; + /* 2nd argument to getnameinfo is specified to + * be socklen_t. Unfortunately there is a number + * of environments where socklen_t is not defined. + * As it's passed by value, it's safe to pass it + * as size_t... */ + + if (p_getnameinfo.p == NULL) { + if ((p_getnameinfo.p = DSO_global_lookup("getnameinfo")) == NULL) + p_getnameinfo.p = (void*) - 1; + } + if (p_getnameinfo.p == (void *) - 1) + break; + + if ((*p_getnameinfo.f)(&sa.from.sa, sa.len.i, h, sizeof(h), + s, sizeof(s), NI_NUMERICHOST|NI_NUMERICSERV)) + break; + nl = strlen(h) + strlen(s) + 2; + p = *addr; + if (p) { + *p = '\0'; + p = OPENSSL_realloc(p, nl); + } else { + p = OPENSSL_malloc(nl); + } + if (p == NULL) { + BIOerr(BIO_F_BIO_ACCEPT, ERR_R_MALLOC_FAILURE); + goto end; } - if (p_getnameinfo.p==(void *)-1) break; - - if ((*p_getnameinfo.f)(&sa.from.sa,sa.len.i,h,sizeof(h),s,sizeof(s), - NI_NUMERICHOST|NI_NUMERICSERV)) break; - nl = strlen(h)+strlen(s)+2; - p = *addr; - if (p) { *p = '\0'; p = OPENSSL_realloc(p,nl); } - else { p = OPENSSL_malloc(nl); } - if (p==NULL) - { - BIOerr(BIO_F_BIO_ACCEPT,ERR_R_MALLOC_FAILURE); + *addr = p; + (void) snprintf(*addr, nl, "%s:%s", h, s); goto end; - } - *addr = p; - (void) snprintf(*addr,nl,"%s:%s",h,s); - goto end; - } while(0); -#endif - if (sa.from.sa.sa_family != AF_INET) goto end; - l=ntohl(sa.from.sa_in.sin_addr.s_addr); - port=ntohs(sa.from.sa_in.sin_port); - if (*addr == NULL) - { - if ((p=OPENSSL_malloc(24)) == NULL) - { - BIOerr(BIO_F_BIO_ACCEPT,ERR_R_MALLOC_FAILURE); + } while (0); +#endif + if (sa.from.sa.sa_family != AF_INET) + goto end; + l = ntohl(sa.from.sa_in.sin_addr.s_addr); + port = ntohs(sa.from.sa_in.sin_port); + if (*addr == NULL) { + if ((p = OPENSSL_malloc(24)) == NULL) { + BIOerr(BIO_F_BIO_ACCEPT, ERR_R_MALLOC_FAILURE); goto end; - } - *addr=p; } - (void) snprintf(*addr,24,"%d.%d.%d.%d:%d", - (unsigned char)(l>>24L)&0xff, - (unsigned char)(l>>16L)&0xff, - (unsigned char)(l>> 8L)&0xff, - (unsigned char)(l )&0xff, - port); -end: - return(ret); + *addr = p; } + (void) snprintf(*addr, 24, "%d.%d.%d.%d:%d", + (unsigned char)(l >> 24L) & 0xff, (unsigned char)(l >> 16L) & 0xff, + (unsigned char)(l >> 8L) & 0xff, (unsigned char)(l) & 0xff, port); -int BIO_set_tcp_ndelay(int s, int on) - { - int ret=0; +end: + return (ret); +} + +int +BIO_set_tcp_ndelay(int s, int on) +{ + int ret = 0; #if defined(TCP_NODELAY) && (defined(IPPROTO_TCP) || defined(SOL_TCP)) int opt; #ifdef SOL_TCP - opt=SOL_TCP; + opt = SOL_TCP; #else #ifdef IPPROTO_TCP - opt=IPPROTO_TCP; + opt = IPPROTO_TCP; #endif #endif - - ret=setsockopt(s,opt,TCP_NODELAY,(char *)&on,sizeof(on)); + + ret = setsockopt(s, opt, TCP_NODELAY,(char *)&on, sizeof(on)); #endif - return(ret == 0); - } + return (ret == 0); +} -int BIO_socket_nbio(int s, int mode) - { - int ret= -1; +int +BIO_socket_nbio(int s, int mode) +{ + int ret = -1; int l; - l=mode; + l = mode; #ifdef FIONBIO - ret=BIO_socket_ioctl(s,FIONBIO,&l); + ret = BIO_socket_ioctl(s, FIONBIO, &l); #endif - return(ret == 0); - } + return (ret == 0); +} #endif diff --git a/src/lib/libssl/src/crypto/bio/bf_buff.c b/src/lib/libssl/src/crypto/bio/bf_buff.c index 4b5a132d8a..9518cf977e 100644 --- a/src/lib/libssl/src/crypto/bio/bf_buff.c +++ b/src/lib/libssl/src/crypto/bio/bf_buff.c @@ -61,7 +61,7 @@ #include "cryptlib.h" #include -static int buffer_write(BIO *h, const char *buf,int num); +static int buffer_write(BIO *h, const char *buf, int num); static int buffer_read(BIO *h, char *buf, int size); static int buffer_puts(BIO *h, const char *str); static int buffer_gets(BIO *h, char *str, int size); @@ -71,8 +71,7 @@ static int buffer_free(BIO *data); static long buffer_callback_ctrl(BIO *h, int cmd, bio_info_cb *fp); #define DEFAULT_BUFFER_SIZE 4096 -static BIO_METHOD methods_buffer= - { +static BIO_METHOD methods_buffer = { BIO_TYPE_BUFFER, "buffer", buffer_write, @@ -83,430 +82,444 @@ static BIO_METHOD methods_buffer= buffer_new, buffer_free, buffer_callback_ctrl, - }; +}; -BIO_METHOD *BIO_f_buffer(void) - { - return(&methods_buffer); - } +BIO_METHOD +*BIO_f_buffer(void) +{ + return (&methods_buffer); +} -static int buffer_new(BIO *bi) - { +static int +buffer_new(BIO *bi) +{ BIO_F_BUFFER_CTX *ctx; - ctx=(BIO_F_BUFFER_CTX *)OPENSSL_malloc(sizeof(BIO_F_BUFFER_CTX)); - if (ctx == NULL) return(0); - ctx->ibuf=(char *)OPENSSL_malloc(DEFAULT_BUFFER_SIZE); - if (ctx->ibuf == NULL) { OPENSSL_free(ctx); return(0); } - ctx->obuf=(char *)OPENSSL_malloc(DEFAULT_BUFFER_SIZE); - if (ctx->obuf == NULL) { OPENSSL_free(ctx->ibuf); OPENSSL_free(ctx); return(0); } - ctx->ibuf_size=DEFAULT_BUFFER_SIZE; - ctx->obuf_size=DEFAULT_BUFFER_SIZE; - ctx->ibuf_len=0; - ctx->ibuf_off=0; - ctx->obuf_len=0; - ctx->obuf_off=0; - - bi->init=1; - bi->ptr=(char *)ctx; - bi->flags=0; - return(1); + ctx = (BIO_F_BUFFER_CTX *)OPENSSL_malloc(sizeof(BIO_F_BUFFER_CTX)); + if (ctx == NULL) + return (0); + ctx->ibuf = (char *)OPENSSL_malloc(DEFAULT_BUFFER_SIZE); + if (ctx->ibuf == NULL) { + OPENSSL_free(ctx); + return (0); } - -static int buffer_free(BIO *a) - { + ctx->obuf = (char *)OPENSSL_malloc(DEFAULT_BUFFER_SIZE); + if (ctx->obuf == NULL) { + OPENSSL_free(ctx->ibuf); + OPENSSL_free(ctx); + return (0); + } + ctx->ibuf_size = DEFAULT_BUFFER_SIZE; + ctx->obuf_size = DEFAULT_BUFFER_SIZE; + ctx->ibuf_len = 0; + ctx->ibuf_off = 0; + ctx->obuf_len = 0; + ctx->obuf_off = 0; + + bi->init = 1; + bi->ptr = (char *)ctx; + bi->flags = 0; + return (1); +} + +static int +buffer_free(BIO *a) +{ BIO_F_BUFFER_CTX *b; - if (a == NULL) return(0); - b=(BIO_F_BUFFER_CTX *)a->ptr; - if (b->ibuf != NULL) OPENSSL_free(b->ibuf); - if (b->obuf != NULL) OPENSSL_free(b->obuf); + if (a == NULL) + return (0); + b = (BIO_F_BUFFER_CTX *)a->ptr; + if (b->ibuf != NULL) + OPENSSL_free(b->ibuf); + if (b->obuf != NULL) + OPENSSL_free(b->obuf); OPENSSL_free(a->ptr); - a->ptr=NULL; - a->init=0; - a->flags=0; - return(1); - } - -static int buffer_read(BIO *b, char *out, int outl) - { - int i,num=0; + a->ptr = NULL; + a->init = 0; + a->flags = 0; + return (1); +} + +static int +buffer_read(BIO *b, char *out, int outl) +{ + int i, num = 0; BIO_F_BUFFER_CTX *ctx; - if (out == NULL) return(0); - ctx=(BIO_F_BUFFER_CTX *)b->ptr; + if (out == NULL) + return (0); + ctx = (BIO_F_BUFFER_CTX *)b->ptr; - if ((ctx == NULL) || (b->next_bio == NULL)) return(0); - num=0; + if ((ctx == NULL) || (b->next_bio == NULL)) + return (0); + num = 0; BIO_clear_retry_flags(b); start: - i=ctx->ibuf_len; + i = ctx->ibuf_len; /* If there is stuff left over, grab it */ - if (i != 0) - { - if (i > outl) i=outl; - memcpy(out,&(ctx->ibuf[ctx->ibuf_off]),i); - ctx->ibuf_off+=i; - ctx->ibuf_len-=i; - num+=i; - if (outl == i) return(num); - outl-=i; - out+=i; - } + if (i != 0) { + if (i > outl) + i = outl; + memcpy(out, &(ctx->ibuf[ctx->ibuf_off]), i); + ctx->ibuf_off += i; + ctx->ibuf_len -= i; + num += i; + if (outl == i) + return (num); + outl -= i; + out += i; + } /* We may have done a partial read. try to do more. * We have nothing in the buffer. * If we get an error and have read some data, just return it * and let them retry to get the error again. * copy direct to parent address space */ - if (outl > ctx->ibuf_size) - { - for (;;) - { - i=BIO_read(b->next_bio,out,outl); - if (i <= 0) - { + if (outl > ctx->ibuf_size) { + for (;;) { + i = BIO_read(b->next_bio, out, outl); + if (i <= 0) { BIO_copy_next_retry(b); - if (i < 0) return((num > 0)?num:i); - if (i == 0) return(num); - } - num+=i; - if (outl == i) return(num); - out+=i; - outl-=i; + if (i < 0) + return ((num > 0) ? num : i); + if (i == 0) + return (num); } + num += i; + if (outl == i) + return (num); + out += i; + outl -= i; } + } /* else */ /* we are going to be doing some buffering */ - i=BIO_read(b->next_bio,ctx->ibuf,ctx->ibuf_size); - if (i <= 0) - { + i = BIO_read(b->next_bio, ctx->ibuf, ctx->ibuf_size); + if (i <= 0) { BIO_copy_next_retry(b); - if (i < 0) return((num > 0)?num:i); - if (i == 0) return(num); - } - ctx->ibuf_off=0; - ctx->ibuf_len=i; + if (i < 0) + return ((num > 0) ? num : i); + if (i == 0) + return (num); + } + ctx->ibuf_off = 0; + ctx->ibuf_len = i; /* Lets re-read using ourselves :-) */ goto start; - } +} -static int buffer_write(BIO *b, const char *in, int inl) - { - int i,num=0; +static int +buffer_write(BIO *b, const char *in, int inl) +{ + int i, num = 0; BIO_F_BUFFER_CTX *ctx; - if ((in == NULL) || (inl <= 0)) return(0); - ctx=(BIO_F_BUFFER_CTX *)b->ptr; - if ((ctx == NULL) || (b->next_bio == NULL)) return(0); + if ((in == NULL) || (inl <= 0)) + return (0); + ctx = (BIO_F_BUFFER_CTX *)b->ptr; + if ((ctx == NULL) || (b->next_bio == NULL)) + return (0); BIO_clear_retry_flags(b); start: - i=ctx->obuf_size-(ctx->obuf_len+ctx->obuf_off); + i = ctx->obuf_size - (ctx->obuf_len + ctx->obuf_off); /* add to buffer and return */ - if (i >= inl) - { - memcpy(&(ctx->obuf[ctx->obuf_off+ctx->obuf_len]),in,inl); - ctx->obuf_len+=inl; - return(num+inl); - } + if (i >= inl) { + memcpy(&(ctx->obuf[ctx->obuf_off + ctx->obuf_len]), in, inl); + ctx->obuf_len += inl; + return (num + inl); + } /* else */ /* stuff already in buffer, so add to it first, then flush */ - if (ctx->obuf_len != 0) - { + if (ctx->obuf_len != 0) { if (i > 0) /* lets fill it up if we can */ - { - memcpy(&(ctx->obuf[ctx->obuf_off+ctx->obuf_len]),in,i); - in+=i; - inl-=i; - num+=i; - ctx->obuf_len+=i; - } + { + memcpy(&(ctx->obuf[ctx->obuf_off + ctx->obuf_len]), in, i); + in += i; + inl -= i; + num += i; + ctx->obuf_len += i; + } /* we now have a full buffer needing flushing */ - for (;;) - { - i=BIO_write(b->next_bio,&(ctx->obuf[ctx->obuf_off]), - ctx->obuf_len); - if (i <= 0) - { + for (;;) { + i = BIO_write(b->next_bio, &(ctx->obuf[ctx->obuf_off]), + ctx->obuf_len); + if (i <= 0) { BIO_copy_next_retry(b); - if (i < 0) return((num > 0)?num:i); - if (i == 0) return(num); - } - ctx->obuf_off+=i; - ctx->obuf_len-=i; - if (ctx->obuf_len == 0) break; + if (i < 0) + return ((num > 0) ? num : i); + if (i == 0) + return (num); } + ctx->obuf_off += i; + ctx->obuf_len -= i; + if (ctx->obuf_len == 0) + break; } + } /* we only get here if the buffer has been flushed and we * still have stuff to write */ - ctx->obuf_off=0; + ctx->obuf_off = 0; /* we now have inl bytes to write */ - while (inl >= ctx->obuf_size) - { - i=BIO_write(b->next_bio,in,inl); - if (i <= 0) - { + while (inl >= ctx->obuf_size) { + i = BIO_write(b->next_bio, in, inl); + if (i <= 0) { BIO_copy_next_retry(b); - if (i < 0) return((num > 0)?num:i); - if (i == 0) return(num); - } - num+=i; - in+=i; - inl-=i; - if (inl == 0) return(num); + if (i < 0) + return ((num > 0) ? num : i); + if (i == 0) + return (num); } + num += i; + in += i; + inl -= i; + if (inl == 0) + return (num); + } /* copy the rest into the buffer since we have only a small * amount left */ goto start; - } +} -static long buffer_ctrl(BIO *b, int cmd, long num, void *ptr) - { +static long +buffer_ctrl(BIO *b, int cmd, long num, void *ptr) +{ BIO *dbio; BIO_F_BUFFER_CTX *ctx; - long ret=1; - char *p1,*p2; - int r,i,*ip; - int ibs,obs; + long ret = 1; + char *p1, *p2; + int r, i, *ip; + int ibs, obs; - ctx=(BIO_F_BUFFER_CTX *)b->ptr; + ctx = (BIO_F_BUFFER_CTX *)b->ptr; - switch (cmd) - { + switch (cmd) { case BIO_CTRL_RESET: - ctx->ibuf_off=0; - ctx->ibuf_len=0; - ctx->obuf_off=0; - ctx->obuf_len=0; - if (b->next_bio == NULL) return(0); - ret=BIO_ctrl(b->next_bio,cmd,num,ptr); + ctx->ibuf_off = 0; + ctx->ibuf_len = 0; + ctx->obuf_off = 0; + ctx->obuf_len = 0; + if (b->next_bio == NULL) + return (0); + ret = BIO_ctrl(b->next_bio, cmd, num, ptr); break; case BIO_CTRL_INFO: - ret=(long)ctx->obuf_len; + ret = (long)ctx->obuf_len; break; case BIO_C_GET_BUFF_NUM_LINES: - ret=0; - p1=ctx->ibuf; - for (i=0; iibuf_len; i++) - { - if (p1[ctx->ibuf_off + i] == '\n') ret++; - } + ret = 0; + p1 = ctx->ibuf; + for (i = 0; i < ctx->ibuf_len; i++) { + if (p1[ctx->ibuf_off + i] == '\n') + ret++; + } break; case BIO_CTRL_WPENDING: - ret=(long)ctx->obuf_len; - if (ret == 0) - { - if (b->next_bio == NULL) return(0); - ret=BIO_ctrl(b->next_bio,cmd,num,ptr); - } + ret = (long)ctx->obuf_len; + if (ret == 0) { + if (b->next_bio == NULL) + return (0); + ret = BIO_ctrl(b->next_bio, cmd, num, ptr); + } break; case BIO_CTRL_PENDING: - ret=(long)ctx->ibuf_len; - if (ret == 0) - { - if (b->next_bio == NULL) return(0); - ret=BIO_ctrl(b->next_bio,cmd,num,ptr); - } + ret = (long)ctx->ibuf_len; + if (ret == 0) { + if (b->next_bio == NULL) + return (0); + ret = BIO_ctrl(b->next_bio, cmd, num, ptr); + } break; case BIO_C_SET_BUFF_READ_DATA: - if (num > ctx->ibuf_size) - { - p1=OPENSSL_malloc((int)num); - if (p1 == NULL) goto malloc_error; - if (ctx->ibuf != NULL) OPENSSL_free(ctx->ibuf); - ctx->ibuf=p1; - } - ctx->ibuf_off=0; - ctx->ibuf_len=(int)num; - memcpy(ctx->ibuf,ptr,(int)num); - ret=1; + if (num > ctx->ibuf_size) { + p1 = OPENSSL_malloc((int)num); + if (p1 == NULL) + goto malloc_error; + if (ctx->ibuf != NULL) + OPENSSL_free(ctx->ibuf); + ctx->ibuf = p1; + } + ctx->ibuf_off = 0; + ctx->ibuf_len = (int)num; + memcpy(ctx->ibuf, ptr,(int)num); + ret = 1; break; case BIO_C_SET_BUFF_SIZE: - if (ptr != NULL) - { - ip=(int *)ptr; - if (*ip == 0) - { - ibs=(int)num; - obs=ctx->obuf_size; - } - else /* if (*ip == 1) */ - { - ibs=ctx->ibuf_size; - obs=(int)num; - } - } - else - { - ibs=(int)num; - obs=(int)num; + if (ptr != NULL) { + ip = (int *)ptr; + if (*ip == 0) { + ibs = (int)num; + obs = ctx->obuf_size; } - p1=ctx->ibuf; - p2=ctx->obuf; - if ((ibs > DEFAULT_BUFFER_SIZE) && (ibs != ctx->ibuf_size)) + else /* if (*ip == 1) */ { - p1=(char *)OPENSSL_malloc((int)num); - if (p1 == NULL) goto malloc_error; + ibs = ctx->ibuf_size; + obs = (int)num; } - if ((obs > DEFAULT_BUFFER_SIZE) && (obs != ctx->obuf_size)) - { - p2=(char *)OPENSSL_malloc((int)num); - if (p2 == NULL) - { - if (p1 != ctx->ibuf) OPENSSL_free(p1); + } else { + ibs = (int)num; + obs = (int)num; + } + p1 = ctx->ibuf; + p2 = ctx->obuf; + if ((ibs > DEFAULT_BUFFER_SIZE) && (ibs != ctx->ibuf_size)) { + p1 = (char *)OPENSSL_malloc((int)num); + if (p1 == NULL) + goto malloc_error; + } + if ((obs > DEFAULT_BUFFER_SIZE) && (obs != ctx->obuf_size)) { + p2 = (char *)OPENSSL_malloc((int)num); + if (p2 == NULL) { + if (p1 != ctx->ibuf) + OPENSSL_free(p1); goto malloc_error; - } } - if (ctx->ibuf != p1) - { + } + if (ctx->ibuf != p1) { OPENSSL_free(ctx->ibuf); - ctx->ibuf=p1; - ctx->ibuf_off=0; - ctx->ibuf_len=0; - ctx->ibuf_size=ibs; - } - if (ctx->obuf != p2) - { + ctx->ibuf = p1; + ctx->ibuf_off = 0; + ctx->ibuf_len = 0; + ctx->ibuf_size = ibs; + } + if (ctx->obuf != p2) { OPENSSL_free(ctx->obuf); - ctx->obuf=p2; - ctx->obuf_off=0; - ctx->obuf_len=0; - ctx->obuf_size=obs; - } + ctx->obuf = p2; + ctx->obuf_off = 0; + ctx->obuf_len = 0; + ctx->obuf_size = obs; + } break; case BIO_C_DO_STATE_MACHINE: - if (b->next_bio == NULL) return(0); + if (b->next_bio == NULL) + return (0); BIO_clear_retry_flags(b); - ret=BIO_ctrl(b->next_bio,cmd,num,ptr); + ret = BIO_ctrl(b->next_bio, cmd, num, ptr); BIO_copy_next_retry(b); break; case BIO_CTRL_FLUSH: - if (b->next_bio == NULL) return(0); - if (ctx->obuf_len <= 0) - { - ret=BIO_ctrl(b->next_bio,cmd,num,ptr); + if (b->next_bio == NULL) + return (0); + if (ctx->obuf_len <= 0) { + ret = BIO_ctrl(b->next_bio, cmd, num, ptr); break; - } + } - for (;;) - { + for (;;) { BIO_clear_retry_flags(b); - if (ctx->obuf_len > 0) - { - r=BIO_write(b->next_bio, - &(ctx->obuf[ctx->obuf_off]), - ctx->obuf_len); + if (ctx->obuf_len > 0) { + r = BIO_write(b->next_bio, + &(ctx->obuf[ctx->obuf_off]), + ctx->obuf_len); #if 0 -fprintf(stderr,"FLUSH [%3d] %3d -> %3d\n",ctx->obuf_off,ctx->obuf_len,r); + fprintf(stderr, "FLUSH [%3d] %3d -> %3d\n", ctx->obuf_off, ctx->obuf_len, r); #endif BIO_copy_next_retry(b); - if (r <= 0) return((long)r); - ctx->obuf_off+=r; - ctx->obuf_len-=r; - } - else - { - ctx->obuf_len=0; - ctx->obuf_off=0; - ret=1; + if (r <= 0) + return ((long)r); + ctx->obuf_off += r; + ctx->obuf_len -= r; + } else { + ctx->obuf_len = 0; + ctx->obuf_off = 0; + ret = 1; break; - } } - ret=BIO_ctrl(b->next_bio,cmd,num,ptr); + } + ret = BIO_ctrl(b->next_bio, cmd, num, ptr); break; case BIO_CTRL_DUP: - dbio=(BIO *)ptr; - if ( !BIO_set_read_buffer_size(dbio,ctx->ibuf_size) || - !BIO_set_write_buffer_size(dbio,ctx->obuf_size)) - ret=0; + dbio = (BIO *)ptr; + if (!BIO_set_read_buffer_size(dbio, ctx->ibuf_size) || + !BIO_set_write_buffer_size(dbio, ctx->obuf_size)) + ret = 0; break; default: - if (b->next_bio == NULL) return(0); - ret=BIO_ctrl(b->next_bio,cmd,num,ptr); + if (b->next_bio == NULL) + return (0); + ret = BIO_ctrl(b->next_bio, cmd, num, ptr); break; - } - return(ret); -malloc_error: - BIOerr(BIO_F_BUFFER_CTRL,ERR_R_MALLOC_FAILURE); - return(0); } - -static long buffer_callback_ctrl(BIO *b, int cmd, bio_info_cb *fp) - { - long ret=1; - - if (b->next_bio == NULL) return(0); - switch (cmd) - { + return (ret); +malloc_error: + BIOerr(BIO_F_BUFFER_CTRL, ERR_R_MALLOC_FAILURE); + return (0); +} + +static long +buffer_callback_ctrl(BIO *b, int cmd, bio_info_cb *fp) +{ + long ret = 1; + + if (b->next_bio == NULL) + return (0); + switch (cmd) { default: - ret=BIO_callback_ctrl(b->next_bio,cmd,fp); + ret = BIO_callback_ctrl(b->next_bio, cmd, fp); break; - } - return(ret); } + return (ret); +} -static int buffer_gets(BIO *b, char *buf, int size) - { +static int +buffer_gets(BIO *b, char *buf, int size) +{ BIO_F_BUFFER_CTX *ctx; - int num=0,i,flag; + int num = 0, i, flag; char *p; - ctx=(BIO_F_BUFFER_CTX *)b->ptr; + ctx = (BIO_F_BUFFER_CTX *)b->ptr; size--; /* reserve space for a '\0' */ BIO_clear_retry_flags(b); - for (;;) - { - if (ctx->ibuf_len > 0) - { - p= &(ctx->ibuf[ctx->ibuf_off]); - flag=0; - for (i=0; (iibuf_len) && (iibuf_len > 0) { + p = &(ctx->ibuf[ctx->ibuf_off]); + flag = 0; + for (i = 0; (i < ctx->ibuf_len) && (i < size); i++) { + *(buf++) = p[i]; + if (p[i] == '\n') { + flag = 1; i++; break; - } - } - num+=i; - size-=i; - ctx->ibuf_len-=i; - ctx->ibuf_off+=i; - if (flag || size == 0) - { - *buf='\0'; - return(num); } } + num += i; + size -= i; + ctx->ibuf_len -= i; + ctx->ibuf_off += i; + if (flag || size == 0) { + *buf = '\0'; + return (num); + } + } else /* read another chunk */ - { - i=BIO_read(b->next_bio,ctx->ibuf,ctx->ibuf_size); - if (i <= 0) - { + { + i = BIO_read(b->next_bio, ctx->ibuf, ctx->ibuf_size); + if (i <= 0) { BIO_copy_next_retry(b); - *buf='\0'; - if (i < 0) return((num > 0)?num:i); - if (i == 0) return(num); - } - ctx->ibuf_len=i; - ctx->ibuf_off=0; + *buf = '\0'; + if (i < 0) + return ((num > 0) ? num : i); + if (i == 0) + return (num); } + ctx->ibuf_len = i; + ctx->ibuf_off = 0; } } +} -static int buffer_puts(BIO *b, const char *str) - { - return(buffer_write(b,str,strlen(str))); - } - +static int +buffer_puts(BIO *b, const char *str) +{ + return (buffer_write(b, str, strlen(str))); +} diff --git a/src/lib/libssl/src/crypto/bio/bf_lbuf.c b/src/lib/libssl/src/crypto/bio/bf_lbuf.c index ec0f7eb0b7..838839f1bf 100644 --- a/src/lib/libssl/src/crypto/bio/bf_lbuf.c +++ b/src/lib/libssl/src/crypto/bio/bf_lbuf.c @@ -62,7 +62,7 @@ #include #include -static int linebuffer_write(BIO *h, const char *buf,int num); +static int linebuffer_write(BIO *h, const char *buf, int num); static int linebuffer_read(BIO *h, char *buf, int size); static int linebuffer_puts(BIO *h, const char *str); static int linebuffer_gets(BIO *h, char *str, int size); @@ -76,8 +76,7 @@ static long linebuffer_callback_ctrl(BIO *h, int cmd, bio_info_cb *fp); /* #define DEBUG */ -static BIO_METHOD methods_linebuffer= - { +static BIO_METHOD methods_linebuffer = { BIO_TYPE_LINEBUFFER, "linebuffer", linebuffer_write, @@ -88,310 +87,313 @@ static BIO_METHOD methods_linebuffer= linebuffer_new, linebuffer_free, linebuffer_callback_ctrl, - }; +}; -BIO_METHOD *BIO_f_linebuffer(void) - { - return(&methods_linebuffer); - } +BIO_METHOD +*BIO_f_linebuffer(void) +{ + return (&methods_linebuffer); +} -typedef struct bio_linebuffer_ctx_struct - { +typedef struct bio_linebuffer_ctx_struct { char *obuf; /* the output char array */ int obuf_size; /* how big is the output buffer */ int obuf_len; /* how many bytes are in it */ - } BIO_LINEBUFFER_CTX; +} BIO_LINEBUFFER_CTX; -static int linebuffer_new(BIO *bi) - { +static int +linebuffer_new(BIO *bi) +{ BIO_LINEBUFFER_CTX *ctx; - ctx=(BIO_LINEBUFFER_CTX *)OPENSSL_malloc(sizeof(BIO_LINEBUFFER_CTX)); - if (ctx == NULL) return(0); - ctx->obuf=(char *)OPENSSL_malloc(DEFAULT_LINEBUFFER_SIZE); - if (ctx->obuf == NULL) { OPENSSL_free(ctx); return(0); } - ctx->obuf_size=DEFAULT_LINEBUFFER_SIZE; - ctx->obuf_len=0; - - bi->init=1; - bi->ptr=(char *)ctx; - bi->flags=0; - return(1); + ctx = (BIO_LINEBUFFER_CTX *)OPENSSL_malloc(sizeof(BIO_LINEBUFFER_CTX)); + if (ctx == NULL) + return (0); + ctx->obuf = (char *)OPENSSL_malloc(DEFAULT_LINEBUFFER_SIZE); + if (ctx->obuf == NULL) { + OPENSSL_free(ctx); + return (0); } + ctx->obuf_size = DEFAULT_LINEBUFFER_SIZE; + ctx->obuf_len = 0; + + bi->init = 1; + bi->ptr = (char *)ctx; + bi->flags = 0; + return (1); +} -static int linebuffer_free(BIO *a) - { +static int +linebuffer_free(BIO *a) +{ BIO_LINEBUFFER_CTX *b; - if (a == NULL) return(0); - b=(BIO_LINEBUFFER_CTX *)a->ptr; - if (b->obuf != NULL) OPENSSL_free(b->obuf); + if (a == NULL) + return (0); + b = (BIO_LINEBUFFER_CTX *)a->ptr; + if (b->obuf != NULL) + OPENSSL_free(b->obuf); OPENSSL_free(a->ptr); - a->ptr=NULL; - a->init=0; - a->flags=0; - return(1); - } - -static int linebuffer_read(BIO *b, char *out, int outl) - { - int ret=0; - - if (out == NULL) return(0); - if (b->next_bio == NULL) return(0); - ret=BIO_read(b->next_bio,out,outl); + a->ptr = NULL; + a->init = 0; + a->flags = 0; + return (1); +} + +static int +linebuffer_read(BIO *b, char *out, int outl) +{ + int ret = 0; + + if (out == NULL) + return (0); + if (b->next_bio == NULL) + return (0); + ret = BIO_read(b->next_bio, out, outl); BIO_clear_retry_flags(b); BIO_copy_next_retry(b); - return(ret); - } + return (ret); +} -static int linebuffer_write(BIO *b, const char *in, int inl) - { - int i,num=0,foundnl; +static int +linebuffer_write(BIO *b, const char *in, int inl) +{ + int i, num = 0, foundnl; BIO_LINEBUFFER_CTX *ctx; - if ((in == NULL) || (inl <= 0)) return(0); - ctx=(BIO_LINEBUFFER_CTX *)b->ptr; - if ((ctx == NULL) || (b->next_bio == NULL)) return(0); + if ((in == NULL) || (inl <= 0)) + return (0); + ctx = (BIO_LINEBUFFER_CTX *)b->ptr; + if ((ctx == NULL) || (b->next_bio == NULL)) + return (0); BIO_clear_retry_flags(b); - do - { + do { const char *p; - for(p = in; p < in + inl && *p != '\n'; p++) + for (p = in; p < in + inl && *p != '\n'; p++) ; - if (*p == '\n') - { + if (*p == '\n') { p++; foundnl = 1; - } - else + } else foundnl = 0; /* If a NL was found and we already have text in the save buffer, concatenate them and write */ - while ((foundnl || p - in > ctx->obuf_size - ctx->obuf_len) - && ctx->obuf_len > 0) - { + while ((foundnl || p - in > ctx->obuf_size - ctx->obuf_len) && + ctx->obuf_len > 0) { int orig_olen = ctx->obuf_len; - + i = ctx->obuf_size - ctx->obuf_len; - if (p - in > 0) - { - if (i >= p - in) - { + if (p - in > 0) { + if (i >= p - in) { memcpy(&(ctx->obuf[ctx->obuf_len]), - in,p - in); + in, p - in); ctx->obuf_len += p - in; inl -= p - in; num += p - in; in = p; - } - else - { + } else { memcpy(&(ctx->obuf[ctx->obuf_len]), - in,i); + in, i); ctx->obuf_len += i; inl -= i; in += i; num += i; - } } + } #if 0 -BIO_write(b->next_bio, "<*<", 3); + BIO_write(b->next_bio, "<*<", 3); #endif - i=BIO_write(b->next_bio, - ctx->obuf, ctx->obuf_len); - if (i <= 0) - { + i = BIO_write(b->next_bio, ctx->obuf, ctx->obuf_len); + if (i <= 0) { ctx->obuf_len = orig_olen; BIO_copy_next_retry(b); - #if 0 -BIO_write(b->next_bio, ">*>", 3); + BIO_write(b->next_bio, ">*>", 3); #endif - if (i < 0) return((num > 0)?num:i); - if (i == 0) return(num); - } + if (i < 0) + return ((num > 0) ? num : i); + if (i == 0) + return (num); + } #if 0 -BIO_write(b->next_bio, ">*>", 3); + BIO_write(b->next_bio, ">*>", 3); #endif if (i < ctx->obuf_len) memmove(ctx->obuf, ctx->obuf + i, - ctx->obuf_len - i); - ctx->obuf_len-=i; - } + ctx->obuf_len - i); + ctx->obuf_len -= i; + } /* Now that the save buffer is emptied, let's write the input buffer if a NL was found and there is anything to write. */ - if ((foundnl || p - in > ctx->obuf_size) && p - in > 0) - { + if ((foundnl || p - in > ctx->obuf_size) && p - in > 0) { #if 0 -BIO_write(b->next_bio, "<*<", 3); + BIO_write(b->next_bio, "<*<", 3); #endif - i=BIO_write(b->next_bio,in,p - in); - if (i <= 0) - { + i = BIO_write(b->next_bio, in, p - in); + if (i <= 0) { BIO_copy_next_retry(b); #if 0 -BIO_write(b->next_bio, ">*>", 3); + BIO_write(b->next_bio, ">*>", 3); #endif - if (i < 0) return((num > 0)?num:i); - if (i == 0) return(num); - } + if (i < 0) + return ((num > 0) ? num : i); + if (i == 0) + return (num); + } #if 0 -BIO_write(b->next_bio, ">*>", 3); + BIO_write(b->next_bio, ">*>", 3); #endif - num+=i; - in+=i; - inl-=i; - } + num += i; + in += i; + inl -= i; } - while(foundnl && inl > 0); + } while (foundnl && inl > 0); /* We've written as much as we can. The rest of the input buffer, if any, is text that doesn't and with a NL and therefore needs to be saved for the next trip. */ - if (inl > 0) - { + if (inl > 0) { memcpy(&(ctx->obuf[ctx->obuf_len]), in, inl); ctx->obuf_len += inl; num += inl; - } - return num; } + return num; +} -static long linebuffer_ctrl(BIO *b, int cmd, long num, void *ptr) - { +static long +linebuffer_ctrl(BIO *b, int cmd, long num, void *ptr) +{ BIO *dbio; BIO_LINEBUFFER_CTX *ctx; - long ret=1; + long ret = 1; char *p; int r; int obs; - ctx=(BIO_LINEBUFFER_CTX *)b->ptr; + ctx = (BIO_LINEBUFFER_CTX *)b->ptr; - switch (cmd) - { + switch (cmd) { case BIO_CTRL_RESET: - ctx->obuf_len=0; - if (b->next_bio == NULL) return(0); - ret=BIO_ctrl(b->next_bio,cmd,num,ptr); + ctx->obuf_len = 0; + if (b->next_bio == NULL) + return (0); + ret = BIO_ctrl(b->next_bio, cmd, num, ptr); break; case BIO_CTRL_INFO: - ret=(long)ctx->obuf_len; + ret = (long)ctx->obuf_len; break; case BIO_CTRL_WPENDING: - ret=(long)ctx->obuf_len; - if (ret == 0) - { - if (b->next_bio == NULL) return(0); - ret=BIO_ctrl(b->next_bio,cmd,num,ptr); - } + ret = (long)ctx->obuf_len; + if (ret == 0) { + if (b->next_bio == NULL) + return (0); + ret = BIO_ctrl(b->next_bio, cmd, num, ptr); + } break; case BIO_C_SET_BUFF_SIZE: - obs=(int)num; - p=ctx->obuf; - if ((obs > DEFAULT_LINEBUFFER_SIZE) && (obs != ctx->obuf_size)) - { - p=(char *)OPENSSL_malloc((int)num); + obs = (int)num; + p = ctx->obuf; + if ((obs > DEFAULT_LINEBUFFER_SIZE) && (obs != ctx->obuf_size)) { + p = (char *)OPENSSL_malloc((int)num); if (p == NULL) goto malloc_error; - } - if (ctx->obuf != p) - { - if (ctx->obuf_len > obs) - { + } + if (ctx->obuf != p) { + if (ctx->obuf_len > obs) { ctx->obuf_len = obs; - } + } memcpy(p, ctx->obuf, ctx->obuf_len); OPENSSL_free(ctx->obuf); - ctx->obuf=p; - ctx->obuf_size=obs; - } + ctx->obuf = p; + ctx->obuf_size = obs; + } break; case BIO_C_DO_STATE_MACHINE: - if (b->next_bio == NULL) return(0); + if (b->next_bio == NULL) + return (0); BIO_clear_retry_flags(b); - ret=BIO_ctrl(b->next_bio,cmd,num,ptr); + ret = BIO_ctrl(b->next_bio, cmd, num, ptr); BIO_copy_next_retry(b); break; case BIO_CTRL_FLUSH: - if (b->next_bio == NULL) return(0); - if (ctx->obuf_len <= 0) - { - ret=BIO_ctrl(b->next_bio,cmd,num,ptr); + if (b->next_bio == NULL) + return (0); + if (ctx->obuf_len <= 0) { + ret = BIO_ctrl(b->next_bio, cmd, num, ptr); break; - } + } - for (;;) - { + for (;;) { BIO_clear_retry_flags(b); - if (ctx->obuf_len > 0) - { - r=BIO_write(b->next_bio, - ctx->obuf, ctx->obuf_len); + if (ctx->obuf_len > 0) { + r = BIO_write(b->next_bio, + ctx->obuf, ctx->obuf_len); #if 0 -fprintf(stderr,"FLUSH %3d -> %3d\n",ctx->obuf_len,r); + fprintf(stderr, "FLUSH %3d -> %3d\n", ctx->obuf_len, r); #endif BIO_copy_next_retry(b); - if (r <= 0) return((long)r); + if (r <= 0) + return ((long)r); if (r < ctx->obuf_len) memmove(ctx->obuf, ctx->obuf + r, - ctx->obuf_len - r); - ctx->obuf_len-=r; - } - else - { - ctx->obuf_len=0; - ret=1; + ctx->obuf_len - r); + ctx->obuf_len -= r; + } else { + ctx->obuf_len = 0; + ret = 1; break; - } } - ret=BIO_ctrl(b->next_bio,cmd,num,ptr); + } + ret = BIO_ctrl(b->next_bio, cmd, num, ptr); break; case BIO_CTRL_DUP: - dbio=(BIO *)ptr; - if ( !BIO_set_write_buffer_size(dbio,ctx->obuf_size)) - ret=0; + dbio = (BIO *)ptr; + if (!BIO_set_write_buffer_size(dbio, ctx->obuf_size)) + ret = 0; break; default: - if (b->next_bio == NULL) return(0); - ret=BIO_ctrl(b->next_bio,cmd,num,ptr); + if (b->next_bio == NULL) + return (0); + ret = BIO_ctrl(b->next_bio, cmd, num, ptr); break; - } - return(ret); -malloc_error: - BIOerr(BIO_F_LINEBUFFER_CTRL,ERR_R_MALLOC_FAILURE); - return(0); } + return (ret); +malloc_error: + BIOerr(BIO_F_LINEBUFFER_CTRL, ERR_R_MALLOC_FAILURE); + return (0); +} -static long linebuffer_callback_ctrl(BIO *b, int cmd, bio_info_cb *fp) - { - long ret=1; +static long +linebuffer_callback_ctrl(BIO *b, int cmd, bio_info_cb *fp) +{ + long ret = 1; - if (b->next_bio == NULL) return(0); - switch (cmd) - { + if (b->next_bio == NULL) + return (0); + switch (cmd) { default: - ret=BIO_callback_ctrl(b->next_bio,cmd,fp); + ret = BIO_callback_ctrl(b->next_bio, cmd, fp); break; - } - return(ret); } + return (ret); +} -static int linebuffer_gets(BIO *b, char *buf, int size) - { - if (b->next_bio == NULL) return(0); - return(BIO_gets(b->next_bio,buf,size)); - } - -static int linebuffer_puts(BIO *b, const char *str) - { - return(linebuffer_write(b,str,strlen(str))); - } +static int +linebuffer_gets(BIO *b, char *buf, int size) +{ + if (b->next_bio == NULL) + return (0); + return (BIO_gets(b->next_bio, buf, size)); +} +static int +linebuffer_puts(BIO *b, const char *str) +{ + return (linebuffer_write(b, str, strlen(str))); +} diff --git a/src/lib/libssl/src/crypto/bio/bf_nbio.c b/src/lib/libssl/src/crypto/bio/bf_nbio.c index 028616c064..76f8f31950 100644 --- a/src/lib/libssl/src/crypto/bio/bf_nbio.c +++ b/src/lib/libssl/src/crypto/bio/bf_nbio.c @@ -65,23 +65,22 @@ /* BIO_put and BIO_get both add to the digest, * BIO_gets returns the digest */ -static int nbiof_write(BIO *h,const char *buf,int num); -static int nbiof_read(BIO *h,char *buf,int size); -static int nbiof_puts(BIO *h,const char *str); -static int nbiof_gets(BIO *h,char *str,int size); -static long nbiof_ctrl(BIO *h,int cmd,long arg1,void *arg2); +static int nbiof_write(BIO *h, const char *buf, int num); +static int nbiof_read(BIO *h, char *buf, int size); +static int nbiof_puts(BIO *h, const char *str); +static int nbiof_gets(BIO *h, char *str, int size); +static long nbiof_ctrl(BIO *h, int cmd, long arg1, void *arg2); static int nbiof_new(BIO *h); static int nbiof_free(BIO *data); -static long nbiof_callback_ctrl(BIO *h,int cmd,bio_info_cb *fp); -typedef struct nbio_test_st - { +static long nbiof_callback_ctrl(BIO *h, int cmd, bio_info_cb *fp); + +typedef struct nbio_test_st { /* only set if we sent a 'should retry' error */ int lrn; int lwn; - } NBIO_TEST; +} NBIO_TEST; -static BIO_METHOD methods_nbiof= - { +static BIO_METHOD methods_nbiof = { BIO_TYPE_NBIO_TEST, "non-blocking IO test filter", nbiof_write, @@ -92,162 +91,170 @@ static BIO_METHOD methods_nbiof= nbiof_new, nbiof_free, nbiof_callback_ctrl, - }; +}; -BIO_METHOD *BIO_f_nbio_test(void) - { - return(&methods_nbiof); - } +BIO_METHOD +*BIO_f_nbio_test(void) +{ + return (&methods_nbiof); +} -static int nbiof_new(BIO *bi) - { +static int +nbiof_new(BIO *bi) +{ NBIO_TEST *nt; - if (!(nt=(NBIO_TEST *)OPENSSL_malloc(sizeof(NBIO_TEST)))) return(0); - nt->lrn= -1; - nt->lwn= -1; - bi->ptr=(char *)nt; - bi->init=1; - bi->flags=0; - return(1); - } + if (!(nt = (NBIO_TEST *)OPENSSL_malloc(sizeof(NBIO_TEST)))) + return (0); + nt->lrn = -1; + nt->lwn = -1; + bi->ptr = (char *)nt; + bi->init = 1; + bi->flags = 0; + return (1); +} -static int nbiof_free(BIO *a) - { - if (a == NULL) return(0); +static int +nbiof_free(BIO *a) +{ + if (a == NULL) + return (0); if (a->ptr != NULL) OPENSSL_free(a->ptr); - a->ptr=NULL; - a->init=0; - a->flags=0; - return(1); - } - -static int nbiof_read(BIO *b, char *out, int outl) - { - int ret=0; + a->ptr = NULL; + a->init = 0; + a->flags = 0; + return (1); +} + +static int +nbiof_read(BIO *b, char *out, int outl) +{ + int ret = 0; #if 1 int num; unsigned char n; #endif - if (out == NULL) return(0); - if (b->next_bio == NULL) return(0); + if (out == NULL) + return (0); + if (b->next_bio == NULL) + return (0); BIO_clear_retry_flags(b); #if 1 - RAND_pseudo_bytes(&n,1); - num=(n&0x07); + RAND_pseudo_bytes(&n, 1); + num = (n & 0x07); - if (outl > num) outl=num; + if (outl > num) + outl = num; - if (num == 0) - { - ret= -1; + if (num == 0) { + ret = -1; BIO_set_retry_read(b); - } - else + } else #endif - { - ret=BIO_read(b->next_bio,out,outl); + { + ret = BIO_read(b->next_bio, out, outl); if (ret < 0) BIO_copy_next_retry(b); - } - return(ret); } + return (ret); +} -static int nbiof_write(BIO *b, const char *in, int inl) - { +static int +nbiof_write(BIO *b, const char *in, int inl) +{ NBIO_TEST *nt; - int ret=0; + int ret = 0; int num; unsigned char n; - if ((in == NULL) || (inl <= 0)) return(0); - if (b->next_bio == NULL) return(0); - nt=(NBIO_TEST *)b->ptr; + if ((in == NULL) || (inl <= 0)) + return (0); + if (b->next_bio == NULL) + return (0); + nt = (NBIO_TEST *)b->ptr; BIO_clear_retry_flags(b); #if 1 - if (nt->lwn > 0) - { - num=nt->lwn; - nt->lwn=0; - } - else - { - RAND_pseudo_bytes(&n,1); - num=(n&7); - } + if (nt->lwn > 0) { + num = nt->lwn; + nt->lwn = 0; + } else { + RAND_pseudo_bytes(&n, 1); + num = (n&7); + } - if (inl > num) inl=num; + if (inl > num) + inl = num; - if (num == 0) - { - ret= -1; + if (num == 0) { + ret = -1; BIO_set_retry_write(b); - } - else + } else #endif - { - ret=BIO_write(b->next_bio,in,inl); - if (ret < 0) - { + { + ret = BIO_write(b->next_bio, in, inl); + if (ret < 0) { BIO_copy_next_retry(b); - nt->lwn=inl; - } + nt->lwn = inl; } - return(ret); } + return (ret); +} -static long nbiof_ctrl(BIO *b, int cmd, long num, void *ptr) - { +static long +nbiof_ctrl(BIO *b, int cmd, long num, void *ptr) +{ long ret; - if (b->next_bio == NULL) return(0); - switch (cmd) - { - case BIO_C_DO_STATE_MACHINE: + if (b->next_bio == NULL) + return (0); + switch (cmd) { + case BIO_C_DO_STATE_MACHINE: BIO_clear_retry_flags(b); - ret=BIO_ctrl(b->next_bio,cmd,num,ptr); + ret = BIO_ctrl(b->next_bio, cmd, num, ptr); BIO_copy_next_retry(b); break; case BIO_CTRL_DUP: - ret=0L; + ret = 0L; break; default: - ret=BIO_ctrl(b->next_bio,cmd,num,ptr); + ret = BIO_ctrl(b->next_bio, cmd, num, ptr); break; - } - return(ret); } + return (ret); +} -static long nbiof_callback_ctrl(BIO *b, int cmd, bio_info_cb *fp) - { - long ret=1; +static long +nbiof_callback_ctrl(BIO *b, int cmd, bio_info_cb *fp) +{ + long ret = 1; - if (b->next_bio == NULL) return(0); - switch (cmd) - { + if (b->next_bio == NULL) + return (0); + switch (cmd) { default: - ret=BIO_callback_ctrl(b->next_bio,cmd,fp); + ret = BIO_callback_ctrl(b->next_bio, cmd, fp); break; - } - return(ret); - } - -static int nbiof_gets(BIO *bp, char *buf, int size) - { - if (bp->next_bio == NULL) return(0); - return(BIO_gets(bp->next_bio,buf,size)); - } - - -static int nbiof_puts(BIO *bp, const char *str) - { - if (bp->next_bio == NULL) return(0); - return(BIO_puts(bp->next_bio,str)); } + return (ret); +} +static int +nbiof_gets(BIO *bp, char *buf, int size) +{ + if (bp->next_bio == NULL) + return (0); + return (BIO_gets(bp->next_bio, buf, size)); +} +static int +nbiof_puts(BIO *bp, const char *str) +{ + if (bp->next_bio == NULL) + return (0); + return (BIO_puts(bp->next_bio, str)); +} diff --git a/src/lib/libssl/src/crypto/bio/bf_null.c b/src/lib/libssl/src/crypto/bio/bf_null.c index c1bf39a904..354731c0c7 100644 --- a/src/lib/libssl/src/crypto/bio/bf_null.c +++ b/src/lib/libssl/src/crypto/bio/bf_null.c @@ -72,8 +72,8 @@ static long nullf_ctrl(BIO *h, int cmd, long arg1, void *arg2); static int nullf_new(BIO *h); static int nullf_free(BIO *data); static long nullf_callback_ctrl(BIO *h, int cmd, bio_info_cb *fp); -static BIO_METHOD methods_nullf= - { + +static BIO_METHOD methods_nullf = { BIO_TYPE_NULL_FILTER, "NULL filter", nullf_write, @@ -84,100 +84,113 @@ static BIO_METHOD methods_nullf= nullf_new, nullf_free, nullf_callback_ctrl, - }; - -BIO_METHOD *BIO_f_null(void) - { - return(&methods_nullf); - } - -static int nullf_new(BIO *bi) - { - bi->init=1; - bi->ptr=NULL; - bi->flags=0; - return(1); - } - -static int nullf_free(BIO *a) - { - if (a == NULL) return(0); +}; + +BIO_METHOD +*BIO_f_null(void) +{ + return (&methods_nullf); +} + +static int +nullf_new(BIO *bi) +{ + bi->init = 1; + bi->ptr = NULL; + bi->flags = 0; + return (1); +} + +static int +nullf_free(BIO *a) +{ + if (a == NULL) + return (0); /* a->ptr=NULL; a->init=0; a->flags=0;*/ - return(1); - } - -static int nullf_read(BIO *b, char *out, int outl) - { - int ret=0; - - if (out == NULL) return(0); - if (b->next_bio == NULL) return(0); - ret=BIO_read(b->next_bio,out,outl); + return (1); +} + +static int +nullf_read(BIO *b, char *out, int outl) +{ + int ret = 0; + + if (out == NULL) + return (0); + if (b->next_bio == NULL) + return (0); + ret = BIO_read(b->next_bio, out, outl); BIO_clear_retry_flags(b); BIO_copy_next_retry(b); - return(ret); - } - -static int nullf_write(BIO *b, const char *in, int inl) - { - int ret=0; - - if ((in == NULL) || (inl <= 0)) return(0); - if (b->next_bio == NULL) return(0); - ret=BIO_write(b->next_bio,in,inl); + return (ret); +} + +static int +nullf_write(BIO *b, const char *in, int inl) +{ + int ret = 0; + + if ((in == NULL) || (inl <= 0)) + return (0); + if (b->next_bio == NULL) + return (0); + ret = BIO_write(b->next_bio, in, inl); BIO_clear_retry_flags(b); BIO_copy_next_retry(b); - return(ret); - } + return (ret); +} -static long nullf_ctrl(BIO *b, int cmd, long num, void *ptr) - { +static long +nullf_ctrl(BIO *b, int cmd, long num, void *ptr) +{ long ret; - if (b->next_bio == NULL) return(0); - switch(cmd) - { - case BIO_C_DO_STATE_MACHINE: + if (b->next_bio == NULL) + return (0); + switch (cmd) { + case BIO_C_DO_STATE_MACHINE: BIO_clear_retry_flags(b); - ret=BIO_ctrl(b->next_bio,cmd,num,ptr); + ret = BIO_ctrl(b->next_bio, cmd, num, ptr); BIO_copy_next_retry(b); break; case BIO_CTRL_DUP: - ret=0L; + ret = 0L; break; default: - ret=BIO_ctrl(b->next_bio,cmd,num,ptr); - } - return(ret); + ret = BIO_ctrl(b->next_bio, cmd, num, ptr); } + return (ret); +} -static long nullf_callback_ctrl(BIO *b, int cmd, bio_info_cb *fp) - { - long ret=1; +static long +nullf_callback_ctrl(BIO *b, int cmd, bio_info_cb *fp) +{ + long ret = 1; - if (b->next_bio == NULL) return(0); - switch (cmd) - { + if (b->next_bio == NULL) + return (0); + switch (cmd) { default: - ret=BIO_callback_ctrl(b->next_bio,cmd,fp); + ret = BIO_callback_ctrl(b->next_bio, cmd, fp); break; - } - return(ret); } - -static int nullf_gets(BIO *bp, char *buf, int size) - { - if (bp->next_bio == NULL) return(0); - return(BIO_gets(bp->next_bio,buf,size)); - } - - -static int nullf_puts(BIO *bp, const char *str) - { - if (bp->next_bio == NULL) return(0); - return(BIO_puts(bp->next_bio,str)); - } - - + return (ret); +} + +static int +nullf_gets(BIO *bp, char *buf, int size) +{ + if (bp->next_bio == NULL) + return (0); + return (BIO_gets(bp->next_bio, buf, size)); +} + +static int +nullf_puts(BIO *bp, const char *str) +{ + if (bp->next_bio == NULL) + return (0); + return (BIO_puts(bp->next_bio, str)); +} diff --git a/src/lib/libssl/src/crypto/bio/bio.h b/src/lib/libssl/src/crypto/bio/bio.h index 05699ab212..4f1d02ada5 100644 --- a/src/lib/libssl/src/crypto/bio/bio.h +++ b/src/lib/libssl/src/crypto/bio/bio.h @@ -151,7 +151,7 @@ extern "C" { #define BIO_CTRL_DGRAM_GET_RECV_TIMER_EXP 37 /* flag whether the last */ #define BIO_CTRL_DGRAM_GET_SEND_TIMER_EXP 38 /* I/O operation tiemd out */ - + /* #ifdef IP_MTU_DISCOVER */ #define BIO_CTRL_DGRAM_MTU_DISCOVER 39 /* set DF bit on egress packets */ /* #endif */ @@ -282,9 +282,10 @@ void BIO_clear_flags(BIO *b, int flags); #define BIO_cb_pre(a) (!((a)&BIO_CB_RETURN)) #define BIO_cb_post(a) ((a)&BIO_CB_RETURN) -long (*BIO_get_callback(const BIO *b)) (struct bio_st *,int,const char *,int, long,long); -void BIO_set_callback(BIO *b, - long (*callback)(struct bio_st *,int,const char *,int, long,long)); +long (*BIO_get_callback(const BIO *b))(struct bio_st *, int, const char *, + int, long, long); +void BIO_set_callback(BIO *b, + long (*callback)(struct bio_st *, int, const char *, int, long, long)); char *BIO_get_callback_arg(const BIO *b); void BIO_set_callback_arg(BIO *b, char *arg); @@ -293,8 +294,7 @@ int BIO_method_type(const BIO *b); typedef void bio_info_cb(struct bio_st *, int, const char *, int, long, long); -typedef struct bio_method_st - { +typedef struct bio_method_st { int type; const char *name; int (*bwrite)(BIO *, const char *, int); @@ -304,14 +304,13 @@ typedef struct bio_method_st long (*ctrl)(BIO *, int, long, void *); int (*create)(BIO *); int (*destroy)(BIO *); - long (*callback_ctrl)(BIO *, int, bio_info_cb *); - } BIO_METHOD; + long (*callback_ctrl)(BIO *, int, bio_info_cb *); +} BIO_METHOD; -struct bio_st - { +struct bio_st { BIO_METHOD *method; /* bio, mode, argp, argi, argl, ret */ - long (*callback)(struct bio_st *,int,const char *,int, long,long); + long (*callback)(struct bio_st *, int, const char *, int, long, long); char *cb_arg; /* first argument for the callback */ int init; @@ -327,12 +326,11 @@ struct bio_st unsigned long num_write; CRYPTO_EX_DATA ex_data; - }; +}; DECLARE_STACK_OF(BIO) -typedef struct bio_f_buffer_ctx_struct - { +typedef struct bio_f_buffer_ctx_struct { /* Buffers are setup like this: * * <---------------------- size -----------------------> @@ -346,30 +344,28 @@ typedef struct bio_f_buffer_ctx_struct int ibuf_size; /* how big is the input buffer */ int obuf_size; /* how big is the output buffer */ - char *ibuf; /* the char array */ - int ibuf_len; /* how many bytes are in it */ - int ibuf_off; /* write/read offset */ + char *ibuf; /* the char array */ + int ibuf_len; /* how many bytes are in it */ + int ibuf_off; /* write/read offset */ - char *obuf; /* the char array */ - int obuf_len; /* how many bytes are in it */ - int obuf_off; /* write/read offset */ - } BIO_F_BUFFER_CTX; + char *obuf; /* the char array */ + int obuf_len; /* how many bytes are in it */ + int obuf_off; /* write/read offset */ +} BIO_F_BUFFER_CTX; /* Prefix and suffix callback in ASN1 BIO */ typedef int asn1_ps_func(BIO *b, unsigned char **pbuf, int *plen, void *parg); #ifndef OPENSSL_NO_SCTP /* SCTP parameter structs */ -struct bio_dgram_sctp_sndinfo - { +struct bio_dgram_sctp_sndinfo { uint16_t snd_sid; uint16_t snd_flags; uint32_t snd_ppid; uint32_t snd_context; - }; +}; -struct bio_dgram_sctp_rcvinfo - { +struct bio_dgram_sctp_rcvinfo { uint16_t rcv_sid; uint16_t rcv_ssn; uint16_t rcv_flags; @@ -377,13 +373,12 @@ struct bio_dgram_sctp_rcvinfo uint32_t rcv_tsn; uint32_t rcv_cumtsn; uint32_t rcv_context; - }; +}; -struct bio_dgram_sctp_prinfo - { +struct bio_dgram_sctp_prinfo { uint16_t pr_policy; uint32_t pr_value; - }; +}; #endif /* connect BIO stuff */ @@ -519,7 +514,7 @@ struct bio_dgram_sctp_prinfo /* If you are wondering why this isn't defined, its because CONST_STRICT is * purely a compile-time kludge to allow const to be checked. */ -int BIO_read_filename(BIO *b,const char *name); +int BIO_read_filename(BIO *b, const char *name); #else #define BIO_read_filename(b,name) BIO_ctrl(b,BIO_C_SET_FILENAME, \ BIO_CLOSE|BIO_FP_READ,(char *)name) @@ -611,22 +606,27 @@ int BIO_ctrl_reset_read_request(BIO *b); /* These two aren't currently implemented */ /* int BIO_get_ex_num(BIO *bio); */ /* void BIO_set_ex_free_func(BIO *bio,int idx,void (*cb)()); */ -int BIO_set_ex_data(BIO *bio,int idx,void *data); -void *BIO_get_ex_data(BIO *bio,int idx); -int BIO_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func, - CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func); +int BIO_set_ex_data(BIO *bio, int idx, void *data); +void *BIO_get_ex_data(BIO *bio, int idx); +int +BIO_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func, +CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func); unsigned long BIO_number_read(BIO *bio); unsigned long BIO_number_written(BIO *bio); /* For BIO_f_asn1() */ -int BIO_asn1_set_prefix(BIO *b, asn1_ps_func *prefix, - asn1_ps_func *prefix_free); -int BIO_asn1_get_prefix(BIO *b, asn1_ps_func **pprefix, - asn1_ps_func **pprefix_free); -int BIO_asn1_set_suffix(BIO *b, asn1_ps_func *suffix, - asn1_ps_func *suffix_free); -int BIO_asn1_get_suffix(BIO *b, asn1_ps_func **psuffix, - asn1_ps_func **psuffix_free); +int +BIO_asn1_set_prefix(BIO *b, asn1_ps_func *prefix, +asn1_ps_func *prefix_free); +int +BIO_asn1_get_prefix(BIO *b, asn1_ps_func **pprefix, +asn1_ps_func **pprefix_free); +int +BIO_asn1_set_suffix(BIO *b, asn1_ps_func *suffix, +asn1_ps_func *suffix_free); +int +BIO_asn1_get_suffix(BIO *b, asn1_ps_func **psuffix, +asn1_ps_func **psuffix_free); # ifndef OPENSSL_NO_FP_API BIO_METHOD *BIO_s_file(void ); @@ -635,22 +635,23 @@ BIO *BIO_new_fp(FILE *stream, int close_flag); # define BIO_s_file_internal BIO_s_file # endif BIO * BIO_new(BIO_METHOD *type); -int BIO_set(BIO *a,BIO_METHOD *type); +int BIO_set(BIO *a, BIO_METHOD *type); int BIO_free(BIO *a); void BIO_vfree(BIO *a); int BIO_read(BIO *b, void *data, int len); -int BIO_gets(BIO *bp,char *buf, int size); +int BIO_gets(BIO *bp, char *buf, int size); int BIO_write(BIO *b, const void *data, int len); -int BIO_puts(BIO *bp,const char *buf); -int BIO_indent(BIO *b,int indent,int max); -long BIO_ctrl(BIO *bp,int cmd,long larg,void *parg); -long BIO_callback_ctrl(BIO *b, int cmd, void (*fp)(struct bio_st *, int, const char *, int, long, long)); -char * BIO_ptr_ctrl(BIO *bp,int cmd,long larg); -long BIO_int_ctrl(BIO *bp,int cmd,long larg,int iarg); -BIO * BIO_push(BIO *b,BIO *append); +int BIO_puts(BIO *bp, const char *buf); +int BIO_indent(BIO *b, int indent, int max); +long BIO_ctrl(BIO *bp, int cmd, long larg, void *parg); +long BIO_callback_ctrl(BIO *b, int cmd, + void (*fp)(struct bio_st *, int, const char *, int, long, long)); +char * BIO_ptr_ctrl(BIO *bp, int cmd, long larg); +long BIO_int_ctrl(BIO *bp, int cmd, long larg, int iarg); +BIO * BIO_push(BIO *b, BIO *append); BIO * BIO_pop(BIO *b); void BIO_free_all(BIO *a); -BIO * BIO_find_type(BIO *b,int bio_type); +BIO * BIO_find_type(BIO *b, int bio_type); BIO * BIO_next(BIO *b); BIO * BIO_get_retry_BIO(BIO *bio, int *reason); int BIO_get_retry_reason(BIO *bio); @@ -661,8 +662,8 @@ int BIO_nread(BIO *bio, char **buf, int num); int BIO_nwrite0(BIO *bio, char **buf); int BIO_nwrite(BIO *bio, char **buf, int num); -long BIO_debug_callback(BIO *bio,int cmd,const char *argp,int argi, - long argl,long ret); +long BIO_debug_callback(BIO *bio, int cmd, const char *argp, int argi, + long argl, long ret); BIO_METHOD *BIO_s_mem(void); BIO *BIO_new_mem_buf(void *buf, int len); @@ -696,12 +697,14 @@ int BIO_dgram_non_fatal_error(int error); int BIO_fd_should_retry(int i); int BIO_fd_non_fatal_error(int error); -int BIO_dump_cb(int (*cb)(const void *data, size_t len, void *u), - void *u, const char *s, int len); -int BIO_dump_indent_cb(int (*cb)(const void *data, size_t len, void *u), - void *u, const char *s, int len, int indent); -int BIO_dump(BIO *b,const char *bytes,int len); -int BIO_dump_indent(BIO *b,const char *bytes,int len,int indent); +int +BIO_dump_cb(int (*cb)(const void *data, size_t len, void *u), +void *u, const char *s, int len); +int +BIO_dump_indent_cb(int (*cb)(const void *data, size_t len, void *u), +void *u, const char *s, int len, int indent); +int BIO_dump(BIO *b, const char *bytes, int len); +int BIO_dump_indent(BIO *b, const char *bytes, int len, int indent); #ifndef OPENSSL_NO_FP_API int BIO_dump_fp(FILE *fp, const char *s, int len); int BIO_dump_indent_fp(FILE *fp, const char *s, int len, int indent); @@ -717,23 +720,24 @@ struct hostent *BIO_gethostbyname(const char *name); */ int BIO_sock_error(int sock); int BIO_socket_ioctl(int fd, long type, void *arg); -int BIO_socket_nbio(int fd,int mode); +int BIO_socket_nbio(int fd, int mode); int BIO_get_port(const char *str, unsigned short *port_ptr); int BIO_get_host_ip(const char *str, unsigned char *ip); -int BIO_get_accept_socket(char *host_port,int mode); -int BIO_accept(int sock,char **ip_port); +int BIO_get_accept_socket(char *host_port, int mode); +int BIO_accept(int sock, char **ip_port); int BIO_sock_init(void ); void BIO_sock_cleanup(void); -int BIO_set_tcp_ndelay(int sock,int turn_on); +int BIO_set_tcp_ndelay(int sock, int turn_on); BIO *BIO_new_socket(int sock, int close_flag); BIO *BIO_new_dgram(int fd, int close_flag); #ifndef OPENSSL_NO_SCTP BIO *BIO_new_dgram_sctp(int fd, int close_flag); int BIO_dgram_is_sctp(BIO *bio); -int BIO_dgram_sctp_notification_cb(BIO *b, - void (*handle_notifications)(BIO *bio, void *context, void *buf), - void *context); +int +BIO_dgram_sctp_notification_cb(BIO *b, + void (*handle_notifications)(BIO *bio, void *context, void *buf), +void *context); int BIO_dgram_sctp_wait_for_dry(BIO *b); int BIO_dgram_sctp_msg_waiting(BIO *b); #endif @@ -741,8 +745,9 @@ BIO *BIO_new_fd(int fd, int close_flag); BIO *BIO_new_connect(char *host_port); BIO *BIO_new_accept(char *host_port); -int BIO_new_bio_pair(BIO **bio1, size_t writebuf1, - BIO **bio2, size_t writebuf2); +int +BIO_new_bio_pair(BIO **bio1, size_t writebuf1, +BIO **bio2, size_t writebuf2); /* If successful, returns 1 and in *bio1, *bio2 two BIO pair endpoints. * Otherwise returns 0 and sets *bio1 and *bio2 to NULL. * Size 0 uses default value. @@ -757,14 +762,18 @@ void BIO_copy_next_retry(BIO *b); #else # define __bio_h__attr__(x) #endif -int BIO_printf(BIO *bio, const char *format, ...) - __bio_h__attr__((__format__(__printf__,2,3))); -int BIO_vprintf(BIO *bio, const char *format, va_list args) - __bio_h__attr__((__format__(__printf__,2,0))); -int BIO_snprintf(char *buf, size_t n, const char *format, ...) - __bio_h__attr__((__format__(__printf__,3,4))); -int BIO_vsnprintf(char *buf, size_t n, const char *format, va_list args) - __bio_h__attr__((__format__(__printf__,3,0))); +int +BIO_printf(BIO *bio, const char *format, ...) +__bio_h__attr__((__format__(__printf__, 2, 3))); +int +BIO_vprintf(BIO *bio, const char *format, va_list args) +__bio_h__attr__((__format__(__printf__, 2, 0))); +int +BIO_snprintf(char *buf, size_t n, const char *format, ...) +__bio_h__attr__((__format__(__printf__, 3, 4))); +int +BIO_vsnprintf(char *buf, size_t n, const char *format, va_list args) +__bio_h__attr__((__format__(__printf__, 3, 0))); #undef __bio_h__attr__ /* BEGIN ERROR CODES */ diff --git a/src/lib/libssl/src/crypto/bio/bio_cb.c b/src/lib/libssl/src/crypto/bio/bio_cb.c index 78c8974ab4..3e110f3751 100644 --- a/src/lib/libssl/src/crypto/bio/bio_cb.c +++ b/src/lib/libssl/src/crypto/bio/bio_cb.c @@ -63,81 +63,85 @@ #include #include -long BIO_debug_callback(BIO *bio, int cmd, const char *argp, - int argi, long argl, long ret) - { +long +BIO_debug_callback(BIO *bio, int cmd, const char *argp, int argi, long argl, + long ret) +{ BIO *b; char buf[256]; char *p; - long r=1; + long r = 1; size_t p_maxlen; if (BIO_CB_RETURN & cmd) - r=ret; + r = ret; - (void) snprintf(buf,sizeof buf,"BIO[%08lX]:",(unsigned long)bio); - p= &(buf[14]); + (void) snprintf(buf, sizeof buf, "BIO[%08lX]:", (unsigned long)bio); + p = &(buf[14]); p_maxlen = sizeof buf - 14; - switch (cmd) - { + switch (cmd) { case BIO_CB_FREE: - (void) snprintf(p,p_maxlen,"Free - %s\n",bio->method->name); + (void) snprintf(p, p_maxlen, "Free - %s\n", bio->method->name); break; case BIO_CB_READ: if (bio->method->type & BIO_TYPE_DESCRIPTOR) - (void) snprintf(p,p_maxlen,"read(%d,%lu) - %s fd=%d\n", - bio->num,(unsigned long)argi, - bio->method->name,bio->num); + (void) snprintf(p, p_maxlen, + "read(%d,%lu) - %s fd=%d\n", + bio->num,(unsigned long)argi, + bio->method->name, bio->num); else - (void) snprintf(p,p_maxlen,"read(%d,%lu) - %s\n", - bio->num,(unsigned long)argi, - bio->method->name); + (void) snprintf(p, p_maxlen, "read(%d,%lu) - %s\n", + bio->num, (unsigned long)argi, bio->method->name); break; case BIO_CB_WRITE: if (bio->method->type & BIO_TYPE_DESCRIPTOR) - (void) snprintf(p,p_maxlen,"write(%d,%lu) - %s fd=%d\n", - bio->num,(unsigned long)argi, - bio->method->name,bio->num); + (void) snprintf(p, p_maxlen, + "write(%d,%lu) - %s fd=%d\n", + bio->num, (unsigned long)argi, + bio->method->name, bio->num); else - (void) snprintf(p,p_maxlen,"write(%d,%lu) - %s\n", - bio->num,(unsigned long)argi, - bio->method->name); + (void) snprintf(p, p_maxlen, "write(%d,%lu) - %s\n", + bio->num, (unsigned long)argi, bio->method->name); break; case BIO_CB_PUTS: - (void) snprintf(p,p_maxlen,"puts() - %s\n",bio->method->name); + (void) snprintf(p, p_maxlen, + "puts() - %s\n", bio->method->name); break; case BIO_CB_GETS: - (void) snprintf(p,p_maxlen,"gets(%lu) - %s\n",(unsigned long)argi,bio->method->name); + (void) snprintf(p, p_maxlen, "gets(%lu) - %s\n", + (unsigned long)argi, bio->method->name); break; case BIO_CB_CTRL: - (void) snprintf(p,p_maxlen,"ctrl(%lu) - %s\n",(unsigned long)argi,bio->method->name); + (void) snprintf(p, p_maxlen, "ctrl(%lu) - %s\n", + (unsigned long)argi, bio->method->name); break; case BIO_CB_RETURN|BIO_CB_READ: - (void) snprintf(p,p_maxlen,"read return %ld\n",ret); + (void) snprintf(p, p_maxlen, "read return %ld\n", ret); break; case BIO_CB_RETURN|BIO_CB_WRITE: - (void) snprintf(p,p_maxlen,"write return %ld\n",ret); + (void) snprintf(p, p_maxlen, "write return %ld\n", ret); break; case BIO_CB_RETURN|BIO_CB_GETS: - (void) snprintf(p,p_maxlen,"gets return %ld\n",ret); + (void) snprintf(p, p_maxlen, "gets return %ld\n", ret); break; case BIO_CB_RETURN|BIO_CB_PUTS: - (void) snprintf(p,p_maxlen,"puts return %ld\n",ret); + (void) snprintf(p, p_maxlen, "puts return %ld\n", ret); break; case BIO_CB_RETURN|BIO_CB_CTRL: - (void) snprintf(p,p_maxlen,"ctrl return %ld\n",ret); + (void) snprintf(p, p_maxlen, "ctrl return %ld\n", ret); break; default: - (void) snprintf(p,p_maxlen,"bio callback - unknown type (%d)\n",cmd); + (void) snprintf(p, p_maxlen, + "bio callback - unknown type (%d)\n", cmd); break; - } + } - b=(BIO *)bio->cb_arg; + b = (BIO *)bio->cb_arg; if (b != NULL) - BIO_write(b,buf,strlen(buf)); + BIO_write(b, buf, strlen(buf)); #if !defined(OPENSSL_NO_STDIO) && !defined(OPENSSL_SYS_WIN16) else - fputs(buf,stderr); + fputs(buf, stderr); #endif - return(r); - } + return (r); +} diff --git a/src/lib/libssl/src/crypto/bio/bio_err.c b/src/lib/libssl/src/crypto/bio/bio_err.c index 0dbfbd80d3..86e9a3082b 100644 --- a/src/lib/libssl/src/crypto/bio/bio_err.c +++ b/src/lib/libssl/src/crypto/bio/bio_err.c @@ -68,88 +68,85 @@ #define ERR_FUNC(func) ERR_PACK(ERR_LIB_BIO,func,0) #define ERR_REASON(reason) ERR_PACK(ERR_LIB_BIO,0,reason) -static ERR_STRING_DATA BIO_str_functs[]= - { -{ERR_FUNC(BIO_F_ACPT_STATE), "ACPT_STATE"}, -{ERR_FUNC(BIO_F_BIO_ACCEPT), "BIO_accept"}, -{ERR_FUNC(BIO_F_BIO_BER_GET_HEADER), "BIO_BER_GET_HEADER"}, -{ERR_FUNC(BIO_F_BIO_CALLBACK_CTRL), "BIO_callback_ctrl"}, -{ERR_FUNC(BIO_F_BIO_CTRL), "BIO_ctrl"}, -{ERR_FUNC(BIO_F_BIO_GETHOSTBYNAME), "BIO_gethostbyname"}, -{ERR_FUNC(BIO_F_BIO_GETS), "BIO_gets"}, -{ERR_FUNC(BIO_F_BIO_GET_ACCEPT_SOCKET), "BIO_get_accept_socket"}, -{ERR_FUNC(BIO_F_BIO_GET_HOST_IP), "BIO_get_host_ip"}, -{ERR_FUNC(BIO_F_BIO_GET_PORT), "BIO_get_port"}, -{ERR_FUNC(BIO_F_BIO_MAKE_PAIR), "BIO_MAKE_PAIR"}, -{ERR_FUNC(BIO_F_BIO_NEW), "BIO_new"}, -{ERR_FUNC(BIO_F_BIO_NEW_FILE), "BIO_new_file"}, -{ERR_FUNC(BIO_F_BIO_NEW_MEM_BUF), "BIO_new_mem_buf"}, -{ERR_FUNC(BIO_F_BIO_NREAD), "BIO_nread"}, -{ERR_FUNC(BIO_F_BIO_NREAD0), "BIO_nread0"}, -{ERR_FUNC(BIO_F_BIO_NWRITE), "BIO_nwrite"}, -{ERR_FUNC(BIO_F_BIO_NWRITE0), "BIO_nwrite0"}, -{ERR_FUNC(BIO_F_BIO_PUTS), "BIO_puts"}, -{ERR_FUNC(BIO_F_BIO_READ), "BIO_read"}, -{ERR_FUNC(BIO_F_BIO_SOCK_INIT), "BIO_sock_init"}, -{ERR_FUNC(BIO_F_BIO_WRITE), "BIO_write"}, -{ERR_FUNC(BIO_F_BUFFER_CTRL), "BUFFER_CTRL"}, -{ERR_FUNC(BIO_F_CONN_CTRL), "CONN_CTRL"}, -{ERR_FUNC(BIO_F_CONN_STATE), "CONN_STATE"}, -{ERR_FUNC(BIO_F_DGRAM_SCTP_READ), "DGRAM_SCTP_READ"}, -{ERR_FUNC(BIO_F_FILE_CTRL), "FILE_CTRL"}, -{ERR_FUNC(BIO_F_FILE_READ), "FILE_READ"}, -{ERR_FUNC(BIO_F_LINEBUFFER_CTRL), "LINEBUFFER_CTRL"}, -{ERR_FUNC(BIO_F_MEM_READ), "MEM_READ"}, -{ERR_FUNC(BIO_F_MEM_WRITE), "MEM_WRITE"}, -{ERR_FUNC(BIO_F_SSL_NEW), "SSL_new"}, -{ERR_FUNC(BIO_F_WSASTARTUP), "WSASTARTUP"}, -{0,NULL} - }; +static ERR_STRING_DATA BIO_str_functs[]= { + {ERR_FUNC(BIO_F_ACPT_STATE), "ACPT_STATE"}, + {ERR_FUNC(BIO_F_BIO_ACCEPT), "BIO_accept"}, + {ERR_FUNC(BIO_F_BIO_BER_GET_HEADER), "BIO_BER_GET_HEADER"}, + {ERR_FUNC(BIO_F_BIO_CALLBACK_CTRL), "BIO_callback_ctrl"}, + {ERR_FUNC(BIO_F_BIO_CTRL), "BIO_ctrl"}, + {ERR_FUNC(BIO_F_BIO_GETHOSTBYNAME), "BIO_gethostbyname"}, + {ERR_FUNC(BIO_F_BIO_GETS), "BIO_gets"}, + {ERR_FUNC(BIO_F_BIO_GET_ACCEPT_SOCKET), "BIO_get_accept_socket"}, + {ERR_FUNC(BIO_F_BIO_GET_HOST_IP), "BIO_get_host_ip"}, + {ERR_FUNC(BIO_F_BIO_GET_PORT), "BIO_get_port"}, + {ERR_FUNC(BIO_F_BIO_MAKE_PAIR), "BIO_MAKE_PAIR"}, + {ERR_FUNC(BIO_F_BIO_NEW), "BIO_new"}, + {ERR_FUNC(BIO_F_BIO_NEW_FILE), "BIO_new_file"}, + {ERR_FUNC(BIO_F_BIO_NEW_MEM_BUF), "BIO_new_mem_buf"}, + {ERR_FUNC(BIO_F_BIO_NREAD), "BIO_nread"}, + {ERR_FUNC(BIO_F_BIO_NREAD0), "BIO_nread0"}, + {ERR_FUNC(BIO_F_BIO_NWRITE), "BIO_nwrite"}, + {ERR_FUNC(BIO_F_BIO_NWRITE0), "BIO_nwrite0"}, + {ERR_FUNC(BIO_F_BIO_PUTS), "BIO_puts"}, + {ERR_FUNC(BIO_F_BIO_READ), "BIO_read"}, + {ERR_FUNC(BIO_F_BIO_SOCK_INIT), "BIO_sock_init"}, + {ERR_FUNC(BIO_F_BIO_WRITE), "BIO_write"}, + {ERR_FUNC(BIO_F_BUFFER_CTRL), "BUFFER_CTRL"}, + {ERR_FUNC(BIO_F_CONN_CTRL), "CONN_CTRL"}, + {ERR_FUNC(BIO_F_CONN_STATE), "CONN_STATE"}, + {ERR_FUNC(BIO_F_DGRAM_SCTP_READ), "DGRAM_SCTP_READ"}, + {ERR_FUNC(BIO_F_FILE_CTRL), "FILE_CTRL"}, + {ERR_FUNC(BIO_F_FILE_READ), "FILE_READ"}, + {ERR_FUNC(BIO_F_LINEBUFFER_CTRL), "LINEBUFFER_CTRL"}, + {ERR_FUNC(BIO_F_MEM_READ), "MEM_READ"}, + {ERR_FUNC(BIO_F_MEM_WRITE), "MEM_WRITE"}, + {ERR_FUNC(BIO_F_SSL_NEW), "SSL_new"}, + {ERR_FUNC(BIO_F_WSASTARTUP), "WSASTARTUP"}, + {0, NULL} +}; -static ERR_STRING_DATA BIO_str_reasons[]= - { -{ERR_REASON(BIO_R_ACCEPT_ERROR) ,"accept error"}, -{ERR_REASON(BIO_R_BAD_FOPEN_MODE) ,"bad fopen mode"}, -{ERR_REASON(BIO_R_BAD_HOSTNAME_LOOKUP) ,"bad hostname lookup"}, -{ERR_REASON(BIO_R_BROKEN_PIPE) ,"broken pipe"}, -{ERR_REASON(BIO_R_CONNECT_ERROR) ,"connect error"}, -{ERR_REASON(BIO_R_EOF_ON_MEMORY_BIO) ,"EOF on memory BIO"}, -{ERR_REASON(BIO_R_ERROR_SETTING_NBIO) ,"error setting nbio"}, -{ERR_REASON(BIO_R_ERROR_SETTING_NBIO_ON_ACCEPTED_SOCKET),"error setting nbio on accepted socket"}, -{ERR_REASON(BIO_R_ERROR_SETTING_NBIO_ON_ACCEPT_SOCKET),"error setting nbio on accept socket"}, -{ERR_REASON(BIO_R_GETHOSTBYNAME_ADDR_IS_NOT_AF_INET),"gethostbyname addr is not af inet"}, -{ERR_REASON(BIO_R_INVALID_ARGUMENT) ,"invalid argument"}, -{ERR_REASON(BIO_R_INVALID_IP_ADDRESS) ,"invalid ip address"}, -{ERR_REASON(BIO_R_IN_USE) ,"in use"}, -{ERR_REASON(BIO_R_KEEPALIVE) ,"keepalive"}, -{ERR_REASON(BIO_R_NBIO_CONNECT_ERROR) ,"nbio connect error"}, -{ERR_REASON(BIO_R_NO_ACCEPT_PORT_SPECIFIED),"no accept port specified"}, -{ERR_REASON(BIO_R_NO_HOSTNAME_SPECIFIED) ,"no hostname specified"}, -{ERR_REASON(BIO_R_NO_PORT_DEFINED) ,"no port defined"}, -{ERR_REASON(BIO_R_NO_PORT_SPECIFIED) ,"no port specified"}, -{ERR_REASON(BIO_R_NO_SUCH_FILE) ,"no such file"}, -{ERR_REASON(BIO_R_NULL_PARAMETER) ,"null parameter"}, -{ERR_REASON(BIO_R_TAG_MISMATCH) ,"tag mismatch"}, -{ERR_REASON(BIO_R_UNABLE_TO_BIND_SOCKET) ,"unable to bind socket"}, -{ERR_REASON(BIO_R_UNABLE_TO_CREATE_SOCKET),"unable to create socket"}, -{ERR_REASON(BIO_R_UNABLE_TO_LISTEN_SOCKET),"unable to listen socket"}, -{ERR_REASON(BIO_R_UNINITIALIZED) ,"uninitialized"}, -{ERR_REASON(BIO_R_UNSUPPORTED_METHOD) ,"unsupported method"}, -{ERR_REASON(BIO_R_WRITE_TO_READ_ONLY_BIO),"write to read only BIO"}, -{ERR_REASON(BIO_R_WSASTARTUP) ,"WSAStartup"}, -{0,NULL} - }; +static ERR_STRING_DATA BIO_str_reasons[]= { + {ERR_REASON(BIO_R_ACCEPT_ERROR) , "accept error"}, + {ERR_REASON(BIO_R_BAD_FOPEN_MODE) , "bad fopen mode"}, + {ERR_REASON(BIO_R_BAD_HOSTNAME_LOOKUP) , "bad hostname lookup"}, + {ERR_REASON(BIO_R_BROKEN_PIPE) , "broken pipe"}, + {ERR_REASON(BIO_R_CONNECT_ERROR) , "connect error"}, + {ERR_REASON(BIO_R_EOF_ON_MEMORY_BIO) , "EOF on memory BIO"}, + {ERR_REASON(BIO_R_ERROR_SETTING_NBIO) , "error setting nbio"}, + {ERR_REASON(BIO_R_ERROR_SETTING_NBIO_ON_ACCEPTED_SOCKET), "error setting nbio on accepted socket"}, + {ERR_REASON(BIO_R_ERROR_SETTING_NBIO_ON_ACCEPT_SOCKET), "error setting nbio on accept socket"}, + {ERR_REASON(BIO_R_GETHOSTBYNAME_ADDR_IS_NOT_AF_INET), "gethostbyname addr is not af inet"}, + {ERR_REASON(BIO_R_INVALID_ARGUMENT) , "invalid argument"}, + {ERR_REASON(BIO_R_INVALID_IP_ADDRESS) , "invalid ip address"}, + {ERR_REASON(BIO_R_IN_USE) , "in use"}, + {ERR_REASON(BIO_R_KEEPALIVE) , "keepalive"}, + {ERR_REASON(BIO_R_NBIO_CONNECT_ERROR) , "nbio connect error"}, + {ERR_REASON(BIO_R_NO_ACCEPT_PORT_SPECIFIED), "no accept port specified"}, + {ERR_REASON(BIO_R_NO_HOSTNAME_SPECIFIED) , "no hostname specified"}, + {ERR_REASON(BIO_R_NO_PORT_DEFINED) , "no port defined"}, + {ERR_REASON(BIO_R_NO_PORT_SPECIFIED) , "no port specified"}, + {ERR_REASON(BIO_R_NO_SUCH_FILE) , "no such file"}, + {ERR_REASON(BIO_R_NULL_PARAMETER) , "null parameter"}, + {ERR_REASON(BIO_R_TAG_MISMATCH) , "tag mismatch"}, + {ERR_REASON(BIO_R_UNABLE_TO_BIND_SOCKET) , "unable to bind socket"}, + {ERR_REASON(BIO_R_UNABLE_TO_CREATE_SOCKET), "unable to create socket"}, + {ERR_REASON(BIO_R_UNABLE_TO_LISTEN_SOCKET), "unable to listen socket"}, + {ERR_REASON(BIO_R_UNINITIALIZED) , "uninitialized"}, + {ERR_REASON(BIO_R_UNSUPPORTED_METHOD) , "unsupported method"}, + {ERR_REASON(BIO_R_WRITE_TO_READ_ONLY_BIO), "write to read only BIO"}, + {ERR_REASON(BIO_R_WSASTARTUP) , "WSAStartup"}, + {0, NULL} +}; #endif -void ERR_load_BIO_strings(void) - { +void +ERR_load_BIO_strings(void) +{ #ifndef OPENSSL_NO_ERR - - if (ERR_func_error_string(BIO_str_functs[0].error) == NULL) - { - ERR_load_strings(0,BIO_str_functs); - ERR_load_strings(0,BIO_str_reasons); - } -#endif + if (ERR_func_error_string(BIO_str_functs[0].error) == NULL) { + ERR_load_strings(0, BIO_str_functs); + ERR_load_strings(0, BIO_str_reasons); } +#endif +} diff --git a/src/lib/libssl/src/crypto/bio/bio_lib.c b/src/lib/libssl/src/crypto/bio/bio_lib.c index 9c9646afa8..9e8fb7913a 100644 --- a/src/lib/libssl/src/crypto/bio/bio_lib.c +++ b/src/lib/libssl/src/crypto/bio/bio_lib.c @@ -63,539 +63,571 @@ #include #include -BIO *BIO_new(BIO_METHOD *method) - { - BIO *ret=NULL; - - ret=(BIO *)OPENSSL_malloc(sizeof(BIO)); - if (ret == NULL) - { - BIOerr(BIO_F_BIO_NEW,ERR_R_MALLOC_FAILURE); - return(NULL); - } - if (!BIO_set(ret,method)) - { +BIO +*BIO_new(BIO_METHOD *method) +{ + BIO *ret = NULL; + + ret = (BIO *)OPENSSL_malloc(sizeof(BIO)); + if (ret == NULL) { + BIOerr(BIO_F_BIO_NEW, ERR_R_MALLOC_FAILURE); + return (NULL); + } + if (!BIO_set(ret, method)) { OPENSSL_free(ret); - ret=NULL; - } - return(ret); + ret = NULL; } + return (ret); +} -int BIO_set(BIO *bio, BIO_METHOD *method) - { - bio->method=method; - bio->callback=NULL; - bio->cb_arg=NULL; - bio->init=0; - bio->shutdown=1; - bio->flags=0; - bio->retry_reason=0; - bio->num=0; - bio->ptr=NULL; - bio->prev_bio=NULL; - bio->next_bio=NULL; - bio->references=1; - bio->num_read=0L; - bio->num_write=0L; +int +BIO_set(BIO *bio, BIO_METHOD *method) +{ + bio->method = method; + bio->callback = NULL; + bio->cb_arg = NULL; + bio->init = 0; + bio->shutdown = 1; + bio->flags = 0; + bio->retry_reason = 0; + bio->num = 0; + bio->ptr = NULL; + bio->prev_bio = NULL; + bio->next_bio = NULL; + bio->references = 1; + bio->num_read = 0L; + bio->num_write = 0L; CRYPTO_new_ex_data(CRYPTO_EX_INDEX_BIO, bio, &bio->ex_data); if (method->create != NULL) - if (!method->create(bio)) - { + if (!method->create(bio)) { CRYPTO_free_ex_data(CRYPTO_EX_INDEX_BIO, bio, - &bio->ex_data); - return(0); - } - return(1); - } + &bio->ex_data); + return (0); + } + return (1); +} -int BIO_free(BIO *a) - { +int +BIO_free(BIO *a) +{ int i; - if (a == NULL) return(0); + if (a == NULL) + return (0); - i=CRYPTO_add(&a->references,-1,CRYPTO_LOCK_BIO); + i = CRYPTO_add(&a->references, -1, CRYPTO_LOCK_BIO); #ifdef REF_PRINT - REF_PRINT("BIO",a); + REF_PRINT("BIO", a); #endif - if (i > 0) return(1); + if (i > 0) + return (1); #ifdef REF_CHECK - if (i < 0) - { - fprintf(stderr,"BIO_free, bad reference count\n"); + if (i < 0) { + fprintf(stderr, "BIO_free, bad reference count\n"); abort(); - } + } #endif if ((a->callback != NULL) && - ((i=(int)a->callback(a,BIO_CB_FREE,NULL,0,0L,1L)) <= 0)) - return(i); + ((i = (int)a->callback(a, BIO_CB_FREE, NULL, 0, 0L, 1L)) <= 0)) + return (i); CRYPTO_free_ex_data(CRYPTO_EX_INDEX_BIO, a, &a->ex_data); - if ((a->method == NULL) || (a->method->destroy == NULL)) return(1); + if ((a->method == NULL) || (a->method->destroy == NULL)) + return (1); a->method->destroy(a); OPENSSL_free(a); - return(1); - } + return (1); +} -void BIO_vfree(BIO *a) - { BIO_free(a); } +void +BIO_vfree(BIO *a) +{ + BIO_free(a); +} -void BIO_clear_flags(BIO *b, int flags) - { +void +BIO_clear_flags(BIO *b, int flags) +{ b->flags &= ~flags; - } +} -int BIO_test_flags(const BIO *b, int flags) - { +int +BIO_test_flags(const BIO *b, int flags) +{ return (b->flags & flags); - } +} -void BIO_set_flags(BIO *b, int flags) - { +void +BIO_set_flags(BIO *b, int flags) +{ b->flags |= flags; - } +} -long (*BIO_get_callback(const BIO *b))(struct bio_st *,int,const char *,int, long,long) - { +long +(*BIO_get_callback(const BIO *b))(struct bio_st *, int, const char *, int, + long, long) +{ return b->callback; - } +} -void BIO_set_callback(BIO *b, long (*cb)(struct bio_st *,int,const char *,int, long,long)) - { +void +BIO_set_callback(BIO *b, long (*cb)(struct bio_st *, int, const char *, int, + long, long)) +{ b->callback = cb; - } +} -void BIO_set_callback_arg(BIO *b, char *arg) - { +void +BIO_set_callback_arg(BIO *b, char *arg) +{ b->cb_arg = arg; - } +} -char * BIO_get_callback_arg(const BIO *b) - { +char * +BIO_get_callback_arg(const BIO *b) +{ return b->cb_arg; - } +} -const char * BIO_method_name(const BIO *b) - { +const char * +BIO_method_name(const BIO *b) +{ return b->method->name; - } +} -int BIO_method_type(const BIO *b) - { +int +BIO_method_type(const BIO *b) +{ return b->method->type; - } - +} -int BIO_read(BIO *b, void *out, int outl) - { +int +BIO_read(BIO *b, void *out, int outl) +{ int i; - long (*cb)(BIO *,int,const char *,int,long,long); + long (*cb)(BIO *, int, const char *, int, long, long); - if ((b == NULL) || (b->method == NULL) || (b->method->bread == NULL)) - { - BIOerr(BIO_F_BIO_READ,BIO_R_UNSUPPORTED_METHOD); - return(-2); - } + if ((b == NULL) || (b->method == NULL) || (b->method->bread == NULL)) { + BIOerr(BIO_F_BIO_READ, BIO_R_UNSUPPORTED_METHOD); + return (-2); + } - cb=b->callback; + cb = b->callback; if ((cb != NULL) && - ((i=(int)cb(b,BIO_CB_READ,out,outl,0L,1L)) <= 0)) - return(i); + ((i = (int)cb(b, BIO_CB_READ, out, outl, 0L, 1L)) <= 0)) + return (i); - if (!b->init) - { - BIOerr(BIO_F_BIO_READ,BIO_R_UNINITIALIZED); - return(-2); - } + if (!b->init) { + BIOerr(BIO_F_BIO_READ, BIO_R_UNINITIALIZED); + return (-2); + } - i=b->method->bread(b,out,outl); + i = b->method->bread(b, out, outl); - if (i > 0) b->num_read+=(unsigned long)i; + if (i > 0) + b->num_read += (unsigned long)i; if (cb != NULL) - i=(int)cb(b,BIO_CB_READ|BIO_CB_RETURN,out,outl, - 0L,(long)i); - return(i); - } + i = (int)cb(b, BIO_CB_READ|BIO_CB_RETURN, out, outl, + 0L, (long)i); + return (i); +} -int BIO_write(BIO *b, const void *in, int inl) - { +int +BIO_write(BIO *b, const void *in, int inl) +{ int i; - long (*cb)(BIO *,int,const char *,int,long,long); + long (*cb)(BIO *, int, const char *, int, long, long); if (b == NULL) - return(0); + return (0); - cb=b->callback; - if ((b->method == NULL) || (b->method->bwrite == NULL)) - { - BIOerr(BIO_F_BIO_WRITE,BIO_R_UNSUPPORTED_METHOD); - return(-2); - } + cb = b->callback; + if ((b->method == NULL) || (b->method->bwrite == NULL)) { + BIOerr(BIO_F_BIO_WRITE, BIO_R_UNSUPPORTED_METHOD); + return (-2); + } if ((cb != NULL) && - ((i=(int)cb(b,BIO_CB_WRITE,in,inl,0L,1L)) <= 0)) - return(i); + ((i = (int)cb(b, BIO_CB_WRITE, in, inl, 0L, 1L)) <= 0)) + return (i); - if (!b->init) - { - BIOerr(BIO_F_BIO_WRITE,BIO_R_UNINITIALIZED); - return(-2); - } + if (!b->init) { + BIOerr(BIO_F_BIO_WRITE, BIO_R_UNINITIALIZED); + return (-2); + } - i=b->method->bwrite(b,in,inl); + i = b->method->bwrite(b, in, inl); - if (i > 0) b->num_write+=(unsigned long)i; + if (i > 0) + b->num_write += (unsigned long)i; if (cb != NULL) - i=(int)cb(b,BIO_CB_WRITE|BIO_CB_RETURN,in,inl, - 0L,(long)i); - return(i); - } + i = (int)cb(b, BIO_CB_WRITE|BIO_CB_RETURN, in, inl, + 0L, (long)i); + return (i); +} -int BIO_puts(BIO *b, const char *in) - { +int +BIO_puts(BIO *b, const char *in) +{ int i; - long (*cb)(BIO *,int,const char *,int,long,long); + long (*cb)(BIO *, int, const char *, int, long, long); - if ((b == NULL) || (b->method == NULL) || (b->method->bputs == NULL)) - { - BIOerr(BIO_F_BIO_PUTS,BIO_R_UNSUPPORTED_METHOD); - return(-2); - } + if ((b == NULL) || (b->method == NULL) || (b->method->bputs == NULL)) { + BIOerr(BIO_F_BIO_PUTS, BIO_R_UNSUPPORTED_METHOD); + return (-2); + } - cb=b->callback; + cb = b->callback; if ((cb != NULL) && - ((i=(int)cb(b,BIO_CB_PUTS,in,0,0L,1L)) <= 0)) - return(i); + ((i = (int)cb(b, BIO_CB_PUTS, in, 0, 0L, 1L)) <= 0)) + return (i); - if (!b->init) - { - BIOerr(BIO_F_BIO_PUTS,BIO_R_UNINITIALIZED); - return(-2); - } + if (!b->init) { + BIOerr(BIO_F_BIO_PUTS, BIO_R_UNINITIALIZED); + return (-2); + } - i=b->method->bputs(b,in); + i = b->method->bputs(b, in); - if (i > 0) b->num_write+=(unsigned long)i; + if (i > 0) + b->num_write += (unsigned long)i; if (cb != NULL) - i=(int)cb(b,BIO_CB_PUTS|BIO_CB_RETURN,in,0, - 0L,(long)i); - return(i); - } + i = (int)cb(b, BIO_CB_PUTS|BIO_CB_RETURN, in, 0, 0L, (long)i); + return (i); +} -int BIO_gets(BIO *b, char *in, int inl) - { +int +BIO_gets(BIO *b, char *in, int inl) +{ int i; - long (*cb)(BIO *,int,const char *,int,long,long); + long (*cb)(BIO *, int, const char *, int, long, long); - if ((b == NULL) || (b->method == NULL) || (b->method->bgets == NULL)) - { - BIOerr(BIO_F_BIO_GETS,BIO_R_UNSUPPORTED_METHOD); - return(-2); - } + if ((b == NULL) || (b->method == NULL) || (b->method->bgets == NULL)) { + BIOerr(BIO_F_BIO_GETS, BIO_R_UNSUPPORTED_METHOD); + return (-2); + } - cb=b->callback; + cb = b->callback; if ((cb != NULL) && - ((i=(int)cb(b,BIO_CB_GETS,in,inl,0L,1L)) <= 0)) - return(i); + ((i = (int)cb(b, BIO_CB_GETS, in, inl, 0L, 1L)) <= 0)) + return (i); - if (!b->init) - { - BIOerr(BIO_F_BIO_GETS,BIO_R_UNINITIALIZED); - return(-2); - } + if (!b->init) { + BIOerr(BIO_F_BIO_GETS, BIO_R_UNINITIALIZED); + return (-2); + } - i=b->method->bgets(b,in,inl); + i = b->method->bgets(b, in, inl); if (cb != NULL) - i=(int)cb(b,BIO_CB_GETS|BIO_CB_RETURN,in,inl, - 0L,(long)i); - return(i); - } + i = (int)cb(b, BIO_CB_GETS|BIO_CB_RETURN, in, inl, 0L, (long)i); + return (i); +} -int BIO_indent(BIO *b,int indent,int max) - { - if(indent < 0) - indent=0; - if(indent > max) - indent=max; - while(indent--) - if(BIO_puts(b," ") != 1) - return 0; +int +BIO_indent(BIO *b, int indent, int max) +{ + if (indent < 0) + indent = 0; + if (indent > max) + indent = max; + while (indent--) + if (BIO_puts(b, " ") != 1) + return 0; return 1; - } +} -long BIO_int_ctrl(BIO *b, int cmd, long larg, int iarg) - { +long +BIO_int_ctrl(BIO *b, int cmd, long larg, int iarg) +{ int i; - i=iarg; - return(BIO_ctrl(b,cmd,larg,(char *)&i)); - } + i = iarg; + return (BIO_ctrl(b, cmd, larg,(char *)&i)); +} -char *BIO_ptr_ctrl(BIO *b, int cmd, long larg) - { - char *p=NULL; +char +*BIO_ptr_ctrl(BIO *b, int cmd, long larg) +{ + char *p = NULL; - if (BIO_ctrl(b,cmd,larg,(char *)&p) <= 0) - return(NULL); + if (BIO_ctrl(b, cmd, larg,(char *)&p) <= 0) + return (NULL); else - return(p); - } + return (p); +} -long BIO_ctrl(BIO *b, int cmd, long larg, void *parg) - { +long +BIO_ctrl(BIO *b, int cmd, long larg, void *parg) +{ long ret; - long (*cb)(BIO *,int,const char *,int,long,long); + long (*cb)(BIO *, int, const char *, int, long, long); - if (b == NULL) return(0); + if (b == NULL) + return (0); - if ((b->method == NULL) || (b->method->ctrl == NULL)) - { - BIOerr(BIO_F_BIO_CTRL,BIO_R_UNSUPPORTED_METHOD); - return(-2); - } + if ((b->method == NULL) || (b->method->ctrl == NULL)) { + BIOerr(BIO_F_BIO_CTRL, BIO_R_UNSUPPORTED_METHOD); + return (-2); + } - cb=b->callback; + cb = b->callback; if ((cb != NULL) && - ((ret=cb(b,BIO_CB_CTRL,parg,cmd,larg,1L)) <= 0)) - return(ret); + ((ret = cb(b, BIO_CB_CTRL, parg, cmd, larg, 1L)) <= 0)) + return (ret); - ret=b->method->ctrl(b,cmd,larg,parg); + ret = b->method->ctrl(b, cmd, larg, parg); if (cb != NULL) - ret=cb(b,BIO_CB_CTRL|BIO_CB_RETURN,parg,cmd, - larg,ret); - return(ret); - } + ret = cb(b, BIO_CB_CTRL|BIO_CB_RETURN, parg, cmd, larg, ret); + return (ret); +} -long BIO_callback_ctrl(BIO *b, int cmd, void (*fp)(struct bio_st *, int, const char *, int, long, long)) - { +long +BIO_callback_ctrl(BIO *b, int cmd, + void (*fp)(struct bio_st *, int, const char *, int, long, long)) +{ long ret; - long (*cb)(BIO *,int,const char *,int,long,long); + long (*cb)(BIO *, int, const char *, int, long, long); - if (b == NULL) return(0); + if (b == NULL) + return (0); - if ((b->method == NULL) || (b->method->callback_ctrl == NULL)) - { - BIOerr(BIO_F_BIO_CALLBACK_CTRL,BIO_R_UNSUPPORTED_METHOD); - return(-2); - } + if ((b->method == NULL) || (b->method->callback_ctrl == NULL)) { + BIOerr(BIO_F_BIO_CALLBACK_CTRL, BIO_R_UNSUPPORTED_METHOD); + return (-2); + } - cb=b->callback; + cb = b->callback; if ((cb != NULL) && - ((ret=cb(b,BIO_CB_CTRL,(void *)&fp,cmd,0,1L)) <= 0)) - return(ret); + ((ret = cb(b, BIO_CB_CTRL,(void *)&fp, cmd, 0, 1L)) <= 0)) + return (ret); - ret=b->method->callback_ctrl(b,cmd,fp); + ret = b->method->callback_ctrl(b, cmd, fp); if (cb != NULL) - ret=cb(b,BIO_CB_CTRL|BIO_CB_RETURN,(void *)&fp,cmd, - 0,ret); - return(ret); - } + ret = cb(b, BIO_CB_CTRL|BIO_CB_RETURN,(void *)&fp, cmd, 0, ret); + return (ret); +} /* It is unfortunate to duplicate in functions what the BIO_(w)pending macros * do; but those macros have inappropriate return type, and for interfacing * from other programming languages, C macros aren't much of a help anyway. */ -size_t BIO_ctrl_pending(BIO *bio) - { +size_t +BIO_ctrl_pending(BIO *bio) +{ return BIO_ctrl(bio, BIO_CTRL_PENDING, 0, NULL); - } +} -size_t BIO_ctrl_wpending(BIO *bio) - { +size_t +BIO_ctrl_wpending(BIO *bio) +{ return BIO_ctrl(bio, BIO_CTRL_WPENDING, 0, NULL); - } +} /* put the 'bio' on the end of b's list of operators */ -BIO *BIO_push(BIO *b, BIO *bio) - { +BIO +*BIO_push(BIO *b, BIO *bio) +{ BIO *lb; - if (b == NULL) return(bio); - lb=b; + if (b == NULL) + return (bio); + lb = b; while (lb->next_bio != NULL) - lb=lb->next_bio; - lb->next_bio=bio; + lb = lb->next_bio; + lb->next_bio = bio; if (bio != NULL) - bio->prev_bio=lb; + bio->prev_bio = lb; /* called to do internal processing */ - BIO_ctrl(b,BIO_CTRL_PUSH,0,lb); - return(b); - } + BIO_ctrl(b, BIO_CTRL_PUSH, 0, lb); + return (b); +} /* Remove the first and return the rest */ -BIO *BIO_pop(BIO *b) - { +BIO +*BIO_pop(BIO *b) +{ BIO *ret; - if (b == NULL) return(NULL); - ret=b->next_bio; + if (b == NULL) + return (NULL); + ret = b->next_bio; - BIO_ctrl(b,BIO_CTRL_POP,0,b); + BIO_ctrl(b, BIO_CTRL_POP, 0, b); if (b->prev_bio != NULL) - b->prev_bio->next_bio=b->next_bio; + b->prev_bio->next_bio = b->next_bio; if (b->next_bio != NULL) - b->next_bio->prev_bio=b->prev_bio; + b->next_bio->prev_bio = b->prev_bio; - b->next_bio=NULL; - b->prev_bio=NULL; - return(ret); - } + b->next_bio = NULL; + b->prev_bio = NULL; + return (ret); +} -BIO *BIO_get_retry_BIO(BIO *bio, int *reason) - { - BIO *b,*last; +BIO +*BIO_get_retry_BIO(BIO *bio, int *reason) +{ + BIO *b, *last; - b=last=bio; - for (;;) - { + b = last = bio; + for (;;) { if (!BIO_should_retry(b)) break; - last=b; - b=b->next_bio; - if (b == NULL) break; - } - if (reason != NULL) *reason=last->retry_reason; - return(last); - } + last = b; + b = b->next_bio; + if (b == NULL) + break; + } + if (reason != NULL) + *reason = last->retry_reason; + return (last); +} -int BIO_get_retry_reason(BIO *bio) - { - return(bio->retry_reason); - } +int +BIO_get_retry_reason(BIO *bio) +{ + return (bio->retry_reason); +} -BIO *BIO_find_type(BIO *bio, int type) - { - int mt,mask; - - if(!bio) return NULL; - mask=type&0xff; - do { - if (bio->method != NULL) - { - mt=bio->method->type; - - if (!mask) - { - if (mt & type) return(bio); - } - else if (mt == type) - return(bio); - } - bio=bio->next_bio; - } while (bio != NULL); - return(NULL); - } +BIO +*BIO_find_type(BIO *bio, int type) +{ + int mt, mask; + + if (!bio) + return NULL; + mask = type & 0xff; + do { + if (bio->method != NULL) { + mt = bio->method->type; + if (!mask) { + if (mt & type) + return (bio); + } else if (mt == type) + return (bio); + } + bio = bio->next_bio; + } while (bio != NULL); + return (NULL); +} -BIO *BIO_next(BIO *b) - { - if(!b) return NULL; +BIO +*BIO_next(BIO *b) +{ + if (!b) + return NULL; return b->next_bio; - } +} -void BIO_free_all(BIO *bio) - { +void +BIO_free_all(BIO *bio) +{ BIO *b; int ref; - while (bio != NULL) - { - b=bio; - ref=b->references; - bio=bio->next_bio; + while (bio != NULL) { + b = bio; + ref = b->references; + bio = bio->next_bio; BIO_free(b); /* Since ref count > 1, don't free anyone else. */ - if (ref > 1) break; - } + if (ref > 1) + break; } +} -BIO *BIO_dup_chain(BIO *in) - { - BIO *ret=NULL,*eoc=NULL,*bio,*new_bio; +BIO +*BIO_dup_chain(BIO *in) +{ + BIO *ret = NULL, *eoc = NULL, *bio, *new_bio; - for (bio=in; bio != NULL; bio=bio->next_bio) - { - if ((new_bio=BIO_new(bio->method)) == NULL) goto err; - new_bio->callback=bio->callback; - new_bio->cb_arg=bio->cb_arg; - new_bio->init=bio->init; - new_bio->shutdown=bio->shutdown; - new_bio->flags=bio->flags; + for (bio = in; bio != NULL; bio = bio->next_bio) { + if ((new_bio = BIO_new(bio->method)) == NULL) goto err; + new_bio->callback = bio->callback; + new_bio->cb_arg = bio->cb_arg; + new_bio->init = bio->init; + new_bio->shutdown = bio->shutdown; + new_bio->flags = bio->flags; /* This will let SSL_s_sock() work with stdin/stdout */ - new_bio->num=bio->num; + new_bio->num = bio->num; - if (!BIO_dup_state(bio,(char *)new_bio)) - { + if (!BIO_dup_state(bio,(char *)new_bio)) { BIO_free(new_bio); goto err; - } + } /* copy app data */ - if (!CRYPTO_dup_ex_data(CRYPTO_EX_INDEX_BIO, &new_bio->ex_data, - &bio->ex_data)) + if (!CRYPTO_dup_ex_data(CRYPTO_EX_INDEX_BIO, + &new_bio->ex_data, &bio->ex_data)) goto err; - if (ret == NULL) - { - eoc=new_bio; - ret=eoc; - } - else - { - BIO_push(eoc,new_bio); - eoc=new_bio; - } + if (ret == NULL) { + eoc = new_bio; + ret = eoc; + } else { + BIO_push(eoc, new_bio); + eoc = new_bio; } - return(ret); + } + return (ret); err: if (ret != NULL) BIO_free(ret); - return(NULL); - } + return (NULL); -void BIO_copy_next_retry(BIO *b) - { - BIO_set_flags(b,BIO_get_retry_flags(b->next_bio)); - b->retry_reason=b->next_bio->retry_reason; - } +} -int BIO_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func, - CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func) - { +void +BIO_copy_next_retry(BIO *b) +{ + BIO_set_flags(b, BIO_get_retry_flags(b->next_bio)); + b->retry_reason = b->next_bio->retry_reason; +} + +int +BIO_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func, + CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func) +{ return CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_BIO, argl, argp, - new_func, dup_func, free_func); - } + new_func, dup_func, free_func); +} -int BIO_set_ex_data(BIO *bio, int idx, void *data) - { - return(CRYPTO_set_ex_data(&(bio->ex_data),idx,data)); - } +int +BIO_set_ex_data(BIO *bio, int idx, void *data) +{ + return (CRYPTO_set_ex_data(&(bio->ex_data), idx, data)); +} -void *BIO_get_ex_data(BIO *bio, int idx) - { - return(CRYPTO_get_ex_data(&(bio->ex_data),idx)); - } +void +*BIO_get_ex_data(BIO *bio, int idx) +{ + return (CRYPTO_get_ex_data(&(bio->ex_data), idx)); +} -unsigned long BIO_number_read(BIO *bio) +unsigned long +BIO_number_read(BIO *bio) { - if(bio) return bio->num_read; + if (bio) + return bio->num_read; return 0; } -unsigned long BIO_number_written(BIO *bio) +unsigned long +BIO_number_written(BIO *bio) { - if(bio) return bio->num_write; + if (bio) + return bio->num_write; return 0; } diff --git a/src/lib/libssl/src/crypto/bio/bss_acpt.c b/src/lib/libssl/src/crypto/bio/bss_acpt.c index 04bfb6fb9d..d772515d64 100644 --- a/src/lib/libssl/src/crypto/bio/bss_acpt.c +++ b/src/lib/libssl/src/crypto/bio/bss_acpt.c @@ -75,8 +75,7 @@ #undef FIONBIO #endif -typedef struct bio_accept_st - { +typedef struct bio_accept_st { int state; char *param_addr; @@ -90,7 +89,7 @@ typedef struct bio_accept_st * If 2, always use SO_REUSEADDR. */ int bind_mode; BIO *bio_chain; - } BIO_ACCEPT; +} BIO_ACCEPT; static int acpt_write(BIO *h, const char *buf, int num); static int acpt_read(BIO *h, char *buf, int size); @@ -107,8 +106,7 @@ static void BIO_ACCEPT_free(BIO_ACCEPT *a); #define ACPT_S_GET_ACCEPT_SOCKET 2 #define ACPT_S_OK 3 -static BIO_METHOD methods_acceptp= - { +static BIO_METHOD methods_acceptp = { BIO_TYPE_ACCEPT, "socket accept", acpt_write, @@ -119,321 +117,313 @@ static BIO_METHOD methods_acceptp= acpt_new, acpt_free, NULL, - }; +}; -BIO_METHOD *BIO_s_accept(void) - { - return(&methods_acceptp); - } +BIO_METHOD +*BIO_s_accept(void) +{ + return (&methods_acceptp); +} -static int acpt_new(BIO *bi) - { +static int +acpt_new(BIO *bi) +{ BIO_ACCEPT *ba; - bi->init=0; - bi->num=-1; - bi->flags=0; - if ((ba=BIO_ACCEPT_new()) == NULL) - return(0); - bi->ptr=(char *)ba; - ba->state=ACPT_S_BEFORE; - bi->shutdown=1; - return(1); - } - -static BIO_ACCEPT *BIO_ACCEPT_new(void) - { + bi->init = 0; + bi->num = -1; + bi->flags = 0; + if ((ba = BIO_ACCEPT_new()) == NULL) + return (0); + bi->ptr = (char *)ba; + ba->state = ACPT_S_BEFORE; + bi->shutdown = 1; + return (1); +} + +static BIO_ACCEPT +*BIO_ACCEPT_new(void) +{ BIO_ACCEPT *ret; - if ((ret=(BIO_ACCEPT *)OPENSSL_malloc(sizeof(BIO_ACCEPT))) == NULL) - return(NULL); - - memset(ret,0,sizeof(BIO_ACCEPT)); - ret->accept_sock=-1; - ret->bind_mode=BIO_BIND_NORMAL; - return(ret); - } - -static void BIO_ACCEPT_free(BIO_ACCEPT *a) - { - if(a == NULL) - return; - - if (a->param_addr != NULL) OPENSSL_free(a->param_addr); - if (a->addr != NULL) OPENSSL_free(a->addr); - if (a->bio_chain != NULL) BIO_free(a->bio_chain); + if ((ret = (BIO_ACCEPT *)OPENSSL_malloc(sizeof(BIO_ACCEPT))) == NULL) + return (NULL); + + memset(ret, 0, sizeof(BIO_ACCEPT)); + ret->accept_sock = -1; + ret->bind_mode = BIO_BIND_NORMAL; + return (ret); +} + +static void +BIO_ACCEPT_free(BIO_ACCEPT *a) +{ + if (a == NULL) + return; + + if (a->param_addr != NULL) + OPENSSL_free(a->param_addr); + if (a->addr != NULL) + OPENSSL_free(a->addr); + if (a->bio_chain != NULL) + BIO_free(a->bio_chain); OPENSSL_free(a); - } +} -static void acpt_close_socket(BIO *bio) - { +static void +acpt_close_socket(BIO *bio) +{ BIO_ACCEPT *c; - c=(BIO_ACCEPT *)bio->ptr; - if (c->accept_sock != -1) - { + c = (BIO_ACCEPT *)bio->ptr; + if (c->accept_sock != -1) { shutdown(c->accept_sock, SHUT_RDWR); close(c->accept_sock); - c->accept_sock=-1; - bio->num=-1; - } + c->accept_sock = -1; + bio->num = -1; } +} -static int acpt_free(BIO *a) - { +static int +acpt_free(BIO *a) +{ BIO_ACCEPT *data; - if (a == NULL) return(0); - data=(BIO_ACCEPT *)a->ptr; - - if (a->shutdown) - { + if (a == NULL) + return (0); + data = (BIO_ACCEPT *)a->ptr; + + if (a->shutdown) { acpt_close_socket(a); BIO_ACCEPT_free(data); - a->ptr=NULL; - a->flags=0; - a->init=0; - } - return(1); + a->ptr = NULL; + a->flags = 0; + a->init = 0; } - -static int acpt_state(BIO *b, BIO_ACCEPT *c) - { - BIO *bio=NULL,*dbio; - int s= -1; + return (1); +} + +static int +acpt_state(BIO *b, BIO_ACCEPT *c) +{ + BIO *bio = NULL, *dbio; + int s = -1; int i; again: - switch (c->state) - { + switch (c->state) { case ACPT_S_BEFORE: - if (c->param_addr == NULL) - { - BIOerr(BIO_F_ACPT_STATE,BIO_R_NO_ACCEPT_PORT_SPECIFIED); - return(-1); - } - s=BIO_get_accept_socket(c->param_addr,c->bind_mode); + if (c->param_addr == NULL) { + BIOerr(BIO_F_ACPT_STATE, BIO_R_NO_ACCEPT_PORT_SPECIFIED); + return (-1); + } + s = BIO_get_accept_socket(c->param_addr, c->bind_mode); if (s == -1) - return(-1); + return (-1); - if (c->accept_nbio) - { - if (!BIO_socket_nbio(s,1)) - { + if (c->accept_nbio) { + if (!BIO_socket_nbio(s, 1)) { close(s); - BIOerr(BIO_F_ACPT_STATE,BIO_R_ERROR_SETTING_NBIO_ON_ACCEPT_SOCKET); - return(-1); - } + BIOerr(BIO_F_ACPT_STATE, BIO_R_ERROR_SETTING_NBIO_ON_ACCEPT_SOCKET); + return (-1); } - c->accept_sock=s; - b->num=s; - c->state=ACPT_S_GET_ACCEPT_SOCKET; - return(1); + } + c->accept_sock = s; + b->num = s; + c->state = ACPT_S_GET_ACCEPT_SOCKET; + return (1); /* break; */ case ACPT_S_GET_ACCEPT_SOCKET: - if (b->next_bio != NULL) - { - c->state=ACPT_S_OK; + if (b->next_bio != NULL) { + c->state = ACPT_S_OK; goto again; - } + } BIO_clear_retry_flags(b); - b->retry_reason=0; - i=BIO_accept(c->accept_sock,&(c->addr)); + b->retry_reason = 0; + i = BIO_accept(c->accept_sock, &(c->addr)); /* -2 return means we should retry */ - if(i == -2) - { + if (i == -2) { BIO_set_retry_special(b); - b->retry_reason=BIO_RR_ACCEPT; + b->retry_reason = BIO_RR_ACCEPT; return -1; - } + } - if (i < 0) return(i); + if (i < 0) + return (i); - bio=BIO_new_socket(i,BIO_CLOSE); - if (bio == NULL) goto err; + bio = BIO_new_socket(i, BIO_CLOSE); + if (bio == NULL) + goto err; - BIO_set_callback(bio,BIO_get_callback(b)); - BIO_set_callback_arg(bio,BIO_get_callback_arg(b)); + BIO_set_callback(bio, BIO_get_callback(b)); + BIO_set_callback_arg(bio, BIO_get_callback_arg(b)); - if (c->nbio) - { - if (!BIO_socket_nbio(i,1)) - { - BIOerr(BIO_F_ACPT_STATE,BIO_R_ERROR_SETTING_NBIO_ON_ACCEPTED_SOCKET); + if (c->nbio) { + if (!BIO_socket_nbio(i, 1)) { + BIOerr(BIO_F_ACPT_STATE, BIO_R_ERROR_SETTING_NBIO_ON_ACCEPTED_SOCKET); goto err; - } } + } /* If the accept BIO has an bio_chain, we dup it and * put the new socket at the end. */ - if (c->bio_chain != NULL) - { - if ((dbio=BIO_dup_chain(c->bio_chain)) == NULL) + if (c->bio_chain != NULL) { + if ((dbio = BIO_dup_chain(c->bio_chain)) == NULL) goto err; - if (!BIO_push(dbio,bio)) goto err; - bio=dbio; - } - if (BIO_push(b,bio) == NULL) goto err; + if (!BIO_push(dbio, bio)) goto err; + bio = dbio; + } + if (BIO_push(b, bio) + == NULL) goto err; + + c->state = ACPT_S_OK; + return (1); - c->state=ACPT_S_OK; - return(1); err: if (bio != NULL) BIO_free(bio); else if (s >= 0) close(s); - return(0); + return (0); /* break; */ case ACPT_S_OK: - if (b->next_bio == NULL) - { - c->state=ACPT_S_GET_ACCEPT_SOCKET; + if (b->next_bio == NULL) { + c->state = ACPT_S_GET_ACCEPT_SOCKET; goto again; - } - return(1); + } + return (1); /* break; */ - default: - return(0); + default: + return (0); /* break; */ - } - } +} -static int acpt_read(BIO *b, char *out, int outl) - { - int ret=0; +static int +acpt_read(BIO *b, char *out, int outl) +{ + int ret = 0; BIO_ACCEPT *data; BIO_clear_retry_flags(b); - data=(BIO_ACCEPT *)b->ptr; + data = (BIO_ACCEPT *)b->ptr; - while (b->next_bio == NULL) - { - ret=acpt_state(b,data); - if (ret <= 0) return(ret); - } + while (b->next_bio == NULL) { + ret = acpt_state(b, data); + if (ret <= 0) + return (ret); + } - ret=BIO_read(b->next_bio,out,outl); + ret = BIO_read(b->next_bio, out, outl); BIO_copy_next_retry(b); - return(ret); - } + return (ret); +} -static int acpt_write(BIO *b, const char *in, int inl) - { +static int +acpt_write(BIO *b, const char *in, int inl) +{ int ret; BIO_ACCEPT *data; BIO_clear_retry_flags(b); - data=(BIO_ACCEPT *)b->ptr; + data = (BIO_ACCEPT *)b->ptr; - while (b->next_bio == NULL) - { - ret=acpt_state(b,data); - if (ret <= 0) return(ret); - } + while (b->next_bio == NULL) { + ret = acpt_state(b, data); + if (ret <= 0) + return (ret); + } - ret=BIO_write(b->next_bio,in,inl); + ret = BIO_write(b->next_bio, in, inl); BIO_copy_next_retry(b); - return(ret); - } + return (ret); +} -static long acpt_ctrl(BIO *b, int cmd, long num, void *ptr) - { +static long +acpt_ctrl(BIO *b, int cmd, long num, void *ptr) +{ int *ip; - long ret=1; + long ret = 1; BIO_ACCEPT *data; char **pp; - data=(BIO_ACCEPT *)b->ptr; + data = (BIO_ACCEPT *)b->ptr; - switch (cmd) - { + switch (cmd) { case BIO_CTRL_RESET: - ret=0; - data->state=ACPT_S_BEFORE; + ret = 0; + data->state = ACPT_S_BEFORE; acpt_close_socket(b); - b->flags=0; + b->flags = 0; break; case BIO_C_DO_STATE_MACHINE: /* use this one to start the connection */ - ret=(long)acpt_state(b,data); + ret = (long)acpt_state(b, data); break; case BIO_C_SET_ACCEPT: - if (ptr != NULL) - { - if (num == 0) - { - b->init=1; + if (ptr != NULL) { + if (num == 0) { + b->init = 1; if (data->param_addr != NULL) OPENSSL_free(data->param_addr); - data->param_addr=BUF_strdup(ptr); - } - else if (num == 1) - { - data->accept_nbio=(ptr != NULL); - } - else if (num == 2) - { + data->param_addr = BUF_strdup(ptr); + } else if (num == 1) { + data->accept_nbio = (ptr != NULL); + } else if (num == 2) { if (data->bio_chain != NULL) BIO_free(data->bio_chain); - data->bio_chain=(BIO *)ptr; - } + data->bio_chain = (BIO *)ptr; } + } break; case BIO_C_SET_NBIO: - data->nbio=(int)num; + data->nbio = (int)num; break; case BIO_C_SET_FD: - b->init=1; + b->init = 1; b->num= *((int *)ptr); - data->accept_sock=b->num; - data->state=ACPT_S_GET_ACCEPT_SOCKET; - b->shutdown=(int)num; - b->init=1; + data->accept_sock = b->num; + data->state = ACPT_S_GET_ACCEPT_SOCKET; + b->shutdown = (int)num; + b->init = 1; break; case BIO_C_GET_FD: - if (b->init) - { - ip=(int *)ptr; + if (b->init) { + ip = (int *)ptr; if (ip != NULL) - *ip=data->accept_sock; - ret=data->accept_sock; - } - else - ret= -1; + *ip = data->accept_sock; + ret = data->accept_sock; + } else + ret = -1; break; case BIO_C_GET_ACCEPT: - if (b->init) - { - if (ptr != NULL) - { - pp=(char **)ptr; - *pp=data->param_addr; - } - else - ret= -1; - } - else - ret= -1; + if (b->init) { + if (ptr != NULL) { + pp = (char **)ptr; + *pp = data->param_addr; + } else + ret = -1; + } else + ret = -1; break; case BIO_CTRL_GET_CLOSE: - ret=b->shutdown; + ret = b->shutdown; break; case BIO_CTRL_SET_CLOSE: - b->shutdown=(int)num; + b->shutdown = (int)num; break; case BIO_CTRL_PENDING: case BIO_CTRL_WPENDING: - ret=0; + ret = 0; break; case BIO_CTRL_FLUSH: break; case BIO_C_SET_BIND_MODE: - data->bind_mode=(int)num; + data->bind_mode = (int)num; break; case BIO_C_GET_BIND_MODE: - ret=(long)data->bind_mode; + ret = (long)data->bind_mode; break; case BIO_CTRL_DUP: /* dbio=(BIO *)ptr; @@ -441,38 +431,41 @@ static long acpt_ctrl(BIO *b, int cmd, long num, void *ptr) BIO_set_port(dbio,data->param_port); if (data->param_hostname) BIO_set_hostname(dbio,data->param_hostname); - BIO_set_nbio(dbio,data->nbio); */ + BIO_set_nbio(dbio,data->nbio); +*/ break; default: - ret=0; + ret = 0; break; - } - return(ret); } - -static int acpt_puts(BIO *bp, const char *str) - { - int n,ret; - - n=strlen(str); - ret=acpt_write(bp,str,n); - return(ret); - } - -BIO *BIO_new_accept(char *str) - { + return (ret); +} + +static int +acpt_puts(BIO *bp, const char *str) +{ + int n, ret; + + n = strlen(str); + ret = acpt_write(bp, str, n); + return (ret); +} + +BIO +*BIO_new_accept(char *str) +{ BIO *ret; - ret=BIO_new(BIO_s_accept()); - if (ret == NULL) return(NULL); - if (BIO_set_accept_port(ret,str)) - return(ret); - else - { + ret = BIO_new(BIO_s_accept()); + if (ret == NULL) + return (NULL); + if (BIO_set_accept_port(ret, str)) + return (ret); + else { BIO_free(ret); - return(NULL); - } + return (NULL); } +} #endif diff --git a/src/lib/libssl/src/crypto/bio/bss_bio.c b/src/lib/libssl/src/crypto/bio/bss_bio.c index 52ef0ebcb3..a74fcfdabc 100644 --- a/src/lib/libssl/src/crypto/bio/bss_bio.c +++ b/src/lib/libssl/src/crypto/bio/bss_bio.c @@ -103,8 +103,7 @@ static int bio_puts(BIO *bio, const char *str); static int bio_make_pair(BIO *bio1, BIO *bio2); static void bio_destroy_pair(BIO *bio); -static BIO_METHOD methods_biop = -{ +static BIO_METHOD methods_biop = { BIO_TYPE_BIO, "BIO pair", bio_write, @@ -117,50 +116,51 @@ static BIO_METHOD methods_biop = NULL /* no bio_callback_ctrl */ }; -BIO_METHOD *BIO_s_bio(void) - { +BIO_METHOD +*BIO_s_bio(void) +{ return &methods_biop; - } +} + +struct bio_bio_st { + BIO *peer; /* NULL if buf == NULL. + * If peer != NULL, then peer->ptr is also a bio_bio_st, + * and its "peer" member points back to us. + * peer != NULL iff init != 0 in the BIO. */ -struct bio_bio_st -{ - BIO *peer; /* NULL if buf == NULL. - * If peer != NULL, then peer->ptr is also a bio_bio_st, - * and its "peer" member points back to us. - * peer != NULL iff init != 0 in the BIO. */ - /* This is for what we write (i.e. reading uses peer's struct): */ - int closed; /* valid iff peer != NULL */ - size_t len; /* valid iff buf != NULL; 0 if peer == NULL */ - size_t offset; /* valid iff buf != NULL; 0 if len == 0 */ + int closed; /* valid iff peer != NULL */ + size_t len; /* valid iff buf != NULL; 0 if peer == NULL */ + size_t offset; /* valid iff buf != NULL; 0 if len == 0 */ size_t size; char *buf; /* "size" elements (if != NULL) */ size_t request; /* valid iff peer != NULL; 0 if len != 0, - * otherwise set by peer to number of bytes - * it (unsuccessfully) tried to read, + * otherwise set by peer to number of bytes + * it (unsuccessfully) tried to read, * never more than buffer space (size-len) warrants. */ }; -static int bio_new(BIO *bio) - { +static int +bio_new(BIO *bio) +{ struct bio_bio_st *b; - + b = OPENSSL_malloc(sizeof *b); if (b == NULL) return 0; b->peer = NULL; - b->size = 17*1024; /* enough for one TLS record (just a default) */ + b->size = 17 * 1024; /* enough for one TLS record (just a default) */ b->buf = NULL; bio->ptr = b; return 1; - } +} - -static int bio_free(BIO *bio) - { +static int +bio_free(BIO *bio) +{ struct bio_bio_st *b; if (bio == NULL) @@ -171,21 +171,21 @@ static int bio_free(BIO *bio) if (b->peer) bio_destroy_pair(bio); - - if (b->buf != NULL) - { + + if (b->buf != NULL) { OPENSSL_free(b->buf); - } + } OPENSSL_free(b); return 1; - } +} -static int bio_read(BIO *bio, char *buf, int size_) - { +static int +bio_read(BIO *bio, char *buf, int size_) +{ size_t size = size_; size_t rest; struct bio_bio_st *b, *peer_b; @@ -207,12 +207,10 @@ static int bio_read(BIO *bio, char *buf, int size_) if (buf == NULL || size == 0) return 0; - if (peer_b->len == 0) - { + if (peer_b->len == 0) { if (peer_b->closed) return 0; /* writer has closed, and no data is left */ - else - { + else { BIO_set_retry_read(bio); /* buffer is empty */ if (size <= peer_b->size) peer_b->request = size; @@ -221,22 +219,22 @@ static int bio_read(BIO *bio, char *buf, int size_) * deliver in one write */ peer_b->request = peer_b->size; return -1; - } } + } /* we can read */ if (peer_b->len < size) size = peer_b->len; /* now read "size" bytes */ - + rest = size; - + assert(rest > 0); do /* one or two iterations */ - { + { size_t chunk; - + assert(rest <= peer_b->len); if (peer_b->offset + rest <= peer_b->size) chunk = rest; @@ -244,30 +242,26 @@ static int bio_read(BIO *bio, char *buf, int size_) /* wrap around ring buffer */ chunk = peer_b->size - peer_b->offset; assert(peer_b->offset + chunk <= peer_b->size); - + memcpy(buf, peer_b->buf + peer_b->offset, chunk); - + peer_b->len -= chunk; - if (peer_b->len) - { + if (peer_b->len) { peer_b->offset += chunk; assert(peer_b->offset <= peer_b->size); if (peer_b->offset == peer_b->size) peer_b->offset = 0; buf += chunk; - } - else - { + } else { /* buffer now empty, no need to advance "buf" */ assert(chunk == rest); peer_b->offset = 0; - } - rest -= chunk; } - while (rest); - + rest -= chunk; + } while (rest); + return size; - } +} /* non-copying interface: provide pointer to available data in buffer * bio_nread0: return number of available bytes @@ -277,32 +271,32 @@ static int bio_read(BIO *bio, char *buf, int size_) */ /* WARNING: The non-copying interface is largely untested as of yet * and may contain bugs. */ -static ossl_ssize_t bio_nread0(BIO *bio, char **buf) - { +static ossl_ssize_t +bio_nread0(BIO *bio, char **buf) +{ struct bio_bio_st *b, *peer_b; ossl_ssize_t num; - + BIO_clear_retry_flags(bio); if (!bio->init) return 0; - + b = bio->ptr; assert(b != NULL); assert(b->peer != NULL); peer_b = b->peer->ptr; assert(peer_b != NULL); assert(peer_b->buf != NULL); - + peer_b->request = 0; - - if (peer_b->len == 0) - { + + if (peer_b->len == 0) { char dummy; - + /* avoid code duplication -- nothing available for reading */ return bio_read(bio, &dummy, 1); /* returns 0 or -1 */ - } + } num = peer_b->len; if (peer_b->size < peer_b->offset + num) @@ -313,10 +307,11 @@ static ossl_ssize_t bio_nread0(BIO *bio, char **buf) if (buf != NULL) *buf = peer_b->buf + peer_b->offset; return num; - } +} -static ossl_ssize_t bio_nread(BIO *bio, char **buf, size_t num_) - { +static ossl_ssize_t +bio_nread(BIO *bio, char **buf, size_t num_) +{ struct bio_bio_st *b, *peer_b; ossl_ssize_t num, available; @@ -335,22 +330,21 @@ static ossl_ssize_t bio_nread(BIO *bio, char **buf, size_t num_) peer_b = b->peer->ptr; peer_b->len -= num; - if (peer_b->len) - { + if (peer_b->len) { peer_b->offset += num; assert(peer_b->offset <= peer_b->size); if (peer_b->offset == peer_b->size) peer_b->offset = 0; - } - else + } else peer_b->offset = 0; return num; - } +} -static int bio_write(BIO *bio, const char *buf, int num_) - { +static int +bio_write(BIO *bio, const char *buf, int num_) +{ size_t num = num_; size_t rest; struct bio_bio_st *b; @@ -360,38 +354,37 @@ static int bio_write(BIO *bio, const char *buf, int num_) if (!bio->init || buf == NULL || num == 0) return 0; - b = bio->ptr; + b = bio->ptr; + assert(b != NULL); assert(b->peer != NULL); assert(b->buf != NULL); b->request = 0; - if (b->closed) - { + if (b->closed) { /* we already closed */ BIOerr(BIO_F_BIO_WRITE, BIO_R_BROKEN_PIPE); return -1; - } + } assert(b->len <= b->size); - if (b->len == b->size) - { + if (b->len == b->size) { BIO_set_retry_write(bio); /* buffer is full */ return -1; - } + } /* we can write */ if (num > b->size - b->len) num = b->size - b->len; - + /* now write "num" bytes */ rest = num; - + assert(rest > 0); do /* one or two iterations */ - { + { size_t write_offset; size_t chunk; @@ -407,20 +400,19 @@ static int bio_write(BIO *bio, const char *buf, int num_) else /* wrap around ring buffer */ chunk = b->size - write_offset; - + memcpy(b->buf + write_offset, buf, chunk); - + b->len += chunk; assert(b->len <= b->size); - + rest -= chunk; buf += chunk; - } - while (rest); + } while (rest); return num; - } +} /* non-copying interface: provide pointer to region to write to * bio_nwrite0: check how much space is available @@ -428,8 +420,9 @@ static int bio_write(BIO *bio, const char *buf, int num_) * (example usage: bio_nwrite0(), write to buffer, bio_nwrite() * or just bio_nwrite(), write to buffer) */ -static ossl_ssize_t bio_nwrite0(BIO *bio, char **buf) - { +static ossl_ssize_t +bio_nwrite0(BIO *bio, char **buf) +{ struct bio_bio_st *b; size_t num; size_t write_offset; @@ -439,25 +432,24 @@ static ossl_ssize_t bio_nwrite0(BIO *bio, char **buf) if (!bio->init) return 0; - b = bio->ptr; + b = bio->ptr; + assert(b != NULL); assert(b->peer != NULL); assert(b->buf != NULL); b->request = 0; - if (b->closed) - { + if (b->closed) { BIOerr(BIO_F_BIO_NWRITE0, BIO_R_BROKEN_PIPE); return -1; - } + } assert(b->len <= b->size); - if (b->len == b->size) - { + if (b->len == b->size) { BIO_set_retry_write(bio); return -1; - } + } num = b->size - b->len; write_offset = b->offset + b->len; @@ -474,10 +466,11 @@ static ossl_ssize_t bio_nwrite0(BIO *bio, char **buf) assert(write_offset + num <= b->size); return num; - } +} -static ossl_ssize_t bio_nwrite(BIO *bio, char **buf, size_t num_) - { +static ossl_ssize_t +bio_nwrite(BIO *bio, char **buf, size_t num_) +{ struct bio_bio_st *b; ossl_ssize_t num, space; @@ -497,46 +490,39 @@ static ossl_ssize_t bio_nwrite(BIO *bio, char **buf, size_t num_) assert(b->len <= b->size); return num; - } +} -static long bio_ctrl(BIO *bio, int cmd, long num, void *ptr) - { +static long +bio_ctrl(BIO *bio, int cmd, long num, void *ptr) +{ long ret; struct bio_bio_st *b = bio->ptr; - + assert(b != NULL); - switch (cmd) - { - /* specific CTRL codes */ + switch (cmd) { + /* specific CTRL codes */ case BIO_C_SET_WRITE_BUF_SIZE: - if (b->peer) - { + if (b->peer) { BIOerr(BIO_F_BIO_CTRL, BIO_R_IN_USE); ret = 0; - } - else if (num == 0) - { + } else if (num == 0) { BIOerr(BIO_F_BIO_CTRL, BIO_R_INVALID_ARGUMENT); ret = 0; - } - else - { + } else { size_t new_size = num; - if (b->size != new_size) - { - if (b->buf) - { + if (b->size != new_size) { + if (b->buf) { OPENSSL_free(b->buf); b->buf = NULL; - } - b->size = new_size; } - ret = 1; + b->size = new_size; } + ret = 1; + } break; case BIO_C_GET_WRITE_BUF_SIZE: @@ -545,15 +531,15 @@ static long bio_ctrl(BIO *bio, int cmd, long num, void *ptr) case BIO_C_MAKE_BIO_PAIR: { - BIO *other_bio = ptr; - - if (bio_make_pair(bio, other_bio)) - ret = 1; - else - ret = 0; + BIO *other_bio = ptr; + + if (bio_make_pair(bio, other_bio)) + ret = 1; + else + ret = 0; } break; - + case BIO_C_DESTROY_BIO_PAIR: /* Affects both BIOs in the pair -- call just once! * Or let BIO_free(bio1); BIO_free(bio2); do the job. */ @@ -596,12 +582,12 @@ static long bio_ctrl(BIO *bio, int cmd, long num, void *ptr) /* prepare for non-copying read */ ret = (long) bio_nread0(bio, ptr); break; - + case BIO_C_NREAD: /* non-copying read */ ret = (long) bio_nread(bio, ptr, (size_t) num); break; - + case BIO_C_NWRITE0: /* prepare for non-copying write */ ret = (long) bio_nwrite0(bio, ptr); @@ -611,18 +597,18 @@ static long bio_ctrl(BIO *bio, int cmd, long num, void *ptr) /* non-copying write */ ret = (long) bio_nwrite(bio, ptr, (size_t) num); break; - - /* standard CTRL codes follow */ + + /* standard CTRL codes follow */ case BIO_CTRL_RESET: - if (b->buf != NULL) - { + if (b->buf != NULL) { b->len = 0; b->offset = 0; - } + } ret = 0; - break; + break; + case BIO_CTRL_GET_CLOSE: ret = bio->shutdown; @@ -634,13 +620,11 @@ static long bio_ctrl(BIO *bio, int cmd, long num, void *ptr) break; case BIO_CTRL_PENDING: - if (b->peer != NULL) - { + if (b->peer != NULL) { struct bio_bio_st *peer_b = b->peer->ptr; - + ret = (long) peer_b->len; - } - else + } else ret = 0; break; @@ -654,16 +638,16 @@ static long bio_ctrl(BIO *bio, int cmd, long num, void *ptr) case BIO_CTRL_DUP: /* See BIO_dup_chain for circumstances we have to expect. */ { - BIO *other_bio = ptr; - struct bio_bio_st *other_b; - - assert(other_bio != NULL); - other_b = other_bio->ptr; - assert(other_b != NULL); - - assert(other_b->buf == NULL); /* other_bio is always fresh */ - - other_b->size = b->size; + BIO *other_bio = ptr; + struct bio_bio_st *other_b; + + assert(other_bio != NULL); + other_b = other_bio->ptr; + assert(other_b != NULL); + + assert(other_b->buf == NULL); /* other_bio is always fresh */ + + other_b->size = b->size; } ret = 1; @@ -675,34 +659,34 @@ static long bio_ctrl(BIO *bio, int cmd, long num, void *ptr) case BIO_CTRL_EOF: { - BIO *other_bio = ptr; - - if (other_bio) - { - struct bio_bio_st *other_b = other_bio->ptr; - - assert(other_b != NULL); - ret = other_b->len == 0 && other_b->closed; - } - else - ret = 1; + BIO *other_bio = ptr; + + if (other_bio) { + struct bio_bio_st *other_b = other_bio->ptr; + + assert(other_b != NULL); + ret = other_b->len == 0 && other_b->closed; + } else + ret = 1; } break; default: ret = 0; - } - return ret; } + return ret; +} -static int bio_puts(BIO *bio, const char *str) - { +static int +bio_puts(BIO *bio, const char *str) +{ return bio_write(bio, str, strlen(str)); - } +} -static int bio_make_pair(BIO *bio1, BIO *bio2) - { +static int +bio_make_pair(BIO *bio1, BIO *bio2) +{ struct bio_bio_st *b1, *b2; assert(bio1 != NULL); @@ -710,37 +694,32 @@ static int bio_make_pair(BIO *bio1, BIO *bio2) b1 = bio1->ptr; b2 = bio2->ptr; - - if (b1->peer != NULL || b2->peer != NULL) - { + + if (b1->peer != NULL || b2->peer != NULL) { BIOerr(BIO_F_BIO_MAKE_PAIR, BIO_R_IN_USE); return 0; - } - - if (b1->buf == NULL) - { + } + + if (b1->buf == NULL) { b1->buf = OPENSSL_malloc(b1->size); - if (b1->buf == NULL) - { + if (b1->buf == NULL) { BIOerr(BIO_F_BIO_MAKE_PAIR, ERR_R_MALLOC_FAILURE); return 0; - } + } b1->len = 0; b1->offset = 0; - } - - if (b2->buf == NULL) - { + } + + if (b2->buf == NULL) { b2->buf = OPENSSL_malloc(b2->size); - if (b2->buf == NULL) - { + if (b2->buf == NULL) { BIOerr(BIO_F_BIO_MAKE_PAIR, ERR_R_MALLOC_FAILURE); return 0; - } + } b2->len = 0; b2->offset = 0; - } - + } + b1->peer = bio2; b1->closed = 0; b1->request = 0; @@ -752,18 +731,17 @@ static int bio_make_pair(BIO *bio1, BIO *bio2) bio2->init = 1; return 1; - } +} -static void bio_destroy_pair(BIO *bio) - { +static void +bio_destroy_pair(BIO *bio) +{ struct bio_bio_st *b = bio->ptr; - if (b != NULL) - { + if (b != NULL) { BIO *peer_bio = b->peer; - if (peer_bio != NULL) - { + if (peer_bio != NULL) { struct bio_bio_st *peer_b = peer_bio->ptr; assert(peer_b != NULL); @@ -774,151 +752,149 @@ static void bio_destroy_pair(BIO *bio) assert(peer_b->buf != NULL); peer_b->len = 0; peer_b->offset = 0; - + b->peer = NULL; bio->init = 0; assert(b->buf != NULL); b->len = 0; b->offset = 0; - } } } - +} + /* Exported convenience functions */ -int BIO_new_bio_pair(BIO **bio1_p, size_t writebuf1, - BIO **bio2_p, size_t writebuf2) - { - BIO *bio1 = NULL, *bio2 = NULL; - long r; - int ret = 0; - - bio1 = BIO_new(BIO_s_bio()); - if (bio1 == NULL) - goto err; - bio2 = BIO_new(BIO_s_bio()); - if (bio2 == NULL) - goto err; - - if (writebuf1) - { - r = BIO_set_write_buf_size(bio1, writebuf1); - if (!r) - goto err; - } - if (writebuf2) - { - r = BIO_set_write_buf_size(bio2, writebuf2); - if (!r) - goto err; - } - - r = BIO_make_bio_pair(bio1, bio2); - if (!r) - goto err; - ret = 1; - - err: - if (ret == 0) - { - if (bio1) - { - BIO_free(bio1); - bio1 = NULL; - } - if (bio2) - { - BIO_free(bio2); - bio2 = NULL; - } - } - - *bio1_p = bio1; - *bio2_p = bio2; - return ret; - } - -size_t BIO_ctrl_get_write_guarantee(BIO *bio) - { - return BIO_ctrl(bio, BIO_C_GET_WRITE_GUARANTEE, 0, NULL); +int +BIO_new_bio_pair(BIO **bio1_p, size_t writebuf1, BIO **bio2_p, size_t writebuf2) +{ + BIO *bio1 = NULL, *bio2 = NULL; + long r; + int ret = 0; + + bio1 = BIO_new(BIO_s_bio()); + if (bio1 == NULL) + goto err; + bio2 = BIO_new(BIO_s_bio()); + if (bio2 == NULL) + goto err; + + if (writebuf1) { + r = BIO_set_write_buf_size(bio1, writebuf1); + if (!r) + goto err; + } + if (writebuf2) { + r = BIO_set_write_buf_size(bio2, writebuf2); + if (!r) + goto err; } -size_t BIO_ctrl_get_read_request(BIO *bio) - { - return BIO_ctrl(bio, BIO_C_GET_READ_REQUEST, 0, NULL); + r = BIO_make_bio_pair(bio1, bio2); + if (!r) + goto err; + ret = 1; + + err: + if (ret == 0) { + if (bio1) { + BIO_free(bio1); + bio1 = NULL; + } + if (bio2) { + BIO_free(bio2); + bio2 = NULL; + } } -int BIO_ctrl_reset_read_request(BIO *bio) - { + *bio1_p = bio1; + *bio2_p = bio2; + return ret; +} + +size_t +BIO_ctrl_get_write_guarantee(BIO *bio) +{ + return BIO_ctrl(bio, BIO_C_GET_WRITE_GUARANTEE, 0, NULL); +} + +size_t +BIO_ctrl_get_read_request(BIO *bio) +{ + return BIO_ctrl(bio, BIO_C_GET_READ_REQUEST, 0, NULL); +} + +int +BIO_ctrl_reset_read_request(BIO *bio) +{ return (BIO_ctrl(bio, BIO_C_RESET_READ_REQUEST, 0, NULL) != 0); - } +} /* BIO_nread0/nread/nwrite0/nwrite are available only for BIO pairs for now * (conceivably some other BIOs could allow non-copying reads and writes too.) */ -int BIO_nread0(BIO *bio, char **buf) - { +int +BIO_nread0(BIO *bio, char **buf) +{ long ret; - if (!bio->init) - { + if (!bio->init) { BIOerr(BIO_F_BIO_NREAD0, BIO_R_UNINITIALIZED); return -2; - } + } ret = BIO_ctrl(bio, BIO_C_NREAD0, 0, buf); if (ret > INT_MAX) return INT_MAX; else return (int) ret; - } +} -int BIO_nread(BIO *bio, char **buf, int num) - { +int +BIO_nread(BIO *bio, char **buf, int num) +{ int ret; - if (!bio->init) - { + if (!bio->init) { BIOerr(BIO_F_BIO_NREAD, BIO_R_UNINITIALIZED); return -2; - } + } ret = (int) BIO_ctrl(bio, BIO_C_NREAD, num, buf); if (ret > 0) bio->num_read += ret; return ret; - } +} -int BIO_nwrite0(BIO *bio, char **buf) - { +int +BIO_nwrite0(BIO *bio, char **buf) +{ long ret; - if (!bio->init) - { + if (!bio->init) { BIOerr(BIO_F_BIO_NWRITE0, BIO_R_UNINITIALIZED); return -2; - } + } ret = BIO_ctrl(bio, BIO_C_NWRITE0, 0, buf); if (ret > INT_MAX) return INT_MAX; else return (int) ret; - } +} -int BIO_nwrite(BIO *bio, char **buf, int num) - { +int +BIO_nwrite(BIO *bio, char **buf, int num) +{ int ret; - if (!bio->init) - { + if (!bio->init) { BIOerr(BIO_F_BIO_NWRITE, BIO_R_UNINITIALIZED); return -2; - } + } ret = BIO_ctrl(bio, BIO_C_NWRITE, num, buf); if (ret > 0) bio->num_write += ret; return ret; - } +} diff --git a/src/lib/libssl/src/crypto/bio/bss_conn.c b/src/lib/libssl/src/crypto/bio/bss_conn.c index 5162e75c87..df34c49a4a 100644 --- a/src/lib/libssl/src/crypto/bio/bss_conn.c +++ b/src/lib/libssl/src/crypto/bio/bss_conn.c @@ -76,8 +76,7 @@ #endif -typedef struct bio_connect_st - { +typedef struct bio_connect_st { int state; char *param_hostname; @@ -95,8 +94,8 @@ typedef struct bio_connect_st /* called when the connection is initially made * callback(BIO,state,ret); The callback should return * 'ret'. state is for compatibility with the ssl info_callback */ - int (*info_callback)(const BIO *bio,int state,int ret); - } BIO_CONNECT; + int (*info_callback)(const BIO *bio, int state, int ret); +} BIO_CONNECT; static int conn_write(BIO *h, const char *buf, int num); static int conn_read(BIO *h, char *buf, int size); @@ -108,11 +107,10 @@ static long conn_callback_ctrl(BIO *h, int cmd, bio_info_cb *); static int conn_state(BIO *b, BIO_CONNECT *c); static void conn_close_socket(BIO *data); -BIO_CONNECT *BIO_CONNECT_new(void ); +BIO_CONNECT *BIO_CONNECT_new(void); void BIO_CONNECT_free(BIO_CONNECT *a); -static BIO_METHOD methods_connectp= - { +static BIO_METHOD methods_connectp = { BIO_TYPE_CONNECT, "socket connect", conn_write, @@ -123,530 +121,501 @@ static BIO_METHOD methods_connectp= conn_new, conn_free, conn_callback_ctrl, - }; +}; -static int conn_state(BIO *b, BIO_CONNECT *c) - { - int ret= -1,i; +static int +conn_state(BIO *b, BIO_CONNECT *c) +{ + int ret = -1, i; unsigned long l; - char *p,*q; - int (*cb)(const BIO *,int,int)=NULL; + char *p, *q; + int (*cb)(const BIO *, int, int) = NULL; if (c->info_callback != NULL) - cb=c->info_callback; + cb = c->info_callback; - for (;;) - { - switch (c->state) - { + for (;;) { + switch (c->state) { case BIO_CONN_S_BEFORE: - p=c->param_hostname; - if (p == NULL) - { - BIOerr(BIO_F_CONN_STATE,BIO_R_NO_HOSTNAME_SPECIFIED); + p = c->param_hostname; + if (p == NULL) { + BIOerr(BIO_F_CONN_STATE, BIO_R_NO_HOSTNAME_SPECIFIED); goto exit_loop; - } - for ( ; *p != '\0'; p++) - { - if ((*p == ':') || (*p == '/')) break; - } + } + for (; *p != '\0'; p++) { + if ((*p == ':') || (*p == '/')) + break; + } i= *p; - if ((i == ':') || (i == '/')) - { - - *(p++)='\0'; - if (i == ':') - { - for (q=p; *q; q++) - if (*q == '/') - { - *q='\0'; + if ((i == ':') || (i == '/')) { + *(p++) = '\0'; + if (i == ':') { + for (q = p; *q; q++) + if (*q == '/') { + *q = '\0'; break; - } + } if (c->param_port != NULL) OPENSSL_free(c->param_port); - c->param_port=BUF_strdup(p); - } + c->param_port = BUF_strdup(p); } + } - if (c->param_port == NULL) - { - BIOerr(BIO_F_CONN_STATE,BIO_R_NO_PORT_SPECIFIED); - ERR_add_error_data(2,"host=",c->param_hostname); + if (c->param_port == NULL) { + BIOerr(BIO_F_CONN_STATE, BIO_R_NO_PORT_SPECIFIED); + ERR_add_error_data(2, "host=", c->param_hostname); goto exit_loop; - } - c->state=BIO_CONN_S_GET_IP; + } + c->state = BIO_CONN_S_GET_IP; break; case BIO_CONN_S_GET_IP: - if (BIO_get_host_ip(c->param_hostname,&(c->ip[0])) <= 0) + if (BIO_get_host_ip(c->param_hostname, &(c->ip[0])) <= 0) goto exit_loop; - c->state=BIO_CONN_S_GET_PORT; + c->state = BIO_CONN_S_GET_PORT; break; case BIO_CONN_S_GET_PORT: - if (c->param_port == NULL) - { + if (c->param_port == NULL) { /* abort(); */ goto exit_loop; - } - else if (BIO_get_port(c->param_port,&c->port) <= 0) + } else if (BIO_get_port(c->param_port, &c->port) <= 0) goto exit_loop; - c->state=BIO_CONN_S_CREATE_SOCKET; + c->state = BIO_CONN_S_CREATE_SOCKET; break; case BIO_CONN_S_CREATE_SOCKET: /* now setup address */ - memset((char *)&c->them,0,sizeof(c->them)); - c->them.sin_family=AF_INET; - c->them.sin_port=htons((unsigned short)c->port); - l=(unsigned long) - ((unsigned long)c->ip[0]<<24L)| - ((unsigned long)c->ip[1]<<16L)| - ((unsigned long)c->ip[2]<< 8L)| - ((unsigned long)c->ip[3]); - c->them.sin_addr.s_addr=htonl(l); - c->state=BIO_CONN_S_CREATE_SOCKET; - - ret=socket(AF_INET,SOCK_STREAM,SOCKET_PROTOCOL); - if (ret == -1) - { - SYSerr(SYS_F_SOCKET,errno); - ERR_add_error_data(4,"host=",c->param_hostname, - ":",c->param_port); - BIOerr(BIO_F_CONN_STATE,BIO_R_UNABLE_TO_CREATE_SOCKET); + memset((char *)&c->them, 0, sizeof(c->them)); + c->them.sin_family = AF_INET; + c->them.sin_port = htons((unsigned short)c->port); + l = (unsigned long) + ((unsigned long)c->ip[0] << 24L)| + ((unsigned long)c->ip[1] << 16L)| + ((unsigned long)c->ip[2] << 8L)| + ((unsigned long)c->ip[3]); + c->them.sin_addr.s_addr = htonl(l); + c->state = BIO_CONN_S_CREATE_SOCKET; + + ret = socket(AF_INET, SOCK_STREAM, SOCKET_PROTOCOL); + if (ret == -1) { + SYSerr(SYS_F_SOCKET, errno); + ERR_add_error_data(4, "host=", + c->param_hostname, ":", c->param_port); + BIOerr(BIO_F_CONN_STATE, + BIO_R_UNABLE_TO_CREATE_SOCKET); goto exit_loop; - } - b->num=ret; - c->state=BIO_CONN_S_NBIO; + } + b->num = ret; + c->state = BIO_CONN_S_NBIO; break; case BIO_CONN_S_NBIO: - if (c->nbio) - { - if (!BIO_socket_nbio(b->num,1)) - { - BIOerr(BIO_F_CONN_STATE,BIO_R_ERROR_SETTING_NBIO); - ERR_add_error_data(4,"host=", - c->param_hostname, - ":",c->param_port); + if (c->nbio) { + if (!BIO_socket_nbio(b->num, 1)) { + BIOerr(BIO_F_CONN_STATE, + BIO_R_ERROR_SETTING_NBIO); + ERR_add_error_data(4, "host=", + c->param_hostname, ":", + c->param_port); goto exit_loop; - } } - c->state=BIO_CONN_S_CONNECT; + } + c->state = BIO_CONN_S_CONNECT; #if defined(SO_KEEPALIVE) && !defined(OPENSSL_SYS_MPE) - i=1; - i=setsockopt(b->num,SOL_SOCKET,SO_KEEPALIVE,(char *)&i,sizeof(i)); - if (i < 0) - { - SYSerr(SYS_F_SOCKET,errno); - ERR_add_error_data(4,"host=",c->param_hostname, - ":",c->param_port); - BIOerr(BIO_F_CONN_STATE,BIO_R_KEEPALIVE); + i = 1; + i = setsockopt(b->num, SOL_SOCKET, SO_KEEPALIVE,(char *)&i, sizeof(i)); + if (i < 0) { + SYSerr(SYS_F_SOCKET, errno); + ERR_add_error_data(4, "host=", + c->param_hostname, ":", c->param_port); + BIOerr(BIO_F_CONN_STATE, BIO_R_KEEPALIVE); goto exit_loop; - } + } #endif break; case BIO_CONN_S_CONNECT: BIO_clear_retry_flags(b); - ret=connect(b->num, - (struct sockaddr *)&c->them, - sizeof(c->them)); - b->retry_reason=0; - if (ret < 0) - { - if (BIO_sock_should_retry(ret)) - { + ret = connect(b->num, + (struct sockaddr *)&c->them, + sizeof(c->them)); + b->retry_reason = 0; + if (ret < 0) { + if (BIO_sock_should_retry(ret)) { BIO_set_retry_special(b); - c->state=BIO_CONN_S_BLOCKED_CONNECT; - b->retry_reason=BIO_RR_CONNECT; - } - else - { - SYSerr(SYS_F_CONNECT,errno); - ERR_add_error_data(4,"host=", - c->param_hostname, - ":",c->param_port); - BIOerr(BIO_F_CONN_STATE,BIO_R_CONNECT_ERROR); - } - goto exit_loop; + c->state = BIO_CONN_S_BLOCKED_CONNECT; + b->retry_reason = BIO_RR_CONNECT; + } else { + SYSerr(SYS_F_CONNECT, errno); + ERR_add_error_data(4, "host=", + c->param_hostname, ":", + c->param_port); + BIOerr(BIO_F_CONN_STATE, + BIO_R_CONNECT_ERROR); } - else - c->state=BIO_CONN_S_OK; + goto exit_loop; + } else + c->state = BIO_CONN_S_OK; break; case BIO_CONN_S_BLOCKED_CONNECT: - i=BIO_sock_error(b->num); - if (i) - { + i = BIO_sock_error(b->num); + if (i) { BIO_clear_retry_flags(b); - SYSerr(SYS_F_CONNECT,i); - ERR_add_error_data(4,"host=", - c->param_hostname, - ":",c->param_port); - BIOerr(BIO_F_CONN_STATE,BIO_R_NBIO_CONNECT_ERROR); - ret=0; + SYSerr(SYS_F_CONNECT, i); + ERR_add_error_data(4, "host=", + c->param_hostname, ":", c->param_port); + BIOerr(BIO_F_CONN_STATE, + BIO_R_NBIO_CONNECT_ERROR); + ret = 0; goto exit_loop; - } - else - c->state=BIO_CONN_S_OK; + } else + c->state = BIO_CONN_S_OK; break; case BIO_CONN_S_OK: - ret=1; + ret = 1; goto exit_loop; default: /* abort(); */ goto exit_loop; - } + } - if (cb != NULL) - { - if (!(ret=cb((BIO *)b,c->state,ret))) + if (cb != NULL) { + if (!(ret = cb((BIO *)b, c->state, ret))) goto end; - } } + } /* Loop does not exit */ exit_loop: if (cb != NULL) - ret=cb((BIO *)b,c->state,ret); + ret = cb((BIO *)b, c->state, ret); end: - return(ret); - } + return (ret); +} -BIO_CONNECT *BIO_CONNECT_new(void) - { +BIO_CONNECT +*BIO_CONNECT_new(void) +{ BIO_CONNECT *ret; - if ((ret=(BIO_CONNECT *)OPENSSL_malloc(sizeof(BIO_CONNECT))) == NULL) - return(NULL); - ret->state=BIO_CONN_S_BEFORE; - ret->param_hostname=NULL; - ret->param_port=NULL; - ret->info_callback=NULL; - ret->nbio=0; - ret->ip[0]=0; - ret->ip[1]=0; - ret->ip[2]=0; - ret->ip[3]=0; - ret->port=0; - memset((char *)&ret->them,0,sizeof(ret->them)); - return(ret); - } - -void BIO_CONNECT_free(BIO_CONNECT *a) - { - if(a == NULL) - return; + if ((ret = (BIO_CONNECT *)OPENSSL_malloc(sizeof(BIO_CONNECT))) == NULL) + return (NULL); + ret->state = BIO_CONN_S_BEFORE; + ret->param_hostname = NULL; + ret->param_port = NULL; + ret->info_callback = NULL; + ret->nbio = 0; + ret->ip[0] = 0; + ret->ip[1] = 0; + ret->ip[2] = 0; + ret->ip[3] = 0; + ret->port = 0; + memset((char *)&ret->them, 0, sizeof(ret->them)); + return (ret); +} + +void +BIO_CONNECT_free(BIO_CONNECT *a) +{ + if (a == NULL) + return; if (a->param_hostname != NULL) OPENSSL_free(a->param_hostname); if (a->param_port != NULL) OPENSSL_free(a->param_port); OPENSSL_free(a); - } - -BIO_METHOD *BIO_s_connect(void) - { - return(&methods_connectp); - } - -static int conn_new(BIO *bi) - { - bi->init=0; - bi->num=-1; - bi->flags=0; - if ((bi->ptr=(char *)BIO_CONNECT_new()) == NULL) - return(0); +} + +BIO_METHOD +*BIO_s_connect(void) +{ + return (&methods_connectp); +} + +static int +conn_new(BIO *bi) +{ + bi->init = 0; + bi->num = -1; + bi->flags = 0; + if ((bi->ptr = (char *)BIO_CONNECT_new()) == NULL) + return (0); else - return(1); - } + return (1); +} -static void conn_close_socket(BIO *bio) - { +static void +conn_close_socket(BIO *bio) +{ BIO_CONNECT *c; - c=(BIO_CONNECT *)bio->ptr; - if (bio->num != -1) - { + c = (BIO_CONNECT *)bio->ptr; + if (bio->num != -1) { /* Only do a shutdown if things were established */ if (c->state == BIO_CONN_S_OK) shutdown(bio->num, SHUT_RDWR); close(bio->num); - bio->num=-1; - } + bio->num = -1; } +} -static int conn_free(BIO *a) - { +static int +conn_free(BIO *a) +{ BIO_CONNECT *data; - if (a == NULL) return(0); - data=(BIO_CONNECT *)a->ptr; - - if (a->shutdown) - { + if (a == NULL) + return (0); + data = (BIO_CONNECT *)a->ptr; + + if (a->shutdown) { conn_close_socket(a); BIO_CONNECT_free(data); - a->ptr=NULL; - a->flags=0; - a->init=0; - } - return(1); + a->ptr = NULL; + a->flags = 0; + a->init = 0; } - -static int conn_read(BIO *b, char *out, int outl) - { - int ret=0; + return (1); +} + +static int +conn_read(BIO *b, char *out, int outl) +{ + int ret = 0; BIO_CONNECT *data; - data=(BIO_CONNECT *)b->ptr; - if (data->state != BIO_CONN_S_OK) - { - ret=conn_state(b,data); + data = (BIO_CONNECT *)b->ptr; + if (data->state != BIO_CONN_S_OK) { + ret = conn_state(b, data); if (ret <= 0) - return(ret); - } + return (ret); + } - if (out != NULL) - { + if (out != NULL) { errno = 0; - ret=read(b->num,out,outl); + ret = read(b->num, out, outl); BIO_clear_retry_flags(b); - if (ret <= 0) - { + if (ret <= 0) { if (BIO_sock_should_retry(ret)) BIO_set_retry_read(b); - } } - return(ret); } + return (ret); +} -static int conn_write(BIO *b, const char *in, int inl) - { +static int +conn_write(BIO *b, const char *in, int inl) +{ int ret; BIO_CONNECT *data; - data=(BIO_CONNECT *)b->ptr; - if (data->state != BIO_CONN_S_OK) - { - ret=conn_state(b,data); - if (ret <= 0) return(ret); - } + data = (BIO_CONNECT *)b->ptr; + if (data->state != BIO_CONN_S_OK) { + ret = conn_state(b, data); + if (ret <= 0) + return (ret); + } errno = 0; - ret=write(b->num,in,inl); + ret = write(b->num, in, inl); BIO_clear_retry_flags(b); - if (ret <= 0) - { + if (ret <= 0) { if (BIO_sock_should_retry(ret)) BIO_set_retry_write(b); - } - return(ret); } + return (ret); +} -static long conn_ctrl(BIO *b, int cmd, long num, void *ptr) - { +static long +conn_ctrl(BIO *b, int cmd, long num, void *ptr) +{ BIO *dbio; int *ip; const char **pptr; - long ret=1; + long ret = 1; BIO_CONNECT *data; - data=(BIO_CONNECT *)b->ptr; + data = (BIO_CONNECT *)b->ptr; - switch (cmd) - { + switch (cmd) { case BIO_CTRL_RESET: - ret=0; - data->state=BIO_CONN_S_BEFORE; + ret = 0; + data->state = BIO_CONN_S_BEFORE; conn_close_socket(b); - b->flags=0; + b->flags = 0; break; case BIO_C_DO_STATE_MACHINE: /* use this one to start the connection */ if (data->state != BIO_CONN_S_OK) - ret=(long)conn_state(b,data); + ret = (long)conn_state(b, data); else - ret=1; + ret = 1; break; case BIO_C_GET_CONNECT: - if (ptr != NULL) - { - pptr=(const char **)ptr; - if (num == 0) - { - *pptr=data->param_hostname; - - } - else if (num == 1) - { - *pptr=data->param_port; - } - else if (num == 2) - { - *pptr= (char *)&(data->ip[0]); - } - else if (num == 3) - { - *((int *)ptr)=data->port; - } - if ((!b->init) || (ptr == NULL)) - *pptr="not initialized"; - ret=1; + if (ptr != NULL) { + pptr = (const char **)ptr; + if (num == 0) { + *pptr = data->param_hostname; + + } else if (num == 1) { + *pptr = data->param_port; + } else if (num == 2) { + *pptr = (char *)&(data->ip[0]); + } else if (num == 3) { + *((int *)ptr) = data->port; } + if ((!b->init) || (ptr == NULL)) + *pptr = "not initialized"; + ret = 1; + } break; case BIO_C_SET_CONNECT: - if (ptr != NULL) - { - b->init=1; - if (num == 0) - { + if (ptr != NULL) { + b->init = 1; + if (num == 0) { if (data->param_hostname != NULL) OPENSSL_free(data->param_hostname); - data->param_hostname=BUF_strdup(ptr); - } - else if (num == 1) - { + data->param_hostname = BUF_strdup(ptr); + } else if (num == 1) { if (data->param_port != NULL) OPENSSL_free(data->param_port); - data->param_port=BUF_strdup(ptr); - } - else if (num == 2) - { + data->param_port = BUF_strdup(ptr); + } else if (num == 2) { char buf[16]; unsigned char *p = ptr; - (void) snprintf(buf,sizeof buf,"%d.%d.%d.%d", - p[0],p[1],p[2],p[3]); + (void) snprintf(buf, sizeof buf, "%d.%d.%d.%d", + p[0], p[1], p[2], p[3]); if (data->param_hostname != NULL) OPENSSL_free(data->param_hostname); - data->param_hostname=BUF_strdup(buf); - memcpy(&(data->ip[0]),ptr,4); - } - else if (num == 3) - { - char buf[DECIMAL_SIZE(int)+1]; + data->param_hostname = BUF_strdup(buf); + memcpy(&(data->ip[0]), ptr, 4); + } else if (num == 3) { + char buf[DECIMAL_SIZE(int) + 1]; - (void) snprintf(buf,sizeof buf,"%d",*(int *)ptr); + (void) snprintf(buf, sizeof buf, "%d", + *(int *)ptr); if (data->param_port != NULL) OPENSSL_free(data->param_port); - data->param_port=BUF_strdup(buf); + data->param_port = BUF_strdup(buf); data->port= *(int *)ptr; - } } + } break; case BIO_C_SET_NBIO: - data->nbio=(int)num; + data->nbio = (int)num; break; case BIO_C_GET_FD: - if (b->init) - { - ip=(int *)ptr; + if (b->init) { + ip = (int *)ptr; if (ip != NULL) - *ip=b->num; - ret=b->num; - } - else - ret= -1; + *ip = b->num; + ret = b->num; + } else + ret = -1; break; case BIO_CTRL_GET_CLOSE: - ret=b->shutdown; + ret = b->shutdown; break; case BIO_CTRL_SET_CLOSE: - b->shutdown=(int)num; + b->shutdown = (int)num; break; case BIO_CTRL_PENDING: case BIO_CTRL_WPENDING: - ret=0; + ret = 0; break; case BIO_CTRL_FLUSH: break; case BIO_CTRL_DUP: { - dbio=(BIO *)ptr; - if (data->param_port) - BIO_set_conn_port(dbio,data->param_port); - if (data->param_hostname) - BIO_set_conn_hostname(dbio,data->param_hostname); - BIO_set_nbio(dbio,data->nbio); - /* FIXME: the cast of the function seems unlikely to be a good idea */ - (void)BIO_set_info_callback(dbio,(bio_info_cb *)data->info_callback); + dbio = (BIO *)ptr; + if (data->param_port) + BIO_set_conn_port(dbio, data->param_port); + if (data->param_hostname) + BIO_set_conn_hostname(dbio, + data->param_hostname); + BIO_set_nbio(dbio, data->nbio); + /* FIXME: the cast of the function seems unlikely to be a good idea */ + (void)BIO_set_info_callback(dbio, + (bio_info_cb *)data->info_callback); } break; case BIO_CTRL_SET_CALLBACK: { #if 0 /* FIXME: Should this be used? -- Richard Levitte */ - BIOerr(BIO_F_CONN_CTRL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED); - ret = -1; + BIOerr(BIO_F_CONN_CTRL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED); + ret = -1; #else - ret=0; + ret = 0; #endif } break; case BIO_CTRL_GET_CALLBACK: { - int (**fptr)(const BIO *bio,int state,int xret); + int (**fptr)(const BIO *bio, int state, int xret); - fptr=(int (**)(const BIO *bio,int state,int xret))ptr; - *fptr=data->info_callback; + fptr = (int (**)(const BIO *bio, int state, int xret))ptr; + *fptr = data->info_callback; } break; default: - ret=0; + ret = 0; break; - } - return(ret); } + return (ret); +} -static long conn_callback_ctrl(BIO *b, int cmd, bio_info_cb *fp) - { - long ret=1; +static long +conn_callback_ctrl(BIO *b, int cmd, bio_info_cb *fp) +{ + long ret = 1; BIO_CONNECT *data; - data=(BIO_CONNECT *)b->ptr; + data = (BIO_CONNECT *)b->ptr; - switch (cmd) - { + switch (cmd) { case BIO_CTRL_SET_CALLBACK: { - data->info_callback=(int (*)(const struct bio_st *, int, int))fp; + data->info_callback = (int (*)(const struct bio_st *, int, int))fp; } break; default: - ret=0; + ret = 0; break; - } - return(ret); } - -static int conn_puts(BIO *bp, const char *str) - { - int n,ret; - - n=strlen(str); - ret=conn_write(bp,str,n); - return(ret); - } - -BIO *BIO_new_connect(char *str) - { + return (ret); +} + +static int +conn_puts(BIO *bp, const char *str) +{ + int n, ret; + + n = strlen(str); + ret = conn_write(bp, str, n); + return (ret); +} + +BIO +*BIO_new_connect(char *str) +{ BIO *ret; - ret=BIO_new(BIO_s_connect()); - if (ret == NULL) return(NULL); - if (BIO_set_conn_hostname(ret,str)) - return(ret); - else - { + ret = BIO_new(BIO_s_connect()); + if (ret == NULL) + return (NULL); + if (BIO_set_conn_hostname(ret, str)) + return (ret); + else { BIO_free(ret); - return(NULL); - } + return (NULL); } +} #endif - diff --git a/src/lib/libssl/src/crypto/bio/bss_dgram.c b/src/lib/libssl/src/crypto/bio/bss_dgram.c index 67a13ae845..330f6fc404 100644 --- a/src/lib/libssl/src/crypto/bio/bss_dgram.c +++ b/src/lib/libssl/src/crypto/bio/bss_dgram.c @@ -113,7 +113,8 @@ static long dgram_sctp_ctrl(BIO *h, int cmd, long arg1, void *arg2); static int dgram_sctp_new(BIO *h); static int dgram_sctp_free(BIO *data); #ifdef SCTP_AUTHENTICATION_EVENT -static void dgram_sctp_handle_auth_free_key_event(BIO *b, union sctp_notification *snp); +static void dgram_sctp_handle_auth_free_key_event(BIO *b, + union sctp_notification *snp); #endif #endif @@ -121,8 +122,7 @@ static int BIO_dgram_should_retry(int s); static void get_current_time(struct timeval *t); -static BIO_METHOD methods_dgramp= - { +static BIO_METHOD methods_dgramp = { BIO_TYPE_DGRAM, "datagram socket", dgram_write, @@ -133,11 +133,10 @@ static BIO_METHOD methods_dgramp= dgram_new, dgram_free, NULL, - }; +}; #ifndef OPENSSL_NO_SCTP -static BIO_METHOD methods_dgramp_sctp= - { +static BIO_METHOD methods_dgramp_sctp = { BIO_TYPE_DGRAM_SCTP, "datagram sctp socket", dgram_sctp_write, @@ -148,11 +147,10 @@ static BIO_METHOD methods_dgramp_sctp= dgram_sctp_new, dgram_sctp_free, NULL, - }; +}; #endif -typedef struct bio_dgram_data_st - { +typedef struct bio_dgram_data_st { union { struct sockaddr sa; struct sockaddr_in sa_in; @@ -165,18 +163,16 @@ typedef struct bio_dgram_data_st unsigned int mtu; struct timeval next_timeout; struct timeval socket_timeout; - } bio_dgram_data; +} bio_dgram_data; #ifndef OPENSSL_NO_SCTP -typedef struct bio_dgram_sctp_save_message_st - { - BIO *bio; - char *data; - int length; - } bio_dgram_sctp_save_message; +typedef struct bio_dgram_sctp_save_message_st { + BIO *bio; + char *data; + int length; +} bio_dgram_sctp_save_message; -typedef struct bio_dgram_sctp_data_st - { +typedef struct bio_dgram_sctp_data_st { union { struct sockaddr sa; struct sockaddr_in sa_in; @@ -198,79 +194,88 @@ typedef struct bio_dgram_sctp_data_st int save_shutdown; int peer_auth_tested; bio_dgram_sctp_save_message saved_message; - } bio_dgram_sctp_data; +} bio_dgram_sctp_data; #endif -BIO_METHOD *BIO_s_datagram(void) - { - return(&methods_dgramp); - } +BIO_METHOD +*BIO_s_datagram(void) +{ + return (&methods_dgramp); +} -BIO *BIO_new_dgram(int fd, int close_flag) - { +BIO +*BIO_new_dgram(int fd, int close_flag) +{ BIO *ret; - ret=BIO_new(BIO_s_datagram()); - if (ret == NULL) return(NULL); - BIO_set_fd(ret,fd,close_flag); - return(ret); - } + ret = BIO_new(BIO_s_datagram()); + if (ret == NULL) + return (NULL); + BIO_set_fd(ret, fd, close_flag); + return (ret); +} -static int dgram_new(BIO *bi) - { +static int +dgram_new(BIO *bi) +{ bio_dgram_data *data = NULL; - bi->init=0; - bi->num=0; + bi->init = 0; + bi->num = 0; data = OPENSSL_malloc(sizeof(bio_dgram_data)); if (data == NULL) return 0; memset(data, 0x00, sizeof(bio_dgram_data)); - bi->ptr = data; + bi->ptr = data; - bi->flags=0; - return(1); - } + bi->flags = 0; + return (1); +} -static int dgram_free(BIO *a) - { +static int +dgram_free(BIO *a) +{ bio_dgram_data *data; - if (a == NULL) return(0); - if ( ! dgram_clear(a)) + if (a == NULL) + return (0); + if (!dgram_clear(a)) return 0; data = (bio_dgram_data *)a->ptr; - if(data != NULL) OPENSSL_free(data); + if (data != NULL) + OPENSSL_free(data); - return(1); - } + return (1); +} -static int dgram_clear(BIO *a) - { - if (a == NULL) return(0); - if (a->shutdown) - { - if (a->init) - { +static int +dgram_clear(BIO *a) +{ + if (a == NULL) + return (0); + if (a->shutdown) { + if (a->init) { shutdown(a->num, SHUT_RDWR); close(a->num); - } - a->init=0; - a->flags=0; } - return(1); + a->init = 0; + a->flags = 0; } + return (1); +} -static void dgram_adjust_rcv_timeout(BIO *b) - { +static void +dgram_adjust_rcv_timeout(BIO *b) +{ #if defined(SO_RCVTIMEO) bio_dgram_data *data = (bio_dgram_data *)b->ptr; - union { size_t s; int i; } sz = {0}; + union { size_t s; + int i; + } sz = {0}; /* Is a timer active? */ - if (data->next_timeout.tv_sec > 0 || data->next_timeout.tv_usec > 0) - { + if (data->next_timeout.tv_sec > 0 || data->next_timeout.tv_usec > 0) { struct timeval timenow, timeleft; /* Read current socket timeout */ @@ -279,20 +284,19 @@ static void dgram_adjust_rcv_timeout(BIO *b) sz.i = sizeof(timeout); if (getsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO, - (void*)&timeout, &sz.i) < 0) - { perror("getsockopt"); } - else - { + (void*)&timeout, &sz.i) < 0) { + perror("getsockopt"); + } else { data->socket_timeout.tv_sec = timeout / 1000; data->socket_timeout.tv_usec = (timeout % 1000) * 1000; - } + } #else sz.i = sizeof(data->socket_timeout); - if ( getsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO, - &(data->socket_timeout), (void *)&sz) < 0) - { perror("getsockopt"); } - else if (sizeof(sz.s)!=sizeof(sz.i) && sz.i==0) - OPENSSL_assert(sz.s<=sizeof(data->socket_timeout)); + if (getsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO, + &(data->socket_timeout), (void *)&sz) < 0) { + perror("getsockopt"); + } else if (sizeof(sz.s) != sizeof(sz.i) && sz.i == 0) + OPENSSL_assert(sz.s <= sizeof(data->socket_timeout)); #endif /* Get current time */ @@ -302,126 +306,128 @@ static void dgram_adjust_rcv_timeout(BIO *b) memcpy(&timeleft, &(data->next_timeout), sizeof(struct timeval)); timeleft.tv_sec -= timenow.tv_sec; timeleft.tv_usec -= timenow.tv_usec; - if (timeleft.tv_usec < 0) - { + if (timeleft.tv_usec < 0) { timeleft.tv_sec--; timeleft.tv_usec += 1000000; - } + } - if (timeleft.tv_sec < 0) - { + if (timeleft.tv_sec < 0) { timeleft.tv_sec = 0; timeleft.tv_usec = 1; - } + } /* Adjust socket timeout if next handhake message timer * will expire earlier. */ - if ((data->socket_timeout.tv_sec == 0 && data->socket_timeout.tv_usec == 0) || - (data->socket_timeout.tv_sec > timeleft.tv_sec) || - (data->socket_timeout.tv_sec == timeleft.tv_sec && - data->socket_timeout.tv_usec >= timeleft.tv_usec)) - { + if ((data->socket_timeout.tv_sec == 0 && + data->socket_timeout.tv_usec == 0) || + (data->socket_timeout.tv_sec > timeleft.tv_sec) || + (data->socket_timeout.tv_sec == timeleft.tv_sec && + data->socket_timeout.tv_usec >= timeleft.tv_usec)) { #ifdef OPENSSL_SYS_WINDOWS timeout = timeleft.tv_sec * 1000 + timeleft.tv_usec / 1000; if (setsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO, - (void*)&timeout, sizeof(timeout)) < 0) - { perror("setsockopt"); } + (void*)&timeout, sizeof(timeout)) < 0) { + perror("setsockopt"); + } #else - if ( setsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO, &timeleft, - sizeof(struct timeval)) < 0) - { perror("setsockopt"); } -#endif + if (setsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO, + &timeleft, sizeof(struct timeval)) < 0) { + perror("setsockopt"); } - } #endif + } } +#endif +} -static void dgram_reset_rcv_timeout(BIO *b) - { +static void +dgram_reset_rcv_timeout(BIO *b) +{ #if defined(SO_RCVTIMEO) bio_dgram_data *data = (bio_dgram_data *)b->ptr; /* Is a timer active? */ - if (data->next_timeout.tv_sec > 0 || data->next_timeout.tv_usec > 0) - { + if (data->next_timeout.tv_sec > 0 || data->next_timeout.tv_usec > 0) { #ifdef OPENSSL_SYS_WINDOWS int timeout = data->socket_timeout.tv_sec * 1000 + - data->socket_timeout.tv_usec / 1000; + data->socket_timeout.tv_usec / 1000; if (setsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO, - (void*)&timeout, sizeof(timeout)) < 0) - { perror("setsockopt"); } + (void*)&timeout, sizeof(timeout)) < 0) { + perror("setsockopt"); + } #else - if ( setsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO, &(data->socket_timeout), - sizeof(struct timeval)) < 0) - { perror("setsockopt"); } -#endif + if (setsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO, + &(data->socket_timeout), sizeof(struct timeval)) < 0) { + perror("setsockopt"); } #endif } +#endif +} -static int dgram_read(BIO *b, char *out, int outl) - { - int ret=0; +static int +dgram_read(BIO *b, char *out, int outl) +{ + int ret = 0; bio_dgram_data *data = (bio_dgram_data *)b->ptr; struct { - /* - * See commentary in b_sock.c. - */ - union { size_t s; int i; } len; - union { - struct sockaddr sa; - struct sockaddr_in sa_in; + /* + * See commentary in b_sock.c. + */ + union { + size_t s; + int i; + } len; + union { + struct sockaddr sa; + struct sockaddr_in sa_in; #if OPENSSL_USE_IPV6 - struct sockaddr_in6 sa_in6; + struct sockaddr_in6 sa_in6; #endif } peer; } sa; - sa.len.s=0; - sa.len.i=sizeof(sa.peer); + sa.len.s = 0; + sa.len.i = sizeof(sa.peer); - if (out != NULL) - { + if (out != NULL) { errno = 0; memset(&sa.peer, 0x00, sizeof(sa.peer)); dgram_adjust_rcv_timeout(b); - ret=recvfrom(b->num,out,outl,0,&sa.peer.sa,(void *)&sa.len); - if (sizeof(sa.len.i)!=sizeof(sa.len.s) && sa.len.i==0) - { - OPENSSL_assert(sa.len.s<=sizeof(sa.peer)); + ret = recvfrom(b->num, out, outl, 0, &sa.peer.sa,(void *)&sa.len); + if (sizeof(sa.len.i) != sizeof(sa.len.s) && sa.len.i == 0) { + OPENSSL_assert(sa.len.s <= sizeof(sa.peer)); sa.len.i = (int)sa.len.s; - } + } - if ( ! data->connected && ret >= 0) + if (! data->connected && ret >= 0) BIO_ctrl(b, BIO_CTRL_DGRAM_SET_PEER, 0, &sa.peer); BIO_clear_retry_flags(b); - if (ret < 0) - { - if (BIO_dgram_should_retry(ret)) - { + if (ret < 0) { + if (BIO_dgram_should_retry(ret)) { BIO_set_retry_read(b); data->_errno = errno; - } } + } dgram_reset_rcv_timeout(b); - } - return(ret); } + return (ret); +} -static int dgram_write(BIO *b, const char *in, int inl) - { +static int +dgram_write(BIO *b, const char *in, int inl) +{ int ret; bio_dgram_data *data = (bio_dgram_data *)b->ptr; errno = 0; - if ( data->connected ) - ret=write(b->num,in,inl); - else - { + if (data->connected) + ret = write(b->num, in, inl); + else { int peerlen = sizeof(data->peer); if (data->peer.sa.sa_family == AF_INET) @@ -431,33 +437,33 @@ static int dgram_write(BIO *b, const char *in, int inl) peerlen = sizeof(data->peer.sa_in6); #endif #if defined(NETWARE_CLIB) && defined(NETWARE_BSDSOCK) - ret=sendto(b->num, (char *)in, inl, 0, &data->peer.sa, peerlen); + ret = sendto(b->num, (char *)in, inl, 0, &data->peer.sa, peerlen); #else - ret=sendto(b->num, in, inl, 0, &data->peer.sa, peerlen); + ret = sendto(b->num, in, inl, 0, &data->peer.sa, peerlen); #endif - } + } BIO_clear_retry_flags(b); - if (ret <= 0) - { - if (BIO_dgram_should_retry(ret)) - { - BIO_set_retry_write(b); + if (ret <= 0) { + if (BIO_dgram_should_retry(ret)) { + BIO_set_retry_write(b); + data->_errno = errno; #if 0 /* higher layers are responsible for querying MTU, if necessary */ - if ( data->_errno == EMSGSIZE) + if (data->_errno == EMSGSIZE) /* retrieve the new MTU */ - BIO_ctrl(b, BIO_CTRL_DGRAM_QUERY_MTU, 0, NULL); + BIO_ctrl(b, BIO_CTRL_DGRAM_QUERY_MTU, 0, NULL); #endif - } } - return(ret); } + return (ret); +} -static long dgram_ctrl(BIO *b, int cmd, long num, void *ptr) - { - long ret=1; +static long +dgram_ctrl(BIO *b, int cmd, long num, void *ptr) +{ + long ret = 1; int *ip; struct sockaddr *to = NULL; bio_dgram_data *data = NULL; @@ -472,76 +478,73 @@ static long dgram_ctrl(BIO *b, int cmd, long num, void *ptr) #if OPENSSL_USE_IPV6 struct sockaddr_in6 s6; #endif - } addr; + } addr; #endif data = (bio_dgram_data *)b->ptr; - switch (cmd) - { + switch (cmd) { case BIO_CTRL_RESET: - num=0; + num = 0; case BIO_C_FILE_SEEK: - ret=0; + ret = 0; break; case BIO_C_FILE_TELL: case BIO_CTRL_INFO: - ret=0; + ret = 0; break; case BIO_C_SET_FD: dgram_clear(b); b->num= *((int *)ptr); - b->shutdown=(int)num; - b->init=1; + b->shutdown = (int)num; + b->init = 1; break; case BIO_C_GET_FD: - if (b->init) - { - ip=(int *)ptr; - if (ip != NULL) *ip=b->num; - ret=b->num; - } - else - ret= -1; + if (b->init) { + ip = (int *)ptr; + if (ip != NULL) + *ip = b->num; + ret = b->num; + } else + ret = -1; break; case BIO_CTRL_GET_CLOSE: - ret=b->shutdown; + ret = b->shutdown; break; case BIO_CTRL_SET_CLOSE: - b->shutdown=(int)num; + b->shutdown = (int)num; break; case BIO_CTRL_PENDING: case BIO_CTRL_WPENDING: - ret=0; + ret = 0; break; case BIO_CTRL_DUP: case BIO_CTRL_FLUSH: - ret=1; + ret = 1; break; case BIO_CTRL_DGRAM_CONNECT: to = (struct sockaddr *)ptr; #if 0 - if (connect(b->num, to, sizeof(struct sockaddr)) < 0) - { perror("connect"); ret = 0; } - else - { + if (connect(b->num, to, sizeof(struct sockaddr)) < 0) { + perror("connect"); + ret = 0; + } else { #endif - switch (to->sa_family) - { - case AF_INET: - memcpy(&data->peer,to,sizeof(data->peer.sa_in)); - break; + switch (to->sa_family) { + case AF_INET: + memcpy(&data->peer, to, sizeof(data->peer.sa_in)); + break; #if OPENSSL_USE_IPV6 - case AF_INET6: - memcpy(&data->peer,to,sizeof(data->peer.sa_in6)); - break; + case AF_INET6: + memcpy(&data->peer, to, sizeof(data->peer.sa_in6)); + break; #endif - default: - memcpy(&data->peer,to,sizeof(data->peer.sa)); - break; - } -#if 0 + default: + memcpy(&data->peer, to, sizeof(data->peer.sa)); + break; } +#if 0 + } #endif break; /* (Linux)kernel sets DF bit on outgoing IP packets */ @@ -549,31 +552,31 @@ static long dgram_ctrl(BIO *b, int cmd, long num, void *ptr) #if defined(OPENSSL_SYS_LINUX) && defined(IP_MTU_DISCOVER) && defined(IP_PMTUDISC_DO) addr_len = (socklen_t)sizeof(addr); memset((void *)&addr, 0, sizeof(addr)); - if (getsockname(b->num, &addr.sa, &addr_len) < 0) - { + if (getsockname(b->num, &addr.sa, &addr_len) < 0) { ret = 0; break; - } - switch (addr.sa.sa_family) - { + } + switch (addr.sa.sa_family) { case AF_INET: sockopt_val = IP_PMTUDISC_DO; - if ((ret = setsockopt(b->num, IPPROTO_IP, IP_MTU_DISCOVER, - &sockopt_val, sizeof(sockopt_val))) < 0) + if ((ret = setsockopt(b->num, IPPROTO_IP, + IP_MTU_DISCOVER, &sockopt_val, + sizeof(sockopt_val))) < 0) perror("setsockopt"); break; #if OPENSSL_USE_IPV6 && defined(IPV6_MTU_DISCOVER) && defined(IPV6_PMTUDISC_DO) case AF_INET6: sockopt_val = IPV6_PMTUDISC_DO; - if ((ret = setsockopt(b->num, IPPROTO_IPV6, IPV6_MTU_DISCOVER, - &sockopt_val, sizeof(sockopt_val))) < 0) + if ((ret = setsockopt(b->num, IPPROTO_IPV6, + IPV6_MTU_DISCOVER, &sockopt_val, + sizeof(sockopt_val))) < 0) perror("setsockopt"); break; #endif default: ret = -1; break; - } + } ret = -1; #else break; @@ -582,74 +585,67 @@ static long dgram_ctrl(BIO *b, int cmd, long num, void *ptr) #if defined(OPENSSL_SYS_LINUX) && defined(IP_MTU) addr_len = (socklen_t)sizeof(addr); memset((void *)&addr, 0, sizeof(addr)); - if (getsockname(b->num, &addr.sa, &addr_len) < 0) - { + if (getsockname(b->num, &addr.sa, &addr_len) < 0) { ret = 0; break; - } + } sockopt_len = sizeof(sockopt_val); - switch (addr.sa.sa_family) - { + switch (addr.sa.sa_family) { case AF_INET: - if ((ret = getsockopt(b->num, IPPROTO_IP, IP_MTU, (void *)&sockopt_val, - &sockopt_len)) < 0 || sockopt_val < 0) - { + if ((ret = getsockopt(b->num, IPPROTO_IP, IP_MTU, + (void *)&sockopt_val, &sockopt_len)) < 0 || + sockopt_val < 0) { ret = 0; - } - else - { + } else { /* we assume that the transport protocol is UDP and no * IP options are used. */ data->mtu = sockopt_val - 8 - 20; ret = data->mtu; - } + } break; #if OPENSSL_USE_IPV6 && defined(IPV6_MTU) case AF_INET6: - if ((ret = getsockopt(b->num, IPPROTO_IPV6, IPV6_MTU, (void *)&sockopt_val, - &sockopt_len)) < 0 || sockopt_val < 0) - { + if ((ret = getsockopt(b->num, IPPROTO_IPV6, IPV6_MTU, + (void *)&sockopt_val, &sockopt_len)) < 0 || + sockopt_val < 0) { ret = 0; - } - else - { + } else { /* we assume that the transport protocol is UDP and no * IPV6 options are used. */ data->mtu = sockopt_val - 8 - 40; ret = data->mtu; - } + } break; #endif - default: +default: ret = 0; break; - } + } #else ret = 0; #endif break; case BIO_CTRL_DGRAM_GET_FALLBACK_MTU: - switch (data->peer.sa.sa_family) - { - case AF_INET: - ret = 576 - 20 - 8; - break; + switch (data->peer.sa.sa_family) { + case AF_INET: + ret = 576 - 20 - 8; + break; #if OPENSSL_USE_IPV6 - case AF_INET6: + case AF_INET6: #ifdef IN6_IS_ADDR_V4MAPPED - if (IN6_IS_ADDR_V4MAPPED(&data->peer.sa_in6.sin6_addr)) - ret = 576 - 20 - 8; - else + if (IN6_IS_ADDR_V4MAPPED(&data->peer.sa_in6.sin6_addr)) + ret = 576 - 20 - 8; + else #endif - ret = 1280 - 40 - 8; - break; + ret = 1280 - 40 - 8; + break; #endif - default: - ret = 576 - 20 - 8; - break; - } + default: + ret = 576 - 20 - 8; + break; + } break; case BIO_CTRL_DGRAM_GET_MTU: return data->mtu; @@ -661,65 +657,59 @@ static long dgram_ctrl(BIO *b, int cmd, long num, void *ptr) case BIO_CTRL_DGRAM_SET_CONNECTED: to = (struct sockaddr *)ptr; - if ( to != NULL) - { + if (to != NULL) { data->connected = 1; - switch (to->sa_family) - { - case AF_INET: - memcpy(&data->peer,to,sizeof(data->peer.sa_in)); - break; -#if OPENSSL_USE_IPV6 - case AF_INET6: - memcpy(&data->peer,to,sizeof(data->peer.sa_in6)); - break; -#endif - default: - memcpy(&data->peer,to,sizeof(data->peer.sa)); - break; - } - } - else - { - data->connected = 0; - memset(&(data->peer), 0x00, sizeof(data->peer)); - } - break; - case BIO_CTRL_DGRAM_GET_PEER: - switch (data->peer.sa.sa_family) - { + switch (to->sa_family) { case AF_INET: - ret=sizeof(data->peer.sa_in); + memcpy(&data->peer, to, sizeof(data->peer.sa_in)); break; #if OPENSSL_USE_IPV6 case AF_INET6: - ret=sizeof(data->peer.sa_in6); + memcpy(&data->peer, to, sizeof(data->peer.sa_in6)); break; #endif default: - ret=sizeof(data->peer.sa); + memcpy(&data->peer, to, sizeof(data->peer.sa)); break; } - if (num==0 || num>ret) - num=ret; - memcpy(ptr,&data->peer,(ret=num)); + } else { + data->connected = 0; + memset(&(data->peer), 0x00, sizeof(data->peer)); + } + break; + case BIO_CTRL_DGRAM_GET_PEER: + switch (data->peer.sa.sa_family) { + case AF_INET: + ret = sizeof(data->peer.sa_in); + break; +#if OPENSSL_USE_IPV6 + case AF_INET6: + ret = sizeof(data->peer.sa_in6); + break; +#endif + default: + ret = sizeof(data->peer.sa); + break; + } + if (num == 0 || num > ret) + num = ret; + memcpy(ptr, &data->peer, (ret = num)); break; case BIO_CTRL_DGRAM_SET_PEER: to = (struct sockaddr *) ptr; - switch (to->sa_family) - { - case AF_INET: - memcpy(&data->peer,to,sizeof(data->peer.sa_in)); - break; + switch (to->sa_family) { + case AF_INET: + memcpy(&data->peer, to, sizeof(data->peer.sa_in)); + break; #if OPENSSL_USE_IPV6 - case AF_INET6: - memcpy(&data->peer,to,sizeof(data->peer.sa_in6)); - break; + case AF_INET6: + memcpy(&data->peer, to, sizeof(data->peer.sa_in6)); + break; #endif - default: - memcpy(&data->peer,to,sizeof(data->peer.sa)); - break; - } + default: + memcpy(&data->peer, to, sizeof(data->peer.sa)); + break; + } break; case BIO_CTRL_DGRAM_SET_NEXT_TIMEOUT: memcpy(&(data->next_timeout), ptr, sizeof(struct timeval)); @@ -728,47 +718,53 @@ static long dgram_ctrl(BIO *b, int cmd, long num, void *ptr) case BIO_CTRL_DGRAM_SET_RECV_TIMEOUT: #ifdef OPENSSL_SYS_WINDOWS { - struct timeval *tv = (struct timeval *)ptr; - int timeout = tv->tv_sec * 1000 + tv->tv_usec/1000; - if (setsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO, - (void*)&timeout, sizeof(timeout)) < 0) - { perror("setsockopt"); ret = -1; } + struct timeval *tv = (struct timeval *)ptr; + int timeout = tv->tv_sec * 1000 + tv->tv_usec/1000; + if (setsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO, + (void*)&timeout, sizeof(timeout)) < 0) { + perror("setsockopt"); + ret = -1; + } } #else - if ( setsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO, ptr, - sizeof(struct timeval)) < 0) - { perror("setsockopt"); ret = -1; } + if (setsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO, ptr, + sizeof(struct timeval)) < 0) { + perror("setsockopt"); + ret = -1; + } #endif break; case BIO_CTRL_DGRAM_GET_RECV_TIMEOUT: { - union { size_t s; int i; } sz = {0}; + union { + size_t s; + int i; + } sz = {0}; #ifdef OPENSSL_SYS_WINDOWS - int timeout; - struct timeval *tv = (struct timeval *)ptr; - - sz.i = sizeof(timeout); - if (getsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO, - (void*)&timeout, &sz.i) < 0) - { perror("getsockopt"); ret = -1; } - else - { - tv->tv_sec = timeout / 1000; - tv->tv_usec = (timeout % 1000) * 1000; - ret = sizeof(*tv); + int timeout; + struct timeval *tv = (struct timeval *)ptr; + + sz.i = sizeof(timeout); + if (getsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO, + (void*)&timeout, &sz.i) < 0) { + perror("getsockopt"); + ret = -1; + } else { + tv->tv_sec = timeout / 1000; + tv->tv_usec = (timeout % 1000) * 1000; + ret = sizeof(*tv); } #else - sz.i = sizeof(struct timeval); - if ( getsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO, - ptr, (void *)&sz) < 0) - { perror("getsockopt"); ret = -1; } - else if (sizeof(sz.s)!=sizeof(sz.i) && sz.i==0) - { - OPENSSL_assert(sz.s<=sizeof(struct timeval)); - ret = (int)sz.s; - } - else - ret = sz.i; + sz.i = sizeof(struct timeval); + if (getsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO, + ptr, (void *)&sz) < 0) { + perror("getsockopt"); + ret = -1; + } else if (sizeof(sz.s)!=sizeof(sz.i) && sz.i==0) { + OPENSSL_assert(sz.s <= sizeof(struct timeval)); + ret = (int)sz.s; + } else + ret = sz.i; #endif } break; @@ -777,47 +773,53 @@ static long dgram_ctrl(BIO *b, int cmd, long num, void *ptr) case BIO_CTRL_DGRAM_SET_SEND_TIMEOUT: #ifdef OPENSSL_SYS_WINDOWS { - struct timeval *tv = (struct timeval *)ptr; - int timeout = tv->tv_sec * 1000 + tv->tv_usec/1000; - if (setsockopt(b->num, SOL_SOCKET, SO_SNDTIMEO, - (void*)&timeout, sizeof(timeout)) < 0) - { perror("setsockopt"); ret = -1; } + struct timeval *tv = (struct timeval *)ptr; + int timeout = tv->tv_sec * 1000 + tv->tv_usec/1000; + if (setsockopt(b->num, SOL_SOCKET, SO_SNDTIMEO, + (void*)&timeout, sizeof(timeout)) < 0) { + perror("setsockopt"); + ret = -1; + } } #else - if ( setsockopt(b->num, SOL_SOCKET, SO_SNDTIMEO, ptr, - sizeof(struct timeval)) < 0) - { perror("setsockopt"); ret = -1; } + if (setsockopt(b->num, SOL_SOCKET, SO_SNDTIMEO, ptr, + sizeof(struct timeval)) < 0) { + perror("setsockopt"); + ret = -1; + } #endif break; case BIO_CTRL_DGRAM_GET_SEND_TIMEOUT: { - union { size_t s; int i; } sz = {0}; + union { + size_t s; + int i; + } sz = {0}; #ifdef OPENSSL_SYS_WINDOWS - int timeout; - struct timeval *tv = (struct timeval *)ptr; - - sz.i = sizeof(timeout); - if (getsockopt(b->num, SOL_SOCKET, SO_SNDTIMEO, - (void*)&timeout, &sz.i) < 0) - { perror("getsockopt"); ret = -1; } - else - { - tv->tv_sec = timeout / 1000; - tv->tv_usec = (timeout % 1000) * 1000; - ret = sizeof(*tv); + int timeout; + struct timeval *tv = (struct timeval *)ptr; + + sz.i = sizeof(timeout); + if (getsockopt(b->num, SOL_SOCKET, SO_SNDTIMEO, + (void*)&timeout, &sz.i) < 0) { + perror("getsockopt"); + ret = -1; + } else { + tv->tv_sec = timeout / 1000; + tv->tv_usec = (timeout % 1000) * 1000; + ret = sizeof(*tv); } #else - sz.i = sizeof(struct timeval); - if ( getsockopt(b->num, SOL_SOCKET, SO_SNDTIMEO, - ptr, (void *)&sz) < 0) - { perror("getsockopt"); ret = -1; } - else if (sizeof(sz.s)!=sizeof(sz.i) && sz.i==0) - { - OPENSSL_assert(sz.s<=sizeof(struct timeval)); - ret = (int)sz.s; - } - else - ret = sz.i; + sz.i = sizeof(struct timeval); + if (getsockopt(b->num, SOL_SOCKET, SO_SNDTIMEO, + ptr, (void *)&sz) < 0) { + perror("getsockopt"); + ret = -1; + } else if (sizeof(sz.s) != sizeof(sz.i) && sz.i == 0) { + OPENSSL_assert(sz.s <= sizeof(struct timeval)); + ret = (int)sz.s; + } else + ret = sz.i; #endif } break; @@ -826,52 +828,52 @@ static long dgram_ctrl(BIO *b, int cmd, long num, void *ptr) /* fall-through */ case BIO_CTRL_DGRAM_GET_RECV_TIMER_EXP: #ifdef OPENSSL_SYS_WINDOWS - if ( data->_errno == WSAETIMEDOUT) + if (data->_errno == WSAETIMEDOUT) #else - if ( data->_errno == EAGAIN) + if (data->_errno == EAGAIN) #endif - { + { ret = 1; data->_errno = 0; - } - else + } else ret = 0; break; #ifdef EMSGSIZE case BIO_CTRL_DGRAM_MTU_EXCEEDED: - if ( data->_errno == EMSGSIZE) - { + if (data->_errno == EMSGSIZE) { ret = 1; data->_errno = 0; - } - else + } else ret = 0; break; #endif default: - ret=0; + ret = 0; break; - } - return(ret); } + return (ret); +} -static int dgram_puts(BIO *bp, const char *str) - { - int n,ret; +static int +dgram_puts(BIO *bp, const char *str) +{ + int n, ret; - n=strlen(str); - ret=dgram_write(bp,str,n); - return(ret); - } + n = strlen(str); + ret = dgram_write(bp, str, n); + return (ret); +} #ifndef OPENSSL_NO_SCTP -BIO_METHOD *BIO_s_datagram_sctp(void) - { - return(&methods_dgramp_sctp); - } +BIO_METHOD +*BIO_s_datagram_sctp(void) +{ + return (&methods_dgramp_sctp); +} -BIO *BIO_new_dgram_sctp(int fd, int close_flag) - { +BIO +*BIO_new_dgram_sctp(int fd, int close_flag) +{ BIO *bio; int ret, optval = 20000; int auth_data = 0, auth_forward = 0; @@ -887,9 +889,10 @@ BIO *BIO_new_dgram_sctp(int fd, int close_flag) #endif #endif - bio=BIO_new(BIO_s_datagram_sctp()); - if (bio == NULL) return(NULL); - BIO_set_fd(bio,fd,close_flag); + bio = BIO_new(BIO_s_datagram_sctp()); + if (bio == NULL) + return (NULL); + BIO_set_fd(bio, fd, close_flag); /* Activate SCTP-AUTH for DATA and FORWARD-TSN chunks */ auth.sauth_chunk = OPENSSL_SCTP_DATA_CHUNK_TYPE; @@ -909,13 +912,14 @@ BIO *BIO_new_dgram_sctp(int fd, int close_flag) OPENSSL_assert(ret >= 0); for (p = (unsigned char*) authchunks->gauth_chunks; - p < (unsigned char*) authchunks + sockopt_len; - p += sizeof(uint8_t)) - { - if (*p == OPENSSL_SCTP_DATA_CHUNK_TYPE) auth_data = 1; - if (*p == OPENSSL_SCTP_FORWARD_CUM_TSN_CHUNK_TYPE) auth_forward = 1; - } - + p < (unsigned char*) authchunks + sockopt_len; + p += sizeof(uint8_t)) { + if (*p == OPENSSL_SCTP_DATA_CHUNK_TYPE) + auth_data = 1; + if (*p == OPENSSL_SCTP_FORWARD_CUM_TSN_CHUNK_TYPE) + auth_forward = 1; + } + OPENSSL_free(authchunks); OPENSSL_assert(auth_data); @@ -947,20 +951,22 @@ BIO *BIO_new_dgram_sctp(int fd, int close_flag) ret = setsockopt(fd, IPPROTO_SCTP, SCTP_PARTIAL_DELIVERY_POINT, &optval, sizeof(optval)); OPENSSL_assert(ret >= 0); - return(bio); - } + return (bio); +} -int BIO_dgram_is_sctp(BIO *bio) - { +int +BIO_dgram_is_sctp(BIO *bio) +{ return (BIO_method_type(bio) == BIO_TYPE_DGRAM_SCTP); - } +} -static int dgram_sctp_new(BIO *bi) - { +static int +dgram_sctp_new(BIO *bi) +{ bio_dgram_sctp_data *data = NULL; - bi->init=0; - bi->num=0; + bi->init = 0; + bi->num = 0; data = OPENSSL_malloc(sizeof(bio_dgram_sctp_data)); if (data == NULL) return 0; @@ -968,46 +974,50 @@ static int dgram_sctp_new(BIO *bi) #ifdef SCTP_PR_SCTP_NONE data->prinfo.pr_policy = SCTP_PR_SCTP_NONE; #endif - bi->ptr = data; + bi->ptr = data; - bi->flags=0; - return(1); - } + bi->flags = 0; + return (1); +} -static int dgram_sctp_free(BIO *a) - { +static int +dgram_sctp_free(BIO *a) +{ bio_dgram_sctp_data *data; - if (a == NULL) return(0); - if ( ! dgram_clear(a)) + if (a == NULL) + return (0); + if (! dgram_clear(a)) return 0; data = (bio_dgram_sctp_data *)a->ptr; - if(data != NULL) OPENSSL_free(data); + if (data != NULL) + OPENSSL_free(data); - return(1); - } + return (1); +} #ifdef SCTP_AUTHENTICATION_EVENT -void dgram_sctp_handle_auth_free_key_event(BIO *b, union sctp_notification *snp) - { +void +dgram_sctp_handle_auth_free_key_event(BIO *b, union sctp_notification *snp) +{ int ret; struct sctp_authkey_event* authkeyevent = &snp->sn_auth_event; - if (authkeyevent->auth_indication == SCTP_AUTH_FREE_KEY) - { + if (authkeyevent->auth_indication == SCTP_AUTH_FREE_KEY) { struct sctp_authkeyid authkeyid; /* delete key */ authkeyid.scact_keynumber = authkeyevent->auth_keynumber; ret = setsockopt(b->num, IPPROTO_SCTP, SCTP_AUTH_DELETE_KEY, - &authkeyid, sizeof(struct sctp_authkeyid)); - } + &authkeyid, sizeof(struct sctp_authkeyid)); } +} #endif -static int dgram_sctp_read(BIO *b, char *out, int outl) - { +static int +dgram_sctp_read(BIO *b, char *out, int outl) +{ int ret = 0, n = 0, i, optval; socklen_t optlen; bio_dgram_sctp_data *data = (bio_dgram_sctp_data *)b->ptr; @@ -1017,12 +1027,10 @@ static int dgram_sctp_read(BIO *b, char *out, int outl) struct cmsghdr *cmsg; char cmsgbuf[512]; - if (out != NULL) - { + if (out != NULL) { errno = 0; - do - { + do { memset(&data->rcvinfo, 0x00, sizeof(struct bio_dgram_sctp_rcvinfo)); iov.iov_base = out; iov.iov_len = outl; @@ -1035,15 +1043,12 @@ static int dgram_sctp_read(BIO *b, char *out, int outl) msg.msg_flags = 0; n = recvmsg(b->num, &msg, 0); - if (msg.msg_controllen > 0) - { - for (cmsg = CMSG_FIRSTHDR(&msg); cmsg; cmsg = CMSG_NXTHDR(&msg, cmsg)) - { + if (msg.msg_controllen > 0) { + for (cmsg = CMSG_FIRSTHDR(&msg); cmsg; cmsg = CMSG_NXTHDR(&msg, cmsg)) { if (cmsg->cmsg_level != IPPROTO_SCTP) continue; #ifdef SCTP_RCVINFO - if (cmsg->cmsg_type == SCTP_RCVINFO) - { + if (cmsg->cmsg_type == SCTP_RCVINFO) { struct sctp_rcvinfo *rcvinfo; rcvinfo = (struct sctp_rcvinfo *)CMSG_DATA(cmsg); @@ -1054,11 +1059,10 @@ static int dgram_sctp_read(BIO *b, char *out, int outl) data->rcvinfo.rcv_tsn = rcvinfo->rcv_tsn; data->rcvinfo.rcv_cumtsn = rcvinfo->rcv_cumtsn; data->rcvinfo.rcv_context = rcvinfo->rcv_context; - } + } #endif #ifdef SCTP_SNDRCV - if (cmsg->cmsg_type == SCTP_SNDRCV) - { + if (cmsg->cmsg_type == SCTP_SNDRCV) { struct sctp_sndrcvinfo *sndrcvinfo; sndrcvinfo = (struct sctp_sndrcvinfo *)CMSG_DATA(cmsg); @@ -1069,23 +1073,20 @@ static int dgram_sctp_read(BIO *b, char *out, int outl) data->rcvinfo.rcv_tsn = sndrcvinfo->sinfo_tsn; data->rcvinfo.rcv_cumtsn = sndrcvinfo->sinfo_cumtsn; data->rcvinfo.rcv_context = sndrcvinfo->sinfo_context; - } -#endif } +#endif } + } - if (n <= 0) - { + if (n <= 0) { if (n < 0) ret = n; break; - } + } - if (msg.msg_flags & MSG_NOTIFICATION) - { + if (msg.msg_flags & MSG_NOTIFICATION) { snp = (union sctp_notification*) out; - if (snp->sn_header.sn_type == SCTP_SENDER_DRY_EVENT) - { + if (snp->sn_header.sn_type == SCTP_SENDER_DRY_EVENT) { #ifdef SCTP_EVENT struct sctp_event event; #else @@ -1095,13 +1096,12 @@ static int dgram_sctp_read(BIO *b, char *out, int outl) /* If a message has been delayed until the socket * is dry, it can be sent now. */ - if (data->saved_message.length > 0) - { + if (data->saved_message.length > 0) { dgram_sctp_write(data->saved_message.bio, data->saved_message.data, - data->saved_message.length); + data->saved_message.length); OPENSSL_free(data->saved_message.data); data->saved_message.length = 0; - } + } /* disable sender dry event */ #ifdef SCTP_EVENT @@ -1121,7 +1121,7 @@ static int dgram_sctp_read(BIO *b, char *out, int outl) i = setsockopt(b->num, IPPROTO_SCTP, SCTP_EVENTS, &event, sizeof(struct sctp_event_subscribe)); OPENSSL_assert(i >= 0); #endif - } + } #ifdef SCTP_AUTHENTICATION_EVENT if (snp->sn_header.sn_type == SCTP_AUTHENTICATION_EVENT) @@ -1132,14 +1132,12 @@ static int dgram_sctp_read(BIO *b, char *out, int outl) data->handle_notifications(b, data->notification_context, (void*) out); memset(out, 0, outl); - } - else + } else ret += n; - } + } while ((msg.msg_flags & MSG_NOTIFICATION) && (msg.msg_flags & MSG_EOR) && (ret < outl)); - if (ret > 0 && !(msg.msg_flags & MSG_EOR)) - { + if (ret > 0 && !(msg.msg_flags & MSG_EOR)) { /* Partial message read, this should never happen! */ /* The buffer was too small, this means the peer sent @@ -1159,8 +1157,8 @@ static int dgram_sctp_read(BIO *b, char *out, int outl) * max record size (2^14 + 2048 + 13) */ optlen = (socklen_t) sizeof(int); - ret = getsockopt(b->num, IPPROTO_SCTP, SCTP_PARTIAL_DELIVERY_POINT, - &optval, &optlen); + ret = getsockopt(b->num, IPPROTO_SCTP, + SCTP_PARTIAL_DELIVERY_POINT, &optval, &optlen); OPENSSL_assert(ret >= 0); OPENSSL_assert(optval >= 18445); @@ -1173,21 +1171,18 @@ static int dgram_sctp_read(BIO *b, char *out, int outl) memset(out, 0, outl); BIO_set_retry_read(b); return -1; - } + } BIO_clear_retry_flags(b); - if (ret < 0) - { - if (BIO_dgram_should_retry(ret)) - { + if (ret < 0) { + if (BIO_dgram_should_retry(ret)) { BIO_set_retry_read(b); data->_errno = errno; - } } + } /* Test if peer uses SCTP-AUTH before continuing */ - if (!data->peer_auth_tested) - { + if (!data->peer_auth_tested) { int ii, auth_data = 0, auth_forward = 0; unsigned char *p; struct sctp_authchunks *authchunks; @@ -1199,29 +1194,30 @@ static int dgram_sctp_read(BIO *b, char *out, int outl) OPENSSL_assert(ii >= 0); for (p = (unsigned char*) authchunks->gauth_chunks; - p < (unsigned char*) authchunks + optlen; - p += sizeof(uint8_t)) - { - if (*p == OPENSSL_SCTP_DATA_CHUNK_TYPE) auth_data = 1; - if (*p == OPENSSL_SCTP_FORWARD_CUM_TSN_CHUNK_TYPE) auth_forward = 1; - } + p < (unsigned char*) authchunks + optlen; + p += sizeof(uint8_t)) { + if (*p == OPENSSL_SCTP_DATA_CHUNK_TYPE) + auth_data = 1; + if (*p == OPENSSL_SCTP_FORWARD_CUM_TSN_CHUNK_TYPE) + auth_forward = 1; + } OPENSSL_free(authchunks); - if (!auth_data || !auth_forward) - { - BIOerr(BIO_F_DGRAM_SCTP_READ,BIO_R_CONNECT_ERROR); + if (!auth_data || !auth_forward) { + BIOerr(BIO_F_DGRAM_SCTP_READ, BIO_R_CONNECT_ERROR); return -1; - } + } data->peer_auth_tested = 1; - } } - return(ret); } + return (ret); +} -static int dgram_sctp_write(BIO *b, const char *in, int inl) - { +static int +dgram_sctp_write(BIO *b, const char *in, int inl) +{ int ret; bio_dgram_sctp_data *data = (bio_dgram_sctp_data *)b->ptr; struct bio_dgram_sctp_sndinfo *sinfo = &(data->sndinfo); @@ -1256,8 +1252,7 @@ static int dgram_sctp_write(BIO *b, const char *in, int inl) * socket is not dry yet, we have to save it and send it * as soon as the socket gets dry. */ - if (data->save_shutdown && !BIO_dgram_sctp_wait_for_dry(b)) - { + if (data->save_shutdown && !BIO_dgram_sctp_wait_for_dry(b)) { data->saved_message.bio = b; data->saved_message.length = inl; data->saved_message.data = OPENSSL_malloc(inl); @@ -1317,20 +1312,20 @@ static int dgram_sctp_write(BIO *b, const char *in, int inl) ret = sendmsg(b->num, &msg, 0); BIO_clear_retry_flags(b); - if (ret <= 0) - { - if (BIO_dgram_should_retry(ret)) - { - BIO_set_retry_write(b); + if (ret <= 0) { + if (BIO_dgram_should_retry(ret)) { + BIO_set_retry_write(b); + data->_errno = errno; - } } - return(ret); } + return (ret); +} -static long dgram_sctp_ctrl(BIO *b, int cmd, long num, void *ptr) - { - long ret=1; +static long +dgram_sctp_ctrl(BIO *b, int cmd, long num, void *ptr) +{ + long ret = 1; bio_dgram_sctp_data *data = NULL; socklen_t sockopt_len = 0; struct sctp_authkeyid authkeyid; @@ -1338,8 +1333,7 @@ static long dgram_sctp_ctrl(BIO *b, int cmd, long num, void *ptr) data = (bio_dgram_sctp_data *)b->ptr; - switch (cmd) - { + switch (cmd) { case BIO_CTRL_DGRAM_QUERY_MTU: /* Set to maximum (2^14) * and ignore user input to enable transport @@ -1384,7 +1378,8 @@ static long dgram_sctp_ctrl(BIO *b, int cmd, long num, void *ptr) /* Get active key */ sockopt_len = sizeof(struct sctp_authkeyid); ret = getsockopt(b->num, IPPROTO_SCTP, SCTP_AUTH_ACTIVE_KEY, &authkeyid, &sockopt_len); - if (ret < 0) break; + if (ret < 0) + break; /* Add new key */ sockopt_len = sizeof(struct sctp_authkey) + 64 * sizeof(uint8_t); @@ -1400,12 +1395,14 @@ static long dgram_sctp_ctrl(BIO *b, int cmd, long num, void *ptr) memcpy(&authkey->sca_key[0], ptr, 64 * sizeof(uint8_t)); ret = setsockopt(b->num, IPPROTO_SCTP, SCTP_AUTH_KEY, authkey, sockopt_len); - if (ret < 0) break; + if (ret < 0) + break; /* Reset active key */ ret = setsockopt(b->num, IPPROTO_SCTP, SCTP_AUTH_ACTIVE_KEY, - &authkeyid, sizeof(struct sctp_authkeyid)); - if (ret < 0) break; + &authkeyid, sizeof(struct sctp_authkeyid)); + if (ret < 0) + break; break; case BIO_CTRL_DGRAM_SCTP_NEXT_AUTH_KEY: @@ -1414,13 +1411,15 @@ static long dgram_sctp_ctrl(BIO *b, int cmd, long num, void *ptr) /* Get active key */ sockopt_len = sizeof(struct sctp_authkeyid); ret = getsockopt(b->num, IPPROTO_SCTP, SCTP_AUTH_ACTIVE_KEY, &authkeyid, &sockopt_len); - if (ret < 0) break; + if (ret < 0) + break; /* Set active key */ authkeyid.scact_keynumber = authkeyid.scact_keynumber + 1; ret = setsockopt(b->num, IPPROTO_SCTP, SCTP_AUTH_ACTIVE_KEY, - &authkeyid, sizeof(struct sctp_authkeyid)); - if (ret < 0) break; + &authkeyid, sizeof(struct sctp_authkeyid)); + if (ret < 0) + break; /* CCS has been sent, so remember that and fall through * to check if we need to deactivate an old key @@ -1435,12 +1434,12 @@ static long dgram_sctp_ctrl(BIO *b, int cmd, long num, void *ptr) data->ccs_rcvd = 1; /* CSS has been both, received and sent, so deactivate an old key */ - if (data->ccs_rcvd == 1 && data->ccs_sent == 1) - { + if (data->ccs_rcvd == 1 && data->ccs_sent == 1) { /* Get active key */ sockopt_len = sizeof(struct sctp_authkeyid); ret = getsockopt(b->num, IPPROTO_SCTP, SCTP_AUTH_ACTIVE_KEY, &authkeyid, &sockopt_len); - if (ret < 0) break; + if (ret < 0) + break; /* Deactivate key or delete second last key if * SCTP_AUTHENTICATION_EVENT is not available. @@ -1449,22 +1448,23 @@ static long dgram_sctp_ctrl(BIO *b, int cmd, long num, void *ptr) #ifdef SCTP_AUTH_DEACTIVATE_KEY sockopt_len = sizeof(struct sctp_authkeyid); ret = setsockopt(b->num, IPPROTO_SCTP, SCTP_AUTH_DEACTIVATE_KEY, - &authkeyid, sockopt_len); - if (ret < 0) break; + &authkeyid, sockopt_len); + if (ret < 0) + break; #endif #ifndef SCTP_AUTHENTICATION_EVENT - if (authkeyid.scact_keynumber > 0) - { + if (authkeyid.scact_keynumber > 0) { authkeyid.scact_keynumber = authkeyid.scact_keynumber - 1; ret = setsockopt(b->num, IPPROTO_SCTP, SCTP_AUTH_DELETE_KEY, - &authkeyid, sizeof(struct sctp_authkeyid)); - if (ret < 0) break; - } + &authkeyid, sizeof(struct sctp_authkeyid)); + if (ret < 0) + break; + } #endif data->ccs_rcvd = 0; data->ccs_sent = 0; - } + } break; case BIO_CTRL_DGRAM_SCTP_GET_SNDINFO: /* Returns the size of the copied struct. */ @@ -1524,30 +1524,30 @@ static long dgram_sctp_ctrl(BIO *b, int cmd, long num, void *ptr) /* Pass to default ctrl function to * process SCTP unspecific commands */ - ret=dgram_ctrl(b, cmd, num, ptr); + ret = dgram_ctrl(b, cmd, num, ptr); break; - } - return(ret); } + return (ret); +} -int BIO_dgram_sctp_notification_cb(BIO *b, - void (*handle_notifications)(BIO *bio, void *context, void *buf), - void *context) - { +int +BIO_dgram_sctp_notification_cb(BIO *b, + void (*handle_notifications)(BIO *bio, void *context, void *buf), + void *context) +{ bio_dgram_sctp_data *data = (bio_dgram_sctp_data *) b->ptr; - if (handle_notifications != NULL) - { + if (handle_notifications != NULL) { data->handle_notifications = handle_notifications; data->notification_context = context; - } - else + } else return -1; return 0; - } +} -int BIO_dgram_sctp_wait_for_dry(BIO *b) +int +BIO_dgram_sctp_wait_for_dry(BIO *b) { int is_dry = 0; int n, sockflags, ret; @@ -1574,9 +1574,9 @@ int BIO_dgram_sctp_wait_for_dry(BIO *b) ret = getsockopt(b->num, IPPROTO_SCTP, SCTP_EVENTS, &event, &eventsize); if (ret < 0) return -1; - + event.sctp_sender_dry_event = 1; - + ret = setsockopt(b->num, IPPROTO_SCTP, SCTP_EVENTS, &event, sizeof(struct sctp_event_subscribe)); #endif if (ret < 0) @@ -1595,17 +1595,15 @@ int BIO_dgram_sctp_wait_for_dry(BIO *b) msg.msg_flags = 0; n = recvmsg(b->num, &msg, MSG_PEEK); - if (n <= 0) - { + if (n <= 0) { if ((n < 0) && (errno != EAGAIN) && (errno != EWOULDBLOCK)) return -1; else return 0; - } + } /* if we find a notification, process it and try again if necessary */ - while (msg.msg_flags & MSG_NOTIFICATION) - { + while (msg.msg_flags & MSG_NOTIFICATION) { memset(&snp, 0x00, sizeof(union sctp_notification)); iov.iov_base = (char *)&snp; iov.iov_len = sizeof(union sctp_notification); @@ -1618,16 +1616,14 @@ int BIO_dgram_sctp_wait_for_dry(BIO *b) msg.msg_flags = 0; n = recvmsg(b->num, &msg, 0); - if (n <= 0) - { + if (n <= 0) { if ((n < 0) && (errno != EAGAIN) && (errno != EWOULDBLOCK)) return -1; else return is_dry; - } - - if (snp.sn_header.sn_type == SCTP_SENDER_DRY_EVENT) - { + } + + if (snp.sn_header.sn_type == SCTP_SENDER_DRY_EVENT) { is_dry = 1; /* disable sender dry event */ @@ -1649,7 +1645,7 @@ int BIO_dgram_sctp_wait_for_dry(BIO *b) #endif if (ret < 0) return -1; - } + } #ifdef SCTP_AUTHENTICATION_EVENT if (snp.sn_header.sn_type == SCTP_AUTHENTICATION_EVENT) @@ -1672,34 +1668,32 @@ int BIO_dgram_sctp_wait_for_dry(BIO *b) msg.msg_flags = 0; /* if we have seen the dry already, don't wait */ - if (is_dry) - { + if (is_dry) { sockflags = fcntl(b->num, F_GETFL, 0); fcntl(b->num, F_SETFL, O_NONBLOCK); - } + } n = recvmsg(b->num, &msg, MSG_PEEK); - if (is_dry) - { + if (is_dry) { fcntl(b->num, F_SETFL, sockflags); - } + } - if (n <= 0) - { + if (n <= 0) { if ((n < 0) && (errno != EAGAIN) && (errno != EWOULDBLOCK)) return -1; else return is_dry; - } } + } /* read anything else */ return is_dry; } -int BIO_dgram_sctp_msg_waiting(BIO *b) - { +int +BIO_dgram_sctp_msg_waiting(BIO *b) +{ int n, sockflags; union sctp_notification snp; struct msghdr msg; @@ -1708,7 +1702,7 @@ int BIO_dgram_sctp_msg_waiting(BIO *b) /* Check if there are any messages waiting to be read */ do - { + { memset(&snp, 0x00, sizeof(union sctp_notification)); iov.iov_base = (char *)&snp; iov.iov_len = sizeof(union sctp_notification); @@ -1726,8 +1720,7 @@ int BIO_dgram_sctp_msg_waiting(BIO *b) fcntl(b->num, F_SETFL, sockflags); /* if notification, process and try again */ - if (n > 0 && (msg.msg_flags & MSG_NOTIFICATION)) - { + if (n > 0 && (msg.msg_flags & MSG_NOTIFICATION)) { #ifdef SCTP_AUTHENTICATION_EVENT if (snp.sn_header.sn_type == SCTP_AUTHENTICATION_EVENT) dgram_sctp_handle_auth_free_key_event(b, &snp); @@ -1747,34 +1740,35 @@ int BIO_dgram_sctp_msg_waiting(BIO *b) if (data->handle_notifications != NULL) data->handle_notifications(b, data->notification_context, (void*) &snp); - } + } - } while (n > 0 && (msg.msg_flags & MSG_NOTIFICATION)); + } while (n > 0 && (msg.msg_flags & MSG_NOTIFICATION)); /* Return 1 if there is a message to be read, return 0 otherwise. */ if (n > 0) return 1; else return 0; - } +} -static int dgram_sctp_puts(BIO *bp, const char *str) - { - int n,ret; +static int +dgram_sctp_puts(BIO *bp, const char *str) +{ + int n, ret; - n=strlen(str); - ret=dgram_sctp_write(bp,str,n); - return(ret); - } + n = strlen(str); + ret = dgram_sctp_write(bp, str, n); + return (ret); +} #endif -static int BIO_dgram_should_retry(int i) - { +static int +BIO_dgram_should_retry(int i) +{ int err; - if ((i == 0) || (i == -1)) - { - err=errno; + if ((i == 0) || (i == -1)) { + err = errno; #if defined(OPENSSL_SYS_WINDOWS) /* If the socket return value (i) is -1 @@ -1785,15 +1779,15 @@ static int BIO_dgram_should_retry(int i) */ #endif - return(BIO_dgram_non_fatal_error(err)); - } - return(0); + return (BIO_dgram_non_fatal_error(err)); } + return (0); +} -int BIO_dgram_non_fatal_error(int err) - { - switch (err) - { +int +BIO_dgram_non_fatal_error(int err) +{ + switch (err) { #if defined(OPENSSL_SYS_WINDOWS) # if defined(WSAEWOULDBLOCK) case WSAEWOULDBLOCK: @@ -1838,17 +1832,17 @@ int BIO_dgram_non_fatal_error(int err) case EALREADY: #endif - return(1); + return (1); /* break; */ default: break; - } - return(0); } + return (0); +} -static void get_current_time(struct timeval *t) - { +static void +get_current_time(struct timeval *t) { gettimeofday(t, NULL); - } +} #endif diff --git a/src/lib/libssl/src/crypto/bio/bss_fd.c b/src/lib/libssl/src/crypto/bio/bss_fd.c index ab18a56310..35ddd61359 100644 --- a/src/lib/libssl/src/crypto/bio/bss_fd.c +++ b/src/lib/libssl/src/crypto/bio/bss_fd.c @@ -90,9 +90,8 @@ static int fd_new(BIO *h); static int fd_free(BIO *data); int BIO_fd_should_retry(int s); -static BIO_METHOD methods_fdp= - { - BIO_TYPE_FD,"file descriptor", +static BIO_METHOD methods_fdp = { + BIO_TYPE_FD, "file descriptor", fd_write, fd_read, fd_puts, @@ -101,178 +100,182 @@ static BIO_METHOD methods_fdp= fd_new, fd_free, NULL, - }; +}; -BIO_METHOD *BIO_s_fd(void) - { - return(&methods_fdp); - } +BIO_METHOD +*BIO_s_fd(void) +{ + return (&methods_fdp); +} -BIO *BIO_new_fd(int fd,int close_flag) - { +BIO +*BIO_new_fd(int fd, int close_flag) +{ BIO *ret; - ret=BIO_new(BIO_s_fd()); - if (ret == NULL) return(NULL); - BIO_set_fd(ret,fd,close_flag); - return(ret); - } + ret = BIO_new(BIO_s_fd()); + if (ret == NULL) + return (NULL); + BIO_set_fd(ret, fd, close_flag); + return (ret); +} -static int fd_new(BIO *bi) - { - bi->init=0; - bi->num=-1; - bi->ptr=NULL; +static int +fd_new(BIO *bi) +{ + bi->init = 0; + bi->num = -1; + bi->ptr = NULL; bi->flags=BIO_FLAGS_UPLINK; /* essentially redundant */ - return(1); - } + return (1); +} -static int fd_free(BIO *a) - { - if (a == NULL) return(0); - if (a->shutdown) - { - if (a->init) - { +static int +fd_free(BIO *a) +{ + if (a == NULL) + return (0); + if (a->shutdown) { + if (a->init) { UP_close(a->num); - } - a->init=0; - a->flags=BIO_FLAGS_UPLINK; } - return(1); + a->init = 0; + a->flags = BIO_FLAGS_UPLINK; } - -static int fd_read(BIO *b, char *out,int outl) - { - int ret=0; + return (1); +} - if (out != NULL) - { +static int +fd_read(BIO *b, char *out, int outl) +{ + int ret = 0; + + if (out != NULL) { errno = 0; - ret=UP_read(b->num,out,outl); + ret = UP_read(b->num, out, outl); BIO_clear_retry_flags(b); - if (ret <= 0) - { + if (ret <= 0) { if (BIO_fd_should_retry(ret)) BIO_set_retry_read(b); - } } - return(ret); } + return (ret); +} -static int fd_write(BIO *b, const char *in, int inl) - { +static int +fd_write(BIO *b, const char *in, int inl) +{ int ret; errno = 0; - ret=UP_write(b->num,in,inl); + ret = UP_write(b->num, in, inl); BIO_clear_retry_flags(b); - if (ret <= 0) - { + if (ret <= 0) { if (BIO_fd_should_retry(ret)) BIO_set_retry_write(b); - } - return(ret); } + return (ret); +} -static long fd_ctrl(BIO *b, int cmd, long num, void *ptr) - { - long ret=1; +static long +fd_ctrl(BIO *b, int cmd, long num, void *ptr) +{ + long ret = 1; int *ip; - switch (cmd) - { + switch (cmd) { case BIO_CTRL_RESET: - num=0; + num = 0; case BIO_C_FILE_SEEK: - ret=(long)UP_lseek(b->num,num,0); + ret = (long)UP_lseek(b->num, num, 0); break; case BIO_C_FILE_TELL: case BIO_CTRL_INFO: - ret=(long)UP_lseek(b->num,0,1); + ret = (long)UP_lseek(b->num, 0, 1); break; case BIO_C_SET_FD: fd_free(b); b->num= *((int *)ptr); - b->shutdown=(int)num; - b->init=1; + b->shutdown = (int)num; + b->init = 1; break; case BIO_C_GET_FD: - if (b->init) - { - ip=(int *)ptr; - if (ip != NULL) *ip=b->num; - ret=b->num; - } - else - ret= -1; + if (b->init) { + ip = (int *)ptr; + if (ip != NULL) + *ip = b->num; + ret = b->num; + } else + ret = -1; break; case BIO_CTRL_GET_CLOSE: - ret=b->shutdown; + ret = b->shutdown; break; case BIO_CTRL_SET_CLOSE: - b->shutdown=(int)num; + b->shutdown = (int)num; break; case BIO_CTRL_PENDING: case BIO_CTRL_WPENDING: - ret=0; + ret = 0; break; case BIO_CTRL_DUP: case BIO_CTRL_FLUSH: - ret=1; + ret = 1; break; default: - ret=0; + ret = 0; break; - } - return(ret); } + return (ret); +} -static int fd_puts(BIO *bp, const char *str) - { - int n,ret; +static int +fd_puts(BIO *bp, const char *str) +{ + int n, ret; - n=strlen(str); - ret=fd_write(bp,str,n); - return(ret); - } + n = strlen(str); + ret = fd_write(bp, str, n); + return (ret); +} -static int fd_gets(BIO *bp, char *buf, int size) - { - int ret=0; - char *ptr=buf; - char *end=buf+size-1; +static int +fd_gets(BIO *bp, char *buf, int size) +{ + int ret = 0; + char *ptr = buf; + char *end = buf + size - 1; - while ( (ptr < end) && (fd_read(bp, ptr, 1) > 0) && (ptr[0] != '\n') ) + while ((ptr < end) && (fd_read(bp, ptr, 1) > 0) && (ptr[0] != '\n')) ptr++; - ptr[0]='\0'; + ptr[0] = '\0'; if (buf[0] != '\0') - ret=strlen(buf); - return(ret); - } + ret = strlen(buf); + return (ret); +} -int BIO_fd_should_retry(int i) - { +int +BIO_fd_should_retry(int i) +{ int err; - if ((i == 0) || (i == -1)) - { - err=errno; + if ((i == 0) || (i == -1)) { + err = errno; #if defined(OPENSSL_SYS_WINDOWS) && 0 /* more microsoft stupidity? perhaps not? Ben 4/1/99 */ if ((i == -1) && (err == 0)) - return(1); + return (1); #endif - return(BIO_fd_non_fatal_error(err)); - } - return(0); + return (BIO_fd_non_fatal_error(err)); } + return (0); +} -int BIO_fd_non_fatal_error(int err) - { - switch (err) - { +int +BIO_fd_non_fatal_error(int err) +{ + switch (err) { #ifdef EWOULDBLOCK # ifdef WSAEWOULDBLOCK @@ -309,11 +312,11 @@ int BIO_fd_non_fatal_error(int err) #ifdef EALREADY case EALREADY: #endif - return(1); + return (1); /* break; */ default: break; - } - return(0); } + return (0); +} #endif diff --git a/src/lib/libssl/src/crypto/bio/bss_file.c b/src/lib/libssl/src/crypto/bio/bss_file.c index 638572ab7f..794f503a69 100644 --- a/src/lib/libssl/src/crypto/bio/bss_file.c +++ b/src/lib/libssl/src/crypto/bio/bss_file.c @@ -102,8 +102,8 @@ static int file_gets(BIO *h, char *str, int size); static long file_ctrl(BIO *h, int cmd, long arg1, void *arg2); static int file_new(BIO *h); static int file_free(BIO *data); -static BIO_METHOD methods_filep= - { + +static BIO_METHOD methods_filep = { BIO_TYPE_FILE, "FILE pointer", file_write, @@ -114,15 +114,16 @@ static BIO_METHOD methods_filep= file_new, file_free, NULL, - }; +}; -BIO *BIO_new_file(const char *filename, const char *mode) - { +BIO +*BIO_new_file(const char *filename, const char *mode) +{ BIO *ret; - FILE *file=NULL; + FILE *file = NULL; #if defined(_WIN32) && defined(CP_UTF8) - int sz, len_0 = (int)strlen(filename)+1; + int sz, len_0 = (int)strlen(filename) + 1; DWORD flags; /* @@ -137,173 +138,171 @@ BIO *BIO_new_file(const char *filename, const char *mode) * ERROR_NO_UNICODE_TRANSLATION, in which case we fall * back to fopen... */ - if ((sz=MultiByteToWideChar(CP_UTF8,(flags=MB_ERR_INVALID_CHARS), - filename,len_0,NULL,0))>0 || - (GetLastError()==ERROR_INVALID_FLAGS && - (sz=MultiByteToWideChar(CP_UTF8,(flags=0), - filename,len_0,NULL,0))>0) - ) - { + if ((sz = MultiByteToWideChar(CP_UTF8,(flags = MB_ERR_INVALID_CHARS), + filename, len_0, NULL, 0)) > 0 || + (GetLastError() == ERROR_INVALID_FLAGS && + (sz = MultiByteToWideChar(CP_UTF8,(flags = 0), + filename, len_0, NULL, 0)) > 0)) { WCHAR wmode[8]; WCHAR *wfilename = _alloca(sz*sizeof(WCHAR)); - if (MultiByteToWideChar(CP_UTF8,flags, - filename,len_0,wfilename,sz) && - MultiByteToWideChar(CP_UTF8,0,mode,strlen(mode)+1, - wmode,sizeof(wmode)/sizeof(wmode[0])) && - (file=_wfopen(wfilename,wmode))==NULL && - (errno==ENOENT || errno==EBADF) - ) /* UTF-8 decode succeeded, but no file, filename + if (MultiByteToWideChar(CP_UTF8, flags, filename, len_0, + wfilename, sz) && MultiByteToWideChar(CP_UTF8, 0, mode, + strlen(mode) + 1, wmode, + sizeof(wmode) / sizeof(wmode[0])) && + (file = _wfopen(wfilename, wmode)) == NULL && + (errno == ENOENT || errno == EBADF) + ) /* UTF - 8 decode succeeded, but no file, filename * could still have been locale-ized... */ - file = fopen(filename,mode); - } - else if (GetLastError()==ERROR_NO_UNICODE_TRANSLATION) - { - file = fopen(filename,mode); - } + file = fopen(filename, mode); + } else if (GetLastError() == ERROR_NO_UNICODE_TRANSLATION) { + file = fopen(filename, mode); + } #else - file=fopen(filename,mode); + file = fopen(filename, mode); + #endif - if (file == NULL) - { + if (file == NULL) { SYSerr(SYS_F_FOPEN, errno); - ERR_add_error_data(5,"fopen('",filename,"','",mode,"')"); + ERR_add_error_data(5, "fopen('", filename, "', '", mode, "')"); if (errno == ENOENT) - BIOerr(BIO_F_BIO_NEW_FILE,BIO_R_NO_SUCH_FILE); + 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) - { + 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,BIO_CLOSE); - return(ret); + return (NULL); } -BIO *BIO_new_fp(FILE *stream, int close_flag) - { - BIO *ret; - - if ((ret=BIO_new(BIO_s_file())) == NULL) - return(NULL); - - BIO_set_flags(ret,BIO_FLAGS_UPLINK); /* redundant, left for documentation puposes */ - BIO_set_fp(ret,stream,close_flag); - return(ret); - } + BIO_clear_flags(ret, BIO_FLAGS_UPLINK); /* we did fopen -> we disengage UPLINK */ + BIO_set_fp(ret, file, BIO_CLOSE); + return (ret); +} -BIO_METHOD *BIO_s_file(void) - { - return(&methods_filep); - } +BIO +*BIO_new_fp(FILE *stream, int close_flag) +{ + BIO *ret; -static int file_new(BIO *bi) - { - bi->init=0; - bi->num=0; - bi->ptr=NULL; + if ((ret = BIO_new(BIO_s_file())) == NULL) + return (NULL); + + BIO_set_flags(ret, BIO_FLAGS_UPLINK); /* redundant, left for documentation puposes */ + BIO_set_fp(ret, stream, close_flag); + return (ret); +} + +BIO_METHOD +*BIO_s_file(void) +{ + return (&methods_filep); +} + +static int +file_new(BIO *bi) +{ + bi->init = 0; + bi->num = 0; + bi->ptr = NULL; bi->flags=BIO_FLAGS_UPLINK; /* default to UPLINK */ - return(1); - } - -static int file_free(BIO *a) - { - if (a == NULL) return(0); - if (a->shutdown) - { - if ((a->init) && (a->ptr != NULL)) - { + return (1); +} + +static int +file_free(BIO *a) +{ + if (a == NULL) + return (0); + if (a->shutdown) { + if ((a->init) && (a->ptr != NULL)) { if (a->flags&BIO_FLAGS_UPLINK) UP_fclose (a->ptr); else fclose (a->ptr); - a->ptr=NULL; - a->flags=BIO_FLAGS_UPLINK; - } - a->init=0; + a->ptr = NULL; + a->flags = BIO_FLAGS_UPLINK; } - return(1); + a->init = 0; } - -static int file_read(BIO *b, char *out, int outl) - { - int ret=0; + return (1); +} - if (b->init && (out != NULL)) - { +static int +file_read(BIO *b, char *out, int outl) +{ + int ret = 0; + + if (b->init && (out != NULL)) { if (b->flags&BIO_FLAGS_UPLINK) - ret=UP_fread(out,1,(int)outl,b->ptr); + ret = UP_fread(out, 1,(int)outl, b->ptr); else - ret=fread(out,1,(int)outl,(FILE *)b->ptr); - if(ret == 0 && (b->flags&BIO_FLAGS_UPLINK)?UP_ferror((FILE *)b->ptr):ferror((FILE *)b->ptr)) - { + ret = fread(out, 1,(int)outl,(FILE *)b->ptr); + if (ret == 0 && (b->flags & BIO_FLAGS_UPLINK) ? + UP_ferror((FILE *)b->ptr) : ferror((FILE *)b->ptr)) { SYSerr(SYS_F_FREAD, errno); - BIOerr(BIO_F_FILE_READ,ERR_R_SYS_LIB); - ret=-1; - } + BIOerr(BIO_F_FILE_READ, ERR_R_SYS_LIB); + ret = -1; } - return(ret); } + return (ret); +} -static int file_write(BIO *b, const char *in, int inl) - { - int ret=0; +static int +file_write(BIO *b, const char *in, int inl) +{ + int ret = 0; - if (b->init && (in != NULL)) - { + if (b->init && (in != NULL)) { if (b->flags&BIO_FLAGS_UPLINK) - ret=UP_fwrite(in,(int)inl,1,b->ptr); + ret = UP_fwrite(in,(int)inl, 1, b->ptr); else - ret=fwrite(in,(int)inl,1,(FILE *)b->ptr); + ret = fwrite(in,(int)inl, 1,(FILE *)b->ptr); if (ret) - ret=inl; + ret = inl; /* ret=fwrite(in,1,(int)inl,(FILE *)b->ptr); */ /* according to Tim Hudson , the commented * out version above can cause 'inl' write calls under * some stupid stdio implementations (VMS) */ - } - return(ret); } - -static long file_ctrl(BIO *b, int cmd, long num, void *ptr) - { - long ret=1; - FILE *fp=(FILE *)b->ptr; + return (ret); +} + +static long +file_ctrl(BIO *b, int cmd, long num, void *ptr) +{ + long ret = 1; + FILE *fp = (FILE *)b->ptr; FILE **fpp; char p[4]; - switch (cmd) - { + switch (cmd) { case BIO_C_FILE_SEEK: case BIO_CTRL_RESET: if (b->flags&BIO_FLAGS_UPLINK) - ret=(long)UP_fseek(b->ptr,num,0); + ret = (long)UP_fseek(b->ptr, num, 0); else - ret=(long)fseek(fp,num,0); + ret = (long)fseek(fp, num, 0); break; case BIO_CTRL_EOF: if (b->flags&BIO_FLAGS_UPLINK) - ret=(long)UP_feof(fp); + ret = (long)UP_feof(fp); else - ret=(long)feof(fp); + ret = (long)feof(fp); break; case BIO_C_FILE_TELL: case BIO_CTRL_INFO: if (b->flags&BIO_FLAGS_UPLINK) - ret=UP_ftell(b->ptr); + ret = UP_ftell(b->ptr); else - ret=ftell(fp); + ret = ftell(fp); break; case BIO_C_SET_FILE_PTR: file_free(b); - b->shutdown=(int)num&BIO_CLOSE; - b->ptr=ptr; - b->init=1; + b->shutdown = (int)num&BIO_CLOSE; + b->ptr = ptr; + b->init = 1; #if BIO_FLAGS_UPLINK!=0 #if defined(__MINGW32__) && defined(__MSVCRT__) && !defined(_IOB_ENTRIES) #define _IOB_ENTRIES 20 @@ -311,8 +310,8 @@ static long file_ctrl(BIO *b, int cmd, long num, void *ptr) #if defined(_IOB_ENTRIES) /* Safety net to catch purely internal BIO_set_fp calls */ if ((size_t)ptr >= (size_t)stdin && - (size_t)ptr < (size_t)(stdin+_IOB_ENTRIES)) - BIO_clear_flags(b,BIO_FLAGS_UPLINK); + (size_t)ptr < (size_t)(stdin + _IOB_ENTRIES)) + BIO_clear_flags(b, BIO_FLAGS_UPLINK); #endif #endif #ifdef UP_fsetmod @@ -322,102 +321,94 @@ static long file_ctrl(BIO *b, int cmd, long num, void *ptr) #endif { #if defined(OPENSSL_SYS_WINDOWS) - int fd = _fileno((FILE*)ptr); - if (num & BIO_FP_TEXT) - _setmode(fd,_O_TEXT); - else - _setmode(fd,_O_BINARY); + int fd = _fileno((FILE*)ptr); + if (num & BIO_FP_TEXT) + _setmode(fd, _O_TEXT); + else + _setmode(fd, _O_BINARY); #elif defined(OPENSSL_SYS_NETWARE) && defined(NETWARE_CLIB) - int fd = fileno((FILE*)ptr); - /* Under CLib there are differences in file modes */ - if (num & BIO_FP_TEXT) - setmode(fd,O_TEXT); - else - setmode(fd,O_BINARY); -#elif defined(OPENSSL_SYS_MSDOS) - int fd = fileno((FILE*)ptr); - /* Set correct text/binary mode */ - if (num & BIO_FP_TEXT) - _setmode(fd,_O_TEXT); - /* Dangerous to set stdin/stdout to raw (unless redirected) */ - else - { - if (fd == STDIN_FILENO || fd == STDOUT_FILENO) - { - if (isatty(fd) <= 0) - _setmode(fd,_O_BINARY); - } + int fd = fileno((FILE*)ptr); + /* Under CLib there are differences in file modes */ + if (num & BIO_FP_TEXT) + setmode(fd, O_TEXT); else - _setmode(fd,_O_BINARY); + setmode(fd, O_BINARY); +#elif defined(OPENSSL_SYS_MSDOS) + int fd = fileno((FILE*)ptr); + /* Set correct text/binary mode */ + if (num & BIO_FP_TEXT) + _setmode(fd, _O_TEXT); + /* Dangerous to set stdin/stdout to raw (unless redirected) */ + else { + if (fd == STDIN_FILENO || fd == STDOUT_FILENO) { + if (isatty(fd) <= 0) + _setmode(fd, _O_BINARY); + } else + _setmode(fd, _O_BINARY); } #elif defined(OPENSSL_SYS_OS2) || defined(OPENSSL_SYS_WIN32_CYGWIN) - int fd = fileno((FILE*)ptr); - if (num & BIO_FP_TEXT) - setmode(fd, O_TEXT); - else - setmode(fd, O_BINARY); + int fd = fileno((FILE*)ptr); + if (num & BIO_FP_TEXT) + setmode(fd, O_TEXT); + else + setmode(fd, O_BINARY); #endif } break; case BIO_C_SET_FILENAME: file_free(b); - b->shutdown=(int)num&BIO_CLOSE; - if (num & BIO_FP_APPEND) - { + b->shutdown = (int)num&BIO_CLOSE; + if (num & BIO_FP_APPEND) { if (num & BIO_FP_READ) - BUF_strlcpy(p,"a+",sizeof p); - else BUF_strlcpy(p,"a",sizeof p); - } - else if ((num & BIO_FP_READ) && (num & BIO_FP_WRITE)) - BUF_strlcpy(p,"r+",sizeof p); + BUF_strlcpy(p, "a+", sizeof p); + else BUF_strlcpy(p, "a", sizeof p); + } else if ((num & BIO_FP_READ) && (num & BIO_FP_WRITE)) + BUF_strlcpy(p, "r+", sizeof p); else if (num & BIO_FP_WRITE) - BUF_strlcpy(p,"w",sizeof p); + BUF_strlcpy(p, "w", sizeof p); else if (num & BIO_FP_READ) - BUF_strlcpy(p,"r",sizeof p); - else - { - BIOerr(BIO_F_FILE_CTRL,BIO_R_BAD_FOPEN_MODE); - ret=0; + BUF_strlcpy(p, "r", sizeof p); + else { + BIOerr(BIO_F_FILE_CTRL, BIO_R_BAD_FOPEN_MODE); + ret = 0; break; - } + } #if defined(OPENSSL_SYS_MSDOS) || defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_OS2) || defined(OPENSSL_SYS_WIN32_CYGWIN) if (!(num & BIO_FP_TEXT)) - strcat(p,"b"); + strcat(p, "b"); else - strcat(p,"t"); + strcat(p, "t"); #endif #if defined(OPENSSL_SYS_NETWARE) if (!(num & BIO_FP_TEXT)) - strcat(p,"b"); + strcat(p, "b"); else - strcat(p,"t"); + strcat(p, "t"); #endif - fp=fopen(ptr,p); - if (fp == NULL) - { + fp = fopen(ptr, p); + if (fp == NULL) { SYSerr(SYS_F_FOPEN, errno); - ERR_add_error_data(5,"fopen('",ptr,"','",p,"')"); - BIOerr(BIO_F_FILE_CTRL,ERR_R_SYS_LIB); - ret=0; + ERR_add_error_data(5, "fopen('", ptr, "', '", p, "')"); + BIOerr(BIO_F_FILE_CTRL, ERR_R_SYS_LIB); + ret = 0; break; - } - b->ptr=fp; - b->init=1; - BIO_clear_flags(b,BIO_FLAGS_UPLINK); /* we did fopen -> we disengage UPLINK */ + } + b->ptr = fp; + b->init = 1; + BIO_clear_flags(b, BIO_FLAGS_UPLINK); /* we did fopen -> we disengage UPLINK */ break; case BIO_C_GET_FILE_PTR: /* the ptr parameter is actually a FILE ** in this case. */ - if (ptr != NULL) - { - fpp=(FILE **)ptr; - *fpp=(FILE *)b->ptr; - } + if (ptr != NULL) { + fpp = (FILE **)ptr; + *fpp = (FILE *)b->ptr; + } break; case BIO_CTRL_GET_CLOSE: - ret=(long)b->shutdown; + ret = (long)b->shutdown; break; case BIO_CTRL_SET_CLOSE: - b->shutdown=(int)num; + b->shutdown = (int)num; break; case BIO_CTRL_FLUSH: if (b->flags&BIO_FLAGS_UPLINK) @@ -426,7 +417,7 @@ static long file_ctrl(BIO *b, int cmd, long num, void *ptr) fflush((FILE *)b->ptr); break; case BIO_CTRL_DUP: - ret=1; + ret = 1; break; case BIO_CTRL_WPENDING: @@ -434,44 +425,41 @@ static long file_ctrl(BIO *b, int cmd, long num, void *ptr) case BIO_CTRL_PUSH: case BIO_CTRL_POP: default: - ret=0; + ret = 0; break; - } - return(ret); } + return (ret); +} -static int file_gets(BIO *bp, char *buf, int size) - { - int ret=0; +static int +file_gets(BIO *bp, char *buf, int size) +{ + int ret = 0; - buf[0]='\0'; - if (bp->flags&BIO_FLAGS_UPLINK) - { - if (!UP_fgets(buf,size,bp->ptr)) + buf[0] = '\0'; + if (bp->flags&BIO_FLAGS_UPLINK) { + if (!UP_fgets(buf, size, bp->ptr)) goto err; - } - else - { - if (!fgets(buf,size,(FILE *)bp->ptr)) + } else { + if (!fgets(buf, size,(FILE *)bp->ptr)) goto err; - } - if (buf[0] != '\0') - ret=strlen(buf); - err: - return(ret); } + if (buf[0] != '\0') + ret = strlen(buf); +err: + return (ret); +} -static int file_puts(BIO *bp, const char *str) - { - int n,ret; +static int +file_puts(BIO *bp, const char *str) +{ + int n, ret; - n=strlen(str); - ret=file_write(bp,str,n); - return(ret); - } + n = strlen(str); + ret = file_write(bp, str, n); + return (ret); +} #endif /* OPENSSL_NO_STDIO */ #endif /* HEADER_BSS_FILE_C */ - - diff --git a/src/lib/libssl/src/crypto/bio/bss_log.c b/src/lib/libssl/src/crypto/bio/bss_log.c index 1cc413a916..9225af4df2 100644 --- a/src/lib/libssl/src/crypto/bio/bss_log.c +++ b/src/lib/libssl/src/crypto/bio/bss_log.c @@ -80,7 +80,7 @@ # if __INITIAL_POINTER_SIZE == 64 # pragma pointer_size save # pragma pointer_size 32 - void * _malloc32 (__size_t); +void * _malloc32 (__size_t); # pragma pointer_size restore # endif /* __INITIAL_POINTER_SIZE == 64 */ # endif /* __INITIAL_POINTER_SIZE && defined _ANSI_C_SOURCE */ @@ -131,9 +131,8 @@ static void xopenlog(BIO* bp, char* name, int level); static void xsyslog(BIO* bp, int priority, const char* string); static void xcloselog(BIO* bp); -static BIO_METHOD methods_slg= - { - BIO_TYPE_MEM,"syslog", +static BIO_METHOD methods_slg = { + BIO_TYPE_MEM, "syslog", slg_write, NULL, slg_puts, @@ -142,43 +141,46 @@ static BIO_METHOD methods_slg= slg_new, slg_free, NULL, - }; +}; -BIO_METHOD *BIO_s_log(void) - { - return(&methods_slg); - } +BIO_METHOD +*BIO_s_log(void) +{ + return (&methods_slg); +} -static int slg_new(BIO *bi) - { - bi->init=1; - bi->num=0; - bi->ptr=NULL; +static int +slg_new(BIO *bi) +{ + bi->init = 1; + bi->num = 0; + bi->ptr = NULL; xopenlog(bi, "application", LOG_DAEMON); - return(1); - } + return (1); +} -static int slg_free(BIO *a) - { - if (a == NULL) return(0); +static int +slg_free(BIO *a) +{ + if (a == NULL) + return (0); xcloselog(a); - return(1); - } - -static int slg_write(BIO *b, const char *in, int inl) - { - int ret= inl; + return (1); +} + +static int +slg_write(BIO *b, const char *in, int inl) +{ + int ret = inl; char* buf; char* pp; int priority, i; - static const struct - { + static const struct { int strl; char str[10]; int log_level; - } - mapping[] = - { + } + mapping[] = { { 6, "PANIC ", LOG_EMERG }, { 6, "EMERG ", LOG_EMERG }, { 4, "EMR ", LOG_EMERG }, @@ -199,69 +201,72 @@ static int slg_write(BIO *b, const char *in, int inl) { 6, "DEBUG ", LOG_DEBUG }, { 4, "DBG ", LOG_DEBUG }, { 0, "", LOG_ERR } /* The default */ - }; + }; - if((buf= (char *)OPENSSL_malloc(inl+ 1)) == NULL){ - return(0); + if ((buf = (char *)OPENSSL_malloc(inl + 1)) == NULL) { + return (0); } strncpy(buf, in, inl); - buf[inl]= '\0'; + buf[inl] = '\0'; i = 0; - while(strncmp(buf, mapping[i].str, mapping[i].strl) != 0) i++; + while (strncmp(buf, mapping[i].str, mapping[i].strl) != 0) + i++; priority = mapping[i].log_level; pp = buf + mapping[i].strl; xsyslog(b, priority, pp); OPENSSL_free(buf); - return(ret); - } + return (ret); +} -static long slg_ctrl(BIO *b, int cmd, long num, void *ptr) - { - switch (cmd) - { +static long +slg_ctrl(BIO *b, int cmd, long num, void *ptr) +{ + switch (cmd) { case BIO_CTRL_SET: xcloselog(b); xopenlog(b, ptr, num); break; default: break; - } - return(0); } + return (0); +} -static int slg_puts(BIO *bp, const char *str) - { - int n,ret; +static int +slg_puts(BIO *bp, const char *str) +{ + int n, ret; - n=strlen(str); - ret=slg_write(bp,str,n); - return(ret); - } + n = strlen(str); + ret = slg_write(bp, str, n); + return (ret); +} #if defined(OPENSSL_SYS_WIN32) -static void xopenlog(BIO* bp, char* name, int level) +static void +xopenlog(BIO* bp, char* name, int level) { if (check_winnt()) - bp->ptr = RegisterEventSourceA(NULL,name); + bp->ptr = RegisterEventSourceA(NULL, name); else bp->ptr = NULL; } -static void xsyslog(BIO *bp, int priority, const char *string) +static void +xsyslog(BIO *bp, int priority, const char *string) { LPCSTR lpszStrings[2]; - WORD evtype= EVENTLOG_ERROR_TYPE; - char pidbuf[DECIMAL_SIZE(DWORD)+4]; + WORD evtype = EVENTLOG_ERROR_TYPE; + char pidbuf[DECIMAL_SIZE(DWORD) + 4]; if (bp->ptr == NULL) return; - switch (priority) - { + switch (priority) { case LOG_EMERG: case LOG_ALERT: case LOG_CRIT: @@ -280,33 +285,37 @@ static void xsyslog(BIO *bp, int priority, const char *string) as error anyway. */ evtype = EVENTLOG_ERROR_TYPE; break; - } + } sprintf(pidbuf, "[%u] ", GetCurrentProcessId()); lpszStrings[0] = pidbuf; lpszStrings[1] = string; ReportEventA(bp->ptr, evtype, 0, 1024, NULL, 2, 0, - lpszStrings, NULL); + lpszStrings, NULL); } - -static void xcloselog(BIO* bp) + +static void +xcloselog(BIO* bp) { - if(bp->ptr) + if (bp->ptr) DeregisterEventSource((HANDLE)(bp->ptr)); - bp->ptr= NULL; + bp->ptr = NULL; } #elif defined(OPENSSL_SYS_VMS) static int VMS_OPC_target = LOG_DAEMON; -static void xopenlog(BIO* bp, char* name, int level) +static void +xopenlog(BIO* bp, char* name, int level) { - VMS_OPC_target = level; + VMS_OPC_target = level; + } -static void xsyslog(BIO *bp, int priority, const char *string) +static void +xsyslog(BIO *bp, int priority, const char *string) { struct dsc$descriptor_s opc_dsc; @@ -329,21 +338,28 @@ static void xsyslog(BIO *bp, int priority, const char *string) char buf[10240]; unsigned int len; - struct dsc$descriptor_s buf_dsc; + struct dsc$descriptor_s buf_dsc; $DESCRIPTOR(fao_cmd, "!AZ: !AZ"); char *priority_tag; - switch (priority) - { - case LOG_EMERG: priority_tag = "Emergency"; break; - case LOG_ALERT: priority_tag = "Alert"; break; - case LOG_CRIT: priority_tag = "Critical"; break; - case LOG_ERR: priority_tag = "Error"; break; - case LOG_WARNING: priority_tag = "Warning"; break; - case LOG_NOTICE: priority_tag = "Notice"; break; - case LOG_INFO: priority_tag = "Info"; break; - case LOG_DEBUG: priority_tag = "DEBUG"; break; - } + switch (priority) { + case LOG_EMERG: + priority_tag = "Emergency"; break; + case LOG_ALERT: + priority_tag = "Alert"; break; + case LOG_CRIT: + priority_tag = "Critical"; break; + case LOG_ERR: + priority_tag = "Error"; break; + case LOG_WARNING: + priority_tag = "Warning"; break; + case LOG_NOTICE: + priority_tag = "Notice"; break; + case LOG_INFO: + priority_tag = "Info"; break; + case LOG_DEBUG: + priority_tag = "DEBUG"; break; + } buf_dsc.dsc$b_dtype = DSC$K_DTYPE_T; buf_dsc.dsc$b_class = DSC$K_CLASS_S; @@ -353,7 +369,7 @@ static void xsyslog(BIO *bp, int priority, const char *string) lib$sys_fao(&fao_cmd, &len, &buf_dsc, priority_tag, string); /* We know there's an 8-byte header. That's documented. */ - opcdef_p = OPCDEF_MALLOC( 8+ len); + opcdef_p = OPCDEF_MALLOC( 8 + len); opcdef_p->opc$b_ms_type = OPC$_RQ_RQST; memcpy(opcdef_p->opc$z_ms_target_classes, &VMS_OPC_target, 3); opcdef_p->opc$l_ms_rqstid = 0; @@ -369,13 +385,15 @@ static void xsyslog(BIO *bp, int priority, const char *string) OPENSSL_free(opcdef_p); } -static void xcloselog(BIO* bp) +static void +xcloselog(BIO* bp) { } #else /* Unix/Watt32 */ -static void xopenlog(BIO* bp, char* name, int level) +static void +xopenlog(BIO* bp, char* name, int level) { #ifdef WATT32 /* djgpp/DOS */ openlog(name, LOG_PID|LOG_CONS|LOG_NDELAY, level); @@ -384,12 +402,14 @@ static void xopenlog(BIO* bp, char* name, int level) #endif } -static void xsyslog(BIO *bp, int priority, const char *string) +static void +xsyslog(BIO *bp, int priority, const char *string) { syslog(priority, "%s", string); } -static void xcloselog(BIO* bp) +static void +xcloselog(BIO* bp) { closelog(); } diff --git a/src/lib/libssl/src/crypto/bio/bss_mem.c b/src/lib/libssl/src/crypto/bio/bss_mem.c index 37d4194e4b..a5192202bd 100644 --- a/src/lib/libssl/src/crypto/bio/bss_mem.c +++ b/src/lib/libssl/src/crypto/bio/bss_mem.c @@ -68,8 +68,8 @@ static int mem_gets(BIO *h, char *str, int size); static long mem_ctrl(BIO *h, int cmd, long arg1, void *arg2); static int mem_new(BIO *h); static int mem_free(BIO *data); -static BIO_METHOD mem_method= - { + +static BIO_METHOD mem_method = { BIO_TYPE_MEM, "memory buffer", mem_write, @@ -80,28 +80,31 @@ static BIO_METHOD mem_method= mem_new, mem_free, NULL, - }; +}; /* bio->num is used to hold the value to return on 'empty', if it is * 0, should_retry is not set */ -BIO_METHOD *BIO_s_mem(void) - { - return(&mem_method); - } +BIO_METHOD +*BIO_s_mem(void) +{ + return (&mem_method); +} -BIO *BIO_new_mem_buf(void *buf, int len) +BIO +*BIO_new_mem_buf(void *buf, int len) { BIO *ret; BUF_MEM *b; size_t sz; if (!buf) { - BIOerr(BIO_F_BIO_NEW_MEM_BUF,BIO_R_NULL_PARAMETER); + BIOerr(BIO_F_BIO_NEW_MEM_BUF, BIO_R_NULL_PARAMETER); return NULL; } - sz = (len<0) ? strlen(buf) : (size_t)len; - if(!(ret = BIO_new(BIO_s_mem())) ) return NULL; + sz = (len < 0) ? strlen(buf) : (size_t)len; + if (!(ret = BIO_new(BIO_s_mem()))) + return NULL; b = (BUF_MEM *)ret->ptr; b->data = buf; b->length = sz; @@ -112,208 +115,205 @@ BIO *BIO_new_mem_buf(void *buf, int len) return ret; } -static int mem_new(BIO *bi) - { +static int +mem_new(BIO *bi) +{ BUF_MEM *b; - if ((b=BUF_MEM_new()) == NULL) - return(0); - bi->shutdown=1; - bi->init=1; - bi->num= -1; - bi->ptr=(char *)b; - return(1); - } + if ((b = BUF_MEM_new()) == NULL) + return (0); + bi->shutdown = 1; + bi->init = 1; + bi->num = -1; + bi->ptr = (char *)b; + return (1); +} -static int mem_free(BIO *a) - { - if (a == NULL) return(0); - if (a->shutdown) - { - if ((a->init) && (a->ptr != NULL)) - { +static int +mem_free(BIO *a) +{ + if (a == NULL) + return (0); + if (a->shutdown) { + if ((a->init) && (a->ptr != NULL)) { BUF_MEM *b; b = (BUF_MEM *)a->ptr; - if(a->flags & BIO_FLAGS_MEM_RDONLY) b->data = NULL; - BUF_MEM_free(b); - a->ptr=NULL; - } + if (a->flags & BIO_FLAGS_MEM_RDONLY) + b->data = NULL; + BUF_MEM_free(b); + a->ptr = NULL; } - return(1); } - -static int mem_read(BIO *b, char *out, int outl) - { - int ret= -1; + return (1); +} + +static int +mem_read(BIO *b, char *out, int outl) +{ + int ret = -1; BUF_MEM *bm; - bm=(BUF_MEM *)b->ptr; + bm = (BUF_MEM *)b->ptr; BIO_clear_retry_flags(b); - ret=(outl >=0 && (size_t)outl > bm->length)?(int)bm->length:outl; + ret = (outl >=0 && (size_t)outl > bm->length) ? (int)bm->length : outl; if ((out != NULL) && (ret > 0)) { - memcpy(out,bm->data,ret); - bm->length-=ret; - if(b->flags & BIO_FLAGS_MEM_RDONLY) bm->data += ret; + memcpy(out, bm->data, ret); + bm->length -= ret; + if (b->flags & BIO_FLAGS_MEM_RDONLY) + bm->data += ret; else { - memmove(&(bm->data[0]),&(bm->data[ret]),bm->length); + memmove(&(bm->data[0]), &(bm->data[ret]), bm->length); } - } else if (bm->length == 0) - { + } else if (bm->length == 0) { ret = b->num; if (ret != 0) BIO_set_retry_read(b); - } - return(ret); } + return (ret); +} -static int mem_write(BIO *b, const char *in, int inl) - { - int ret= -1; +static int +mem_write(BIO *b, const char *in, int inl) +{ + int ret = -1; int blen; BUF_MEM *bm; - bm=(BUF_MEM *)b->ptr; - if (in == NULL) - { - BIOerr(BIO_F_MEM_WRITE,BIO_R_NULL_PARAMETER); + bm = (BUF_MEM *)b->ptr; + if (in == NULL) { + BIOerr(BIO_F_MEM_WRITE, BIO_R_NULL_PARAMETER); goto end; - } + } - if(b->flags & BIO_FLAGS_MEM_RDONLY) { - BIOerr(BIO_F_MEM_WRITE,BIO_R_WRITE_TO_READ_ONLY_BIO); + if (b->flags & BIO_FLAGS_MEM_RDONLY) { + BIOerr(BIO_F_MEM_WRITE, BIO_R_WRITE_TO_READ_ONLY_BIO); goto end; } BIO_clear_retry_flags(b); - blen=bm->length; - if (BUF_MEM_grow_clean(bm,blen+inl) != (blen+inl)) + blen = bm->length; + if (BUF_MEM_grow_clean(bm, blen + inl) != (blen + inl)) goto end; - memcpy(&(bm->data[blen]),in,inl); - ret=inl; + memcpy(&(bm->data[blen]), in, inl); + ret = inl; end: - return(ret); - } + return (ret); +} -static long mem_ctrl(BIO *b, int cmd, long num, void *ptr) - { - long ret=1; +static long +mem_ctrl(BIO *b, int cmd, long num, void *ptr) +{ + long ret = 1; char **pptr; - BUF_MEM *bm=(BUF_MEM *)b->ptr; + BUF_MEM *bm = (BUF_MEM *)b->ptr; - switch (cmd) - { + switch (cmd) { case BIO_CTRL_RESET: - if (bm->data != NULL) - { + if (bm->data != NULL) { /* For read only case reset to the start again */ - if(b->flags & BIO_FLAGS_MEM_RDONLY) - { + if (b->flags & BIO_FLAGS_MEM_RDONLY) { bm->data -= bm->max - bm->length; bm->length = bm->max; - } - else - { - memset(bm->data,0,bm->max); - bm->length=0; - } + } else { + memset(bm->data, 0, bm->max); + bm->length = 0; } + } break; case BIO_CTRL_EOF: - ret=(long)(bm->length == 0); + ret = (long)(bm->length == 0); break; case BIO_C_SET_BUF_MEM_EOF_RETURN: - b->num=(int)num; + b->num = (int)num; break; case BIO_CTRL_INFO: - ret=(long)bm->length; - if (ptr != NULL) - { - pptr=(char **)ptr; - *pptr=(char *)&(bm->data[0]); - } + ret = (long)bm->length; + if (ptr != NULL) { + pptr = (char **)ptr; + *pptr = (char *)&(bm->data[0]); + } break; case BIO_C_SET_BUF_MEM: mem_free(b); - b->shutdown=(int)num; - b->ptr=ptr; + b->shutdown = (int)num; + b->ptr = ptr; break; case BIO_C_GET_BUF_MEM_PTR: - if (ptr != NULL) - { - pptr=(char **)ptr; - *pptr=(char *)bm; - } + if (ptr != NULL) { + pptr = (char **)ptr; + *pptr = (char *)bm; + } break; case BIO_CTRL_GET_CLOSE: - ret=(long)b->shutdown; + ret = (long)b->shutdown; break; case BIO_CTRL_SET_CLOSE: - b->shutdown=(int)num; + b->shutdown = (int)num; break; case BIO_CTRL_WPENDING: - ret=0L; + ret = 0L; break; case BIO_CTRL_PENDING: - ret=(long)bm->length; + ret = (long)bm->length; break; case BIO_CTRL_DUP: case BIO_CTRL_FLUSH: - ret=1; + ret = 1; break; case BIO_CTRL_PUSH: case BIO_CTRL_POP: default: - ret=0; + ret = 0; break; - } - return(ret); } + return (ret); +} -static int mem_gets(BIO *bp, char *buf, int size) - { - int i,j; - int ret= -1; +static int +mem_gets(BIO *bp, char *buf, int size) +{ + int i, j; + int ret = -1; char *p; - BUF_MEM *bm=(BUF_MEM *)bp->ptr; + BUF_MEM *bm = (BUF_MEM *)bp->ptr; BIO_clear_retry_flags(bp); - j=bm->length; - if ((size-1) < j) j=size-1; - if (j <= 0) - { - *buf='\0'; + j = bm->length; + if ((size - 1) < j) + j = size - 1; + if (j <= 0) { + *buf = '\0'; return 0; - } - p=bm->data; - for (i=0; idata; + for (i = 0; i < j; i++) { + if (p[i] == '\n') { i++; break; - } } + } /* * i is now the max num of bytes to copy, either j or up to * and including the first newline */ - i=mem_read(bp,buf,i); - if (i > 0) buf[i]='\0'; - ret=i; - return(ret); - } + i = mem_read(bp, buf, i); + if (i > 0) + buf[i] = '\0'; + ret = i; + return (ret); +} -static int mem_puts(BIO *bp, const char *str) - { - int n,ret; +static int +mem_puts(BIO *bp, const char *str) +{ + int n, ret; - n=strlen(str); - ret=mem_write(bp,str,n); + n = strlen(str); + ret = mem_write(bp, str, n); /* memory semantics is that it will always work */ - return(ret); - } - + return (ret); +} diff --git a/src/lib/libssl/src/crypto/bio/bss_null.c b/src/lib/libssl/src/crypto/bio/bss_null.c index 46b73339df..51aed2ac4b 100644 --- a/src/lib/libssl/src/crypto/bio/bss_null.c +++ b/src/lib/libssl/src/crypto/bio/bss_null.c @@ -68,8 +68,8 @@ static int null_gets(BIO *h, char *str, int size); static long null_ctrl(BIO *h, int cmd, long arg1, void *arg2); static int null_new(BIO *h); static int null_free(BIO *data); -static BIO_METHOD null_method= - { + +static BIO_METHOD null_method = { BIO_TYPE_NULL, "NULL", null_write, @@ -80,50 +80,56 @@ static BIO_METHOD null_method= null_new, null_free, NULL, - }; +}; -BIO_METHOD *BIO_s_null(void) - { - return(&null_method); - } +BIO_METHOD +*BIO_s_null(void) +{ + return (&null_method); +} -static int null_new(BIO *bi) - { - bi->init=1; - bi->num=0; - bi->ptr=(NULL); - return(1); - } +static int +null_new(BIO *bi) +{ + bi->init = 1; + bi->num = 0; + bi->ptr = (NULL); + return (1); +} -static int null_free(BIO *a) - { - if (a == NULL) return(0); - return(1); - } - -static int null_read(BIO *b, char *out, int outl) - { - return(0); - } +static int +null_free(BIO *a) +{ + if (a == NULL) + return (0); + return (1); +} -static int null_write(BIO *b, const char *in, int inl) - { - return(inl); - } +static int +null_read(BIO *b, char *out, int outl) +{ + return (0); +} + +static int +null_write(BIO *b, const char *in, int inl) +{ + return (inl); +} -static long null_ctrl(BIO *b, int cmd, long num, void *ptr) - { - long ret=1; +static long +null_ctrl(BIO *b, int cmd, long num, void *ptr) +{ + long ret = 1; - switch (cmd) - { + switch (cmd) { case BIO_CTRL_RESET: case BIO_CTRL_EOF: case BIO_CTRL_SET: case BIO_CTRL_SET_CLOSE: case BIO_CTRL_FLUSH: case BIO_CTRL_DUP: - ret=1; + ret = 1; break; case BIO_CTRL_GET_CLOSE: case BIO_CTRL_INFO: @@ -131,20 +137,22 @@ static long null_ctrl(BIO *b, int cmd, long num, void *ptr) case BIO_CTRL_PENDING: case BIO_CTRL_WPENDING: default: - ret=0; + ret = 0; break; - } - return(ret); } + return (ret); +} -static int null_gets(BIO *bp, char *buf, int size) - { - return(0); - } - -static int null_puts(BIO *bp, const char *str) - { - if (str == NULL) return(0); - return(strlen(str)); - } +static int +null_gets(BIO *bp, char *buf, int size) +{ + return (0); +} +static int +null_puts(BIO *bp, const char *str) +{ + if (str == NULL) + return (0); + return (strlen(str)); +} diff --git a/src/lib/libssl/src/crypto/bio/bss_rtcp.c b/src/lib/libssl/src/crypto/bio/bss_rtcp.c index 7dae485564..84d01e58b4 100644 --- a/src/lib/libssl/src/crypto/bio/bss_rtcp.c +++ b/src/lib/libssl/src/crypto/bio/bss_rtcp.c @@ -73,31 +73,32 @@ typedef unsigned short io_channel; /*************************************************************************/ -struct io_status { short status, count; long flags; }; + struct io_status { short status, count; + long flags; +}; -struct rpc_msg { /* Should have member alignment inhibited */ - char channel; /* 'A'-app data. 'R'-remote client 'G'-global */ - char function; /* 'G'-get, 'P'-put, 'C'-confirm, 'X'-close */ - unsigned short int length; /* Amount of data returned or max to return */ - char data[4092]; /* variable data */ + struct rpc_msg { /* Should have member alignment inhibited */ + char channel; /* 'A'-app data. 'R'-remote client 'G'-global */ + char function; /* 'G'-get, 'P'-put, 'C'-confirm, 'X'-close */ + unsigned short int length; /* Amount of data returned or max to return */ + char data[4092]; /* variable data */ }; #define RPC_HDR_SIZE (sizeof(struct rpc_msg) - 4092) struct rpc_ctx { - int filled, pos; - struct rpc_msg msg; + int filled, pos; + struct rpc_msg msg; }; -static int rtcp_write(BIO *h,const char *buf,int num); -static int rtcp_read(BIO *h,char *buf,int size); -static int rtcp_puts(BIO *h,const char *str); -static int rtcp_gets(BIO *h,char *str,int size); -static long rtcp_ctrl(BIO *h,int cmd,long arg1,void *arg2); +static int rtcp_write(BIO *h, const char *buf, int num); +static int rtcp_read(BIO *h, char *buf, int size); +static int rtcp_puts(BIO *h, const char *str); +static int rtcp_gets(BIO *h, char *str, int size); +static long rtcp_ctrl(BIO *h, int cmd, long arg1, void *arg2); static int rtcp_new(BIO *h); static int rtcp_free(BIO *data); -static BIO_METHOD rtcp_method= - { +static BIO_METHOD rtcp_method = { BIO_TYPE_FD, "RTCP", rtcp_write, @@ -108,12 +109,13 @@ static BIO_METHOD rtcp_method= rtcp_new, rtcp_free, NULL, - }; +}; -BIO_METHOD *BIO_s_rtcp(void) - { - return(&rtcp_method); - } +BIO_METHOD +*BIO_s_rtcp(void) +{ + return (&rtcp_method); +} /*****************************************************************************/ /* Decnet I/O routines. */ @@ -123,25 +125,28 @@ BIO_METHOD *BIO_s_rtcp(void) #pragma message disable DOLLARID #endif -static int get ( io_channel chan, char *buffer, int maxlen, int *length ) +static int get(io_channel chan, char *buffer, int maxlen, int *length) { - int status; - struct io_status iosb; - status = sys$qiow ( 0, chan, IO$_READVBLK, &iosb, 0, 0, - buffer, maxlen, 0, 0, 0, 0 ); - if ( (status&1) == 1 ) status = iosb.status; - if ( (status&1) == 1 ) *length = iosb.count; - return status; + int status; + struct io_status iosb; + status = sys$qiow(0, chan, IO$_READVBLK, &iosb, 0, 0, buffer, maxlen, + 0, 0, 0, 0 ); + if ((status & 1) == 1) + status = iosb.status; + if ((status & 1) == 1 ) + *length = iosb.count; + return status; } -static int put ( io_channel chan, char *buffer, int length ) +static int put(io_channel chan, char *buffer, int length) { - int status; - struct io_status iosb; - status = sys$qiow ( 0, chan, IO$_WRITEVBLK, &iosb, 0, 0, - buffer, length, 0, 0, 0, 0 ); - if ( (status&1) == 1 ) status = iosb.status; - return status; + int status; + struct io_status iosb; + status = sys$qiow ( 0, chan, IO$_WRITEVBLK, &iosb, 0, 0, buffer, + length, 0, 0, 0, 0 ); + if ((status & 1) == 1) + status = iosb.status; + return status; } #ifdef __DECC @@ -150,109 +155,127 @@ static int put ( io_channel chan, char *buffer, int length ) /***************************************************************************/ -static int rtcp_new(BIO *bi) +static int +rtcp_new(BIO *bi) { - struct rpc_ctx *ctx; - bi->init=1; - bi->num=0; + struct rpc_ctx *ctx; + bi->init = 1; + bi->num = 0; bi->flags = 0; - bi->ptr=OPENSSL_malloc(sizeof(struct rpc_ctx)); - ctx = (struct rpc_ctx *) bi->ptr; + bi->ptr = OPENSSL_malloc(sizeof(struct rpc_ctx)); + ctx = (struct rpc_ctx *)bi->ptr; ctx->filled = 0; ctx->pos = 0; - return(1); + return (1); } -static int rtcp_free(BIO *a) +static int +rtcp_free(BIO *a) { - if (a == NULL) return(0); - if ( a->ptr ) OPENSSL_free ( a->ptr ); + if (a == NULL) + return (0); + if (a->ptr) + OPENSSL_free(a->ptr); a->ptr = NULL; - return(1); + return (1); } - -static int rtcp_read(BIO *b, char *out, int outl) + +static int +rtcp_read(BIO *b, char *out, int outl) { - int status, length; - struct rpc_ctx *ctx; - /* - * read data, return existing. - */ - ctx = (struct rpc_ctx *) b->ptr; - if ( ctx->pos < ctx->filled ) { - length = ctx->filled - ctx->pos; - if ( length > outl ) length = outl; - memmove ( out, &ctx->msg.data[ctx->pos], length ); - ctx->pos += length; - return length; - } - /* - * Requst more data from R channel. - */ - ctx->msg.channel = 'R'; - ctx->msg.function = 'G'; - ctx->msg.length = sizeof(ctx->msg.data); - status = put ( b->num, (char *) &ctx->msg, RPC_HDR_SIZE ); - if ( (status&1) == 0 ) { - return -1; - } - /* - * Read. - */ - ctx->pos = ctx->filled = 0; - status = get ( b->num, (char *) &ctx->msg, sizeof(ctx->msg), &length ); - if ( (status&1) == 0 ) length = -1; - if ( ctx->msg.channel != 'R' || ctx->msg.function != 'C' ) { - length = -1; - } - ctx->filled = length - RPC_HDR_SIZE; - - if ( ctx->pos < ctx->filled ) { - length = ctx->filled - ctx->pos; - if ( length > outl ) length = outl; - memmove ( out, ctx->msg.data, length ); - ctx->pos += length; - return length; - } + int status, length; + struct rpc_ctx *ctx; + /* + * read data, return existing. + */ + ctx = (struct rpc_ctx *)b->ptr; + if (ctx->pos < ctx->filled) { + length = ctx->filled - ctx->pos; + if (length > outl) + length = outl; + memmove(out, &ctx->msg.data[ctx->pos], length); + ctx->pos += length; + return length; + } + /* + * Requst more data from R channel. + */ + ctx->msg.channel = 'R'; + ctx->msg.function = 'G'; + ctx->msg.length = sizeof(ctx->msg.data); + status = put(b->num, (char *)&ctx->msg, RPC_HDR_SIZE); + if ((status & 1) == 0 ) { + return -1; + } + /* + * Read. + */ + ctx->pos = ctx->filled = 0; + status = get(b->num, (char *)&ctx->msg, sizeof(ctx->msg), &length); + if ((status & 1) == 0) + length = -1; + if (ctx->msg.channel != 'R' || ctx->msg.function != 'C') { + length = -1; + } + ctx->filled = length - RPC_HDR_SIZE; + + if (ctx->pos < ctx->filled) { + length = ctx->filled - ctx->pos; + if (length > outl) + length = outl; + memmove(out, ctx->msg.data, length); + ctx->pos += length; + return length; + } - return length; + return length; } -static int rtcp_write(BIO *b, const char *in, int inl) +static int +rtcp_write(BIO *b, const char *in, int inl) { - int status, i, segment, length; - struct rpc_ctx *ctx; - /* - * Output data, send in chunks no larger that sizeof(ctx->msg.data). - */ - ctx = (struct rpc_ctx *) b->ptr; - for ( i = 0; i < inl; i += segment ) { - segment = inl - i; - if ( segment > sizeof(ctx->msg.data) ) segment = sizeof(ctx->msg.data); - ctx->msg.channel = 'R'; - ctx->msg.function = 'P'; - ctx->msg.length = segment; - memmove ( ctx->msg.data, &in[i], segment ); - status = put ( b->num, (char *) &ctx->msg, segment + RPC_HDR_SIZE ); - if ((status&1) == 0 ) { i = -1; break; } + int status, i, segment, length; + struct rpc_ctx *ctx; + /* + * Output data, send in chunks no larger that sizeof(ctx->msg.data). + */ + ctx = (struct rpc_ctx *)b->ptr; + for (i = 0; i < inl; i += segment) { + segment = inl - i; + if (segment > sizeof(ctx->msg.data)) + segment = sizeof(ctx->msg.data); + ctx->msg.channel = 'R'; + ctx->msg.function = 'P'; + ctx->msg.length = segment; + memmove(ctx->msg.data, &in[i], segment); + status = put(b->num, (char *) &ctx->msg, + segment + RPC_HDR_SIZE); + if ((status & 1) == 0) { + i = -1; + break; + } - status = get ( b->num, (char *) &ctx->msg, sizeof(ctx->msg), &length ); - if ( ((status&1) == 0) || (length < RPC_HDR_SIZE) ) { i = -1; break; } - if ( (ctx->msg.channel != 'R') || (ctx->msg.function != 'C') ) { - printf("unexpected response when confirming put %c %c\n", - ctx->msg.channel, ctx->msg.function ); + status = get(b->num, (char *)&ctx->msg, sizeof(ctx->msg), + &length ); + if (((status&1) == 0) || (length < RPC_HDR_SIZE)) { + i = -1; + break; + } + if ((ctx->msg.channel != 'R') || (ctx->msg.function != 'C')) { + printf("unexpected response when confirming put %c %c\n", + ctx->msg.channel, ctx->msg.function ); + } } - } - return(i); + return (i); } -static long rtcp_ctrl(BIO *b, int cmd, long num, void *ptr) - { - long ret=1; +static long +rtcp_ctrl(BIO *b, int cmd, long num, void *ptr) +{ + long ret = 1; - switch (cmd) - { + switch (cmd) { case BIO_CTRL_RESET: case BIO_CTRL_EOF: ret = 1; @@ -260,11 +283,11 @@ static long rtcp_ctrl(BIO *b, int cmd, long num, void *ptr) case BIO_C_SET_FD: b->num = num; ret = 1; - break; + break; case BIO_CTRL_SET_CLOSE: case BIO_CTRL_FLUSH: case BIO_CTRL_DUP: - ret=1; + ret = 1; break; case BIO_CTRL_GET_CLOSE: case BIO_CTRL_INFO: @@ -272,23 +295,26 @@ static long rtcp_ctrl(BIO *b, int cmd, long num, void *ptr) case BIO_CTRL_PENDING: case BIO_CTRL_WPENDING: default: - ret=0; + ret = 0; break; - } - return(ret); - } - -static int rtcp_gets(BIO *bp, char *buf, int size) - { - return(0); } + return (ret); +} -static int rtcp_puts(BIO *bp, const char *str) +static int +rtcp_gets(BIO *bp, char *buf, int size) { - int length; - if (str == NULL) return(0); - length = strlen ( str ); - if ( length == 0 ) return (0); - return rtcp_write ( bp,str, length ); + return (0); } +static int +rtcp_puts(BIO *bp, const char *str) +{ + int length; + if (str == NULL) + return (0); + length = strlen(str); + if (length == 0) + return (0); + return rtcp_write(bp, str, length); +} diff --git a/src/lib/libssl/src/crypto/bio/bss_sock.c b/src/lib/libssl/src/crypto/bio/bss_sock.c index eb2965970c..f6d3bf7365 100644 --- a/src/lib/libssl/src/crypto/bio/bss_sock.c +++ b/src/lib/libssl/src/crypto/bio/bss_sock.c @@ -79,8 +79,7 @@ static int sock_new(BIO *h); static int sock_free(BIO *data); int BIO_sock_should_retry(int s); -static BIO_METHOD methods_sockp= - { +static BIO_METHOD methods_sockp = { BIO_TYPE_SOCKET, "socket", sock_write, @@ -91,152 +90,155 @@ static BIO_METHOD methods_sockp= sock_new, sock_free, NULL, - }; +}; -BIO_METHOD *BIO_s_socket(void) - { - return(&methods_sockp); - } +BIO_METHOD +*BIO_s_socket(void) +{ + return (&methods_sockp); +} -BIO *BIO_new_socket(int fd, int close_flag) - { +BIO +*BIO_new_socket(int fd, int close_flag) +{ BIO *ret; - ret=BIO_new(BIO_s_socket()); - if (ret == NULL) return(NULL); - BIO_set_fd(ret,fd,close_flag); - return(ret); - } + ret = BIO_new(BIO_s_socket()); + if (ret == NULL) + return (NULL); + BIO_set_fd(ret, fd, close_flag); + return (ret); +} -static int sock_new(BIO *bi) - { - bi->init=0; - bi->num=0; - bi->ptr=NULL; - bi->flags=0; - return(1); - } +static int +sock_new(BIO *bi) +{ + bi->init = 0; + bi->num = 0; + bi->ptr = NULL; + bi->flags = 0; + return (1); +} -static int sock_free(BIO *a) - { - if (a == NULL) return(0); - if (a->shutdown) - { - if (a->init) - { +static int +sock_free(BIO *a) +{ + if (a == NULL) + return (0); + if (a->shutdown) { + if (a->init) { shutdown(a->num, SHUT_RDWR); close(a->num); - } - a->init=0; - a->flags=0; } - return(1); + a->init = 0; + a->flags = 0; } - -static int sock_read(BIO *b, char *out, int outl) - { - int ret=0; + return (1); +} - if (out != NULL) - { +static int +sock_read(BIO *b, char *out, int outl) +{ + int ret = 0; + + if (out != NULL) { errno = 0; - ret=read(b->num,out,outl); + ret = read(b->num, out, outl); BIO_clear_retry_flags(b); - if (ret <= 0) - { + if (ret <= 0) { if (BIO_sock_should_retry(ret)) BIO_set_retry_read(b); - } } - return(ret); } + return (ret); +} -static int sock_write(BIO *b, const char *in, int inl) - { +static int +sock_write(BIO *b, const char *in, int inl) +{ int ret; - + errno = 0; - ret=write(b->num,in,inl); + ret = write(b->num, in, inl); BIO_clear_retry_flags(b); - if (ret <= 0) - { + if (ret <= 0) { if (BIO_sock_should_retry(ret)) BIO_set_retry_write(b); - } - return(ret); } + return (ret); +} -static long sock_ctrl(BIO *b, int cmd, long num, void *ptr) - { - long ret=1; +static long +sock_ctrl(BIO *b, int cmd, long num, void *ptr) +{ + long ret = 1; int *ip; - switch (cmd) - { + switch (cmd) { case BIO_C_SET_FD: sock_free(b); b->num= *((int *)ptr); - b->shutdown=(int)num; - b->init=1; + b->shutdown = (int)num; + b->init = 1; break; case BIO_C_GET_FD: - if (b->init) - { - ip=(int *)ptr; - if (ip != NULL) *ip=b->num; - ret=b->num; - } - else - ret= -1; + if (b->init) { + ip = (int *)ptr; + if (ip != NULL) + *ip = b->num; + ret = b->num; + } else + ret = -1; break; case BIO_CTRL_GET_CLOSE: - ret=b->shutdown; + ret = b->shutdown; break; case BIO_CTRL_SET_CLOSE: - b->shutdown=(int)num; + b->shutdown = (int)num; break; case BIO_CTRL_DUP: case BIO_CTRL_FLUSH: - ret=1; + ret = 1; break; default: - ret=0; + ret = 0; break; - } - return(ret); } + return (ret); +} -static int sock_puts(BIO *bp, const char *str) - { - int n,ret; +static int +sock_puts(BIO *bp, const char *str) +{ + int n, ret; - n=strlen(str); - ret=sock_write(bp,str,n); - return(ret); - } + n = strlen(str); + ret = sock_write(bp, str, n); + return (ret); +} -int BIO_sock_should_retry(int i) - { +int +BIO_sock_should_retry(int i) +{ int err; - if ((i == 0) || (i == -1)) - { - err=errno; + if ((i == 0) || (i == -1)) { + err = errno; #if defined(OPENSSL_SYS_WINDOWS) && 0 /* more microsoft stupidity? perhaps not? Ben 4/1/99 */ if ((i == -1) && (err == 0)) - return(1); + return (1); #endif - return(BIO_sock_non_fatal_error(err)); - } - return(0); + return (BIO_sock_non_fatal_error(err)); } + return (0); +} -int BIO_sock_non_fatal_error(int err) - { - switch (err) - { +int +BIO_sock_non_fatal_error(int err) +{ + switch (err) { #if defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_NETWARE) # if defined(WSAEWOULDBLOCK) case WSAEWOULDBLOCK: @@ -284,12 +286,12 @@ int BIO_sock_non_fatal_error(int err) #ifdef EALREADY case EALREADY: #endif - return(1); + return (1); /* break; */ default: break; - } - return(0); } + return (0); +} #endif /* #ifndef OPENSSL_NO_SOCK */ -- cgit v1.2.3-55-g6feb