diff -Naur xen-unstable-trp-sdp-pristine/stubdom/openssl.patch xen-unstable-trp-sdp/stubdom/openssl.patch --- xen-unstable-trp-sdp-pristine/stubdom/openssl.patch 1969-12-31 19:00:00.000000000 -0500 +++ xen-unstable-trp-sdp/stubdom/openssl.patch 2011-02-23 19:40:48.000000000 -0500 @@ -0,0 +1,945 @@ +diff -Naur openssl-1.0.0a.pristine/crypto/bio/b_print.c openssl-1.0.0a/crypto/bio/b_print.c +--- openssl-1.0.0a.pristine/crypto/bio/b_print.c 2010-10-21 16:08:44.000000000 -0400 ++++ openssl-1.0.0a/crypto/bio/b_print.c 2010-10-29 11:32:48.000000000 -0400 +@@ -109,660 +109,6 @@ + * o ... (for OpenSSL) + */ + +-#ifdef HAVE_LONG_DOUBLE +-#define LDOUBLE long double +-#else +-#define LDOUBLE double +-#endif +- +-#ifdef HAVE_LONG_LONG +-# if defined(_WIN32) && !defined(__GNUC__) +-# define LLONG __int64 +-# else +-# define LLONG long long +-# endif +-#else +-#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); +- +-/* format read states */ +-#define DP_S_DEFAULT 0 +-#define DP_S_FLAGS 1 +-#define DP_S_MIN 2 +-#define DP_S_DOT 3 +-#define DP_S_MAX 4 +-#define DP_S_MOD 5 +-#define DP_S_CONV 6 +-#define DP_S_DONE 7 +- +-/* format flags - Bits */ +-#define DP_F_MINUS (1 << 0) +-#define DP_F_PLUS (1 << 1) +-#define DP_F_SPACE (1 << 2) +-#define DP_F_NUM (1 << 3) +-#define DP_F_ZERO (1 << 4) +-#define DP_F_UP (1 << 5) +-#define DP_F_UNSIGNED (1 << 6) +- +-/* conversion flags */ +-#define DP_C_SHORT 1 +-#define DP_C_LONG 2 +-#define DP_C_LDOUBLE 3 +-#define DP_C_LLONG 4 +- +-/* some handy macros */ +-#define char_to_int(p) (p - '0') +-#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) +-{ +- 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; +- } +- } +- *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) +-{ +- 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) +-{ +- 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; +-} +- +-static LDOUBLE +-pow_10(int in_exp) +-{ +- 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; +-} +- +-static void +-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; +- } +-} +- +-static void +-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); +- } +- *sbuffer = NULL; +- } else { +- *maxlen += 1024; +- *buffer = OPENSSL_realloc(*buffer, *maxlen); +- } +- } +- /* 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; +- } +- +- return; +-} +- + /***************************************************************************/ + + int BIO_printf (BIO *bio, const char *format, ...) +@@ -780,31 +126,7 @@ + + 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 +- or DOS programs. */ +- char *hugebufp = hugebuf; +- size_t hugebufsize = sizeof(hugebuf); +- char *dynbuf = NULL; +- int ignored; +- +- dynbuf = NULL; +- CRYPTO_push_info("doapr()"); +- _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); ++ return -1; + } + + /* As snprintf is not available everywhere, we provide our own implementation. +@@ -826,17 +148,5 @@ + + int BIO_vsnprintf(char *buf, size_t n, const char *format, va_list args) + { +- size_t retlen; +- int truncated; +- +- _dopr(&buf, NULL, &n, &retlen, &truncated, format, args); +- +- if (truncated) +- /* In case of truncation, return -1 like traditional snprintf. +- * (Current drafts for ISO/IEC 9899 say snprintf should return +- * the number of characters that would have been written, +- * had the buffer been large enough.) */ +- return -1; +- else +- return (retlen <= INT_MAX) ? (int)retlen : -1; ++ return -1; + } +diff -Naur openssl-1.0.0a.pristine/crypto/rand/rand_egd.c openssl-1.0.0a/crypto/rand/rand_egd.c +--- openssl-1.0.0a.pristine/crypto/rand/rand_egd.c 2010-10-21 16:08:44.000000000 -0400 ++++ openssl-1.0.0a/crypto/rand/rand_egd.c 2010-10-29 11:31:16.000000000 -0400 +@@ -95,7 +95,6 @@ + * RAND_egd() is a wrapper for RAND_egd_bytes() with numbytes=255. + */ + +-#if defined(OPENSSL_SYS_WIN32) || defined(OPENSSL_SYS_VMS) || defined(OPENSSL_SYS_MSDOS) || defined(OPENSSL_SYS_VXWORKS) || defined(OPENSSL_SYS_NETWARE) || defined(OPENSSL_SYS_VOS) || defined(OPENSSL_SYS_BEOS) + int RAND_query_egd_bytes(const char *path, unsigned char *buf, int bytes) + { + return(-1); +@@ -109,195 +108,3 @@ + { + return(-1); + } +-#else +-#include +-#include OPENSSL_UNISTD +-#include +-#include +-#ifndef NO_SYS_UN_H +-# ifdef OPENSSL_SYS_VXWORKS +-# include +-# else +-# include +-# endif +-#else +-struct sockaddr_un { +- short sun_family; /* AF_UNIX */ +- char sun_path[108]; /* path name (gag) */ +-}; +-#endif /* NO_SYS_UN_H */ +-#include +-#include +- +-#ifndef offsetof +-# define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER) +-#endif +- +-int RAND_query_egd_bytes(const char *path, unsigned char *buf, int bytes) +- { +- int ret = 0; +- struct sockaddr_un addr; +- int len, num, numbytes; +- int fd = -1; +- int success; +- unsigned char egdbuf[2], tempbuf[255], *retrievebuf; +- +- memset(&addr, 0, sizeof(addr)); +- addr.sun_family = AF_UNIX; +- if (strlen(path) >= sizeof(addr.sun_path)) +- return (-1); +- BUF_strlcpy(addr.sun_path,path,sizeof addr.sun_path); +- len = offsetof(struct sockaddr_un, sun_path) + strlen(path); +- fd = socket(AF_UNIX, SOCK_STREAM, 0); +- if (fd == -1) return (-1); +- success = 0; +- while (!success) +- { +- if (connect(fd, (struct sockaddr *)&addr, len) == 0) +- success = 1; +- else +- { +- switch (errno) +- { +-#ifdef EINTR +- case EINTR: +-#endif +-#ifdef EAGAIN +- case EAGAIN: +-#endif +-#ifdef EINPROGRESS +- case EINPROGRESS: +-#endif +-#ifdef EALREADY +- case EALREADY: +-#endif +- /* No error, try again */ +- break; +-#ifdef EISCONN +- case EISCONN: +- success = 1; +- break; +-#endif +- default: +- goto err; /* failure */ +- } +- } +- } +- +- while(bytes > 0) +- { +- egdbuf[0] = 1; +- egdbuf[1] = bytes < 255 ? bytes : 255; +- numbytes = 0; +- while (numbytes != 2) +- { +- num = write(fd, egdbuf + numbytes, 2 - numbytes); +- if (num >= 0) +- numbytes += num; +- else +- { +- switch (errno) +- { +-#ifdef EINTR +- case EINTR: +-#endif +-#ifdef EAGAIN +- case EAGAIN: +-#endif +- /* No error, try again */ +- break; +- default: +- ret = -1; +- goto err; /* failure */ +- } +- } +- } +- numbytes = 0; +- while (numbytes != 1) +- { +- num = read(fd, egdbuf, 1); +- if (num == 0) +- goto err; /* descriptor closed */ +- else if (num > 0) +- numbytes += num; +- else +- { +- switch (errno) +- { +-#ifdef EINTR +- case EINTR: +-#endif +-#ifdef EAGAIN +- case EAGAIN: +-#endif +- /* No error, try again */ +- break; +- default: +- ret = -1; +- goto err; /* failure */ +- } +- } +- } +- if(egdbuf[0] == 0) +- goto err; +- if (buf) +- retrievebuf = buf + ret; +- else +- retrievebuf = tempbuf; +- numbytes = 0; +- while (numbytes != egdbuf[0]) +- { +- num = read(fd, retrievebuf + numbytes, egdbuf[0] - numbytes); +- if (num == 0) +- goto err; /* descriptor closed */ +- else if (num > 0) +- numbytes += num; +- else +- { +- switch (errno) +- { +-#ifdef EINTR +- case EINTR: +-#endif +-#ifdef EAGAIN +- case EAGAIN: +-#endif +- /* No error, try again */ +- break; +- default: +- ret = -1; +- goto err; /* failure */ +- } +- } +- } +- ret += egdbuf[0]; +- bytes -= egdbuf[0]; +- if (!buf) +- RAND_seed(tempbuf, egdbuf[0]); +- } +- err: +- if (fd != -1) close(fd); +- return(ret); +- } +- +- +-int RAND_egd_bytes(const char *path, int bytes) +- { +- int num, ret = 0; +- +- num = RAND_query_egd_bytes(path, NULL, bytes); +- if (num < 1) goto err; +- if (RAND_status() == 1) +- ret = num; +- err: +- return(ret); +- } +- +- +-int RAND_egd(const char *path) +- { +- return (RAND_egd_bytes(path, 255)); +- } +- +- +-#endif +diff -Naur openssl-1.0.0a.pristine/e_os.h openssl-1.0.0a/e_os.h +--- openssl-1.0.0a.pristine/e_os.h 2010-10-21 16:08:44.000000000 -0400 ++++ openssl-1.0.0a/e_os.h 2010-10-29 11:31:16.000000000 -0400 +@@ -76,18 +76,6 @@ + #define REF_PRINT(a,b) fprintf(stderr,"%08X:%4d:%s\n",(int)b,b->references,a) + #endif + +-#ifndef DEVRANDOM +-/* set this to a comma-separated list of 'random' device files to try out. +- * My default, we will try to read at least one of these files */ +-#define DEVRANDOM "/dev/urandom","/dev/random","/dev/srandom" +-#endif +-#ifndef DEVRANDOM_EGD +-/* set this to a comma-seperated list of 'egd' sockets to try out. These +- * sockets will be tried in the order listed in case accessing the device files +- * listed in DEVRANDOM did not return enough entropy. */ +-#define DEVRANDOM_EGD "/var/run/egd-pool","/dev/egd-pool","/etc/egd-pool","/etc/entropy" +-#endif +- + #if defined(OPENSSL_SYS_VXWORKS) + # define NO_SYS_PARAM_H + # define NO_CHMOD diff -Naur xen-unstable-trp-sdp-pristine/stubdom/polarssl.patch xen-unstable-trp-sdp/stubdom/polarssl.patch --- xen-unstable-trp-sdp-pristine/stubdom/polarssl.patch 1969-12-31 19:00:00.000000000 -0500 +++ xen-unstable-trp-sdp/stubdom/polarssl.patch 2011-02-23 19:40:48.000000000 -0500 @@ -0,0 +1,23 @@ +diff -Naur polarssl-0.12.1-pristine/include/polarssl/config.h polarssl-0.12.1/include/polarssl/config.h +--- polarssl-0.12.1-pristine/include/polarssl/config.h 2010-11-03 14:50:09.000000000 -0400 ++++ polarssl-0.12.1/include/polarssl/config.h 2010-11-04 10:24:29.000000000 -0400 +@@ -221,7 +221,7 @@ + * + * This module provides TCP/IP networking routines. + */ +-#define POLARSSL_NET_C ++//#define POLARSSL_NET_C + + /* + * Module: library/padlock.c +diff -Naur polarssl-0.12.1-pristine/library/timing.c polarssl-0.12.1/library/timing.c +--- polarssl-0.12.1-pristine/library/timing.c 2010-11-03 14:50:09.000000000 -0400 ++++ polarssl-0.12.1/library/timing.c 2010-11-04 10:30:56.000000000 -0400 +@@ -42,6 +42,7 @@ + #include + #include + #include ++#include + #include + #include + diff -Naur xen-unstable-trp-sdp-pristine/stubdom/tpmemu-0.6.1.patch xen-unstable-trp-sdp/stubdom/tpmemu-0.6.1.patch --- xen-unstable-trp-sdp-pristine/stubdom/tpmemu-0.6.1.patch 1969-12-31 19:00:00.000000000 -0500 +++ xen-unstable-trp-sdp/stubdom/tpmemu-0.6.1.patch 2011-02-23 19:40:48.000000000 -0500 @@ -0,0 +1,78 @@ +diff -Naur tpm_emulator-0.6.1-pristine/tpm/tpm_data.c tpm_emulator-0.6.1/tpm/tpm_data.c +--- tpm_emulator-0.6.1-pristine/tpm/tpm_data.c 2009-10-09 05:07:22.000000000 -0400 ++++ tpm_emulator-0.6.1/tpm/tpm_data.c 2011-02-18 14:23:16.000000000 -0500 +@@ -246,8 +246,7 @@ + || tpm_unmarshal_TPM_PERMANENT_DATA(&ptr, &len, &tpmData.permanent.data) + || tpm_unmarshal_TPM_STCLEAR_FLAGS(&ptr, &len, &tpmData.stclear.flags) + || tpm_unmarshal_TPM_STCLEAR_DATA(&ptr, &len, &tpmData.stclear.data) +- || tpm_unmarshal_TPM_STANY_DATA(&ptr, &len, &tpmData.stany.data) +- || len > 0) { ++ || tpm_unmarshal_TPM_STANY_DATA(&ptr, &len, &tpmData.stany.data)) { + tpm_free(buf); + return -1; + } +diff -Naur tpm_emulator-0.6.1-pristine/tpmd/Makefile tpm_emulator-0.6.1/tpmd/Makefile +--- tpm_emulator-0.6.1-pristine/tpmd/Makefile 2009-10-09 05:07:22.000000000 -0400 ++++ tpm_emulator-0.6.1/tpmd/Makefile 2011-02-18 14:23:16.000000000 -0500 +@@ -39,3 +39,5 @@ + + .PHONY: all clean install + ++.PHONY: objs ++objs: $(OBJS) +diff -Naur tpm_emulator-0.6.1-pristine/tpmd/tpm_emulator_config.h tpm_emulator-0.6.1/tpmd/tpm_emulator_config.h +--- tpm_emulator-0.6.1-pristine/tpmd/tpm_emulator_config.h 2009-10-09 05:07:22.000000000 -0400 ++++ tpm_emulator-0.6.1/tpmd/tpm_emulator_config.h 2011-02-18 14:25:22.000000000 -0500 +@@ -21,16 +21,12 @@ + #include + #include + #include +-#if defined(__linux__) +-#include +-#elif (defined(__OpenBSD__) || defined(__FreeBSD__)) +-#include +-#endif ++#include + + /* TPM emulator configuration */ + +-#undef TPM_STRONG_PERSISTENCE +-#undef TPM_GENERATE_EK ++#define TPM_STRONG_PERSISTENCE ++#define TPM_GENERATE_EK + #undef TPM_GENERATE_SEED_DAA + #undef TPM_MEMORY_ALIGNMENT_MANDATORY + #undef TPM_USE_INTERNAL_PRNG +@@ -85,19 +81,19 @@ + + #if defined(__linux__) + +-#define CPU_TO_BE64(x) __cpu_to_be64(x) +-#define CPU_TO_LE64(x) __cpu_to_le64(x) +-#define CPU_TO_BE32(x) __cpu_to_be32(x) +-#define CPU_TO_LE32(x) __cpu_to_le32(x) +-#define CPU_TO_BE16(x) __cpu_to_be16(x) +-#define CPU_TO_LE16(x) __cpu_to_le16(x) +- +-#define BE64_TO_CPU(x) __be64_to_cpu(x) +-#define LE64_TO_CPU(x) __le64_to_cpu(x) +-#define BE32_TO_CPU(x) __be32_to_cpu(x) +-#define LE32_TO_CPU(x) __le32_to_cpu(x) +-#define BE16_TO_CPU(x) __be16_to_cpu(x) +-#define LE16_TO_CPU(x) __le16_to_cpu(x) ++#define CPU_TO_BE64(x) cpu_to_be64(x) ++#define CPU_TO_LE64(x) cpu_to_le64(x) ++#define CPU_TO_BE32(x) cpu_to_be32(x) ++#define CPU_TO_LE32(x) cpu_to_le32(x) ++#define CPU_TO_BE16(x) cpu_to_be16(x) ++#define CPU_TO_LE16(x) cpu_to_le16(x) ++ ++#define BE64_TO_CPU(x) be64_to_cpu(x) ++#define LE64_TO_CPU(x) le64_to_cpu(x) ++#define BE32_TO_CPU(x) be32_to_cpu(x) ++#define LE32_TO_CPU(x) le32_to_cpu(x) ++#define BE16_TO_CPU(x) be16_to_cpu(x) ++#define LE16_TO_CPU(x) le16_to_cpu(x) + + #elif defined(__OpenBSD__) + diff -Naur xen-unstable-trp-sdp-pristine/stubdom/Makefile xen-unstable-trp-sdp/stubdom/Makefile --- xen-unstable-trp-sdp-pristine/stubdom/Makefile 2011-02-23 14:47:26.000000000 -0500 +++ xen-unstable-trp-sdp/stubdom/Makefile 2011-02-23 19:40:48.000000000 -0500 @@ -27,6 +27,22 @@ #OCAML_URL?=$(XEN_EXTFILES_URL) OCAML_URL?=http://caml.inria.fr/pub/distrib/ocaml-3.11 OCAML_VERSION=3.11.0 + +GMP_VERSION=4.3.2 +#GMP_URL?=$(XEN_EXTFILES_URL) +GMP_URL?=ftp://ftp.gmplib.org/pub/gmp-$(GMP_VERSION) + +POLARSSL_VERSION=0.12.1 +#POLARSSL_URL?=$(XEN_EXTFILES_URL) +POLARSSL_URL?=http://polarssl.org/code/releases + +OPENSSL_VERSION=1.0.0a +#OPENSSL_URL?=$(XEN_EXTFILES_URL) +OPENSSL_URL?=http://www.openssl.org/source + +TPMEMU_VERSION=0.6.1 +#TPMEMU_URL?=$(XEN_EXTFILES_URL) +TPMEMU_URL?=http://download.berlios.de/tpm-emulator WGET=wget -c @@ -177,6 +209,125 @@ touch $@ ############# +# cross-gmp +############# +gmp-$(GMP_VERSION).tar.bz2: + $(WGET) $(GMP_URL)/$@ + +.PHONY: cross-gmp +ifeq ($(XEN_TARGET_ARCH), x86_32) + GMPEXT=ABI=32 +endif +gmp-$(XEN_TARGET_ARCH): gmp-$(GMP_VERSION).tar.bz2 $(NEWLIB_STAMPFILE) + tar xjf $< + mv gmp-$(GMP_VERSION) $@ + #patch -d $@ -p0 < gmp.patch + cd $@; CPPFLAGS="-isystem $(CROSS_PREFIX)/$(GNU_TARGET_ARCH)-xen-elf/include $(TARGET_CPPFLAGS)" CFLAGS="$(TARGET_CFLAGS)" CC=$(CC) $(GMPEXT) ./configure --disable-shared --enable-static --disable-fft --without-readline --prefix=$(CROSS_PREFIX)/$(GNU_TARGET_ARCH)-xen-elf + sed -i 's/#define HAVE_OBSTACK_VPRINTF 1/\/\/#define HAVE_OBSTACK_VPRINTF 1/' $@/config.h + touch $@ + +GMP_STAMPFILE=$(CROSS_ROOT)/$(GNU_TARGET_ARCH)-xen-elf/lib/libgmp.a +cross-gmp: $(GMP_STAMPFILE) +$(GMP_STAMPFILE): gmp-$(XEN_TARGET_ARCH) + ( cd $< && \ + $(MAKE) && \ + $(MAKE) install ) + +############# +# cross-polarssl +############# +polarssl-$(POLARSSL_VERSION)-gpl.tgz: + $(WGET) $(POLARSSL_URL)/$@ + +polarssl-$(XEN_TARGET_ARCH): polarssl-$(POLARSSL_VERSION)-gpl.tgz + tar xzf $< + mv polarssl-$(POLARSSL_VERSION) $@ + patch -d $@ -p1 < polarssl.patch + touch $@ + +POLARSSL_STAMPFILE=$(CROSS_ROOT)/$(GNU_TARGET_ARCH)-xen-elf/lib/libpolarssl.a +cross-polarssl: $(POLARSSL_STAMPFILE) +$(POLARSSL_STAMPFILE): polarssl-$(XEN_TARGET_ARCH) $(NEWLIB_STAMPFILE) lwip-$(XEN_TARGET_ARCH) + ( cd $\"]@#include @" $${file}; done; \ + done + install -m 0644 $