generic-library/openssl
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Modify access to EGD socket to deal with EINTR etc that can appear

Browse Source 
during connect() and other calls. First seen on Unixware-7.

Unify access to EGD-socket for all RAND_egd_*() methods.
This commit is contained in:
Lutz Jänicke 2001-02-07 22:13:38 +00:00
parent deb2c1a1c5
commit a8ebe4697e
1 changed files with 164 additions and 75 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

219
crypto/rand/rand_egd.c
View File

@ -1,5 +1,5 @@
/* crypto/rand/rand_egd.c */ /* crypto/rand/rand_egd.c */
/* Written by Ulf Moeller for the OpenSSL project. */ /* Written by Ulf Moeller and Lutz Jaenicke for the OpenSSL project. */
/* ==================================================================== /* ====================================================================
* Copyright (c) 1998-2000 The OpenSSL Project. All rights reserved. * Copyright (c) 1998-2000 The OpenSSL Project. All rights reserved.
* *
@ -56,7 +56,41 @@
#include <openssl/rand.h> #include <openssl/rand.h>
/* Query the EGD <URL: http://www.lothar.com/tech/crypto/>. /*
* Query the EGD <URL: http://www.lothar.com/tech/crypto/>.
*
* This module supplies three routines:
*
* RAND_query_egd_bytes(path, buf, bytes)
* will actually query "bytes" bytes of entropy form the egd-socket located
* at path and will write them to buf (if supplied) or will directly feed
* it to RAND_seed() if buf==NULL.
* The number of bytes is not limited by the maximum chunk size of EGD,
* which is 255 bytes. If more than 255 bytes are wanted, several chunks
* of entropy bytes are requested. The connection is left open until the
* query is competed.
* RAND_query_egd_bytes() returns with
* -1 if an error occured during connection or communication.
* num the number of bytes read from the EGD socket. This number is either
* the number of bytes requested or smaller, if the EGD pool is
* drained and the daemon signals that the pool is empty.
* This routine does not touch any RAND_status(). This is necessary, since
* PRNG functions may call it during initialization.
*
* RAND_egd_bytes(path, bytes) will query "bytes" bytes and have them
* used to seed the PRNG.
* RAND_egd_bytes() is a wrapper for RAND_query_egd_bytes() with buf=NULL.
* Unlike RAND_query_egd_bytes(), RAND_status() is used to test the
* seed status so that the return value can reflect the seed state:
* -1 if an error occured during connection or communication _or_
* if the PRNG has still not received the required seeding.
* num the number of bytes read from the EGD socket. This number is either
* the number of bytes requested or smaller, if the EGD pool is
* drained and the daemon signals that the pool is empty.
*
* RAND_egd(path) will query 255 bytes and use the bytes retreived to seed
* the PRNG.
* RAND_egd() is a wrapper for RAND_egd_bytes() with numbytes=255.
*/ */
#if defined(WIN32) || defined(VMS) || defined(__VMS) #if defined(WIN32) || defined(VMS) || defined(__VMS)
@ -80,6 +114,7 @@ int RAND_egd_bytes(const char *path,int bytes)
#include <sys/socket.h> #include <sys/socket.h>
#include <sys/un.h> #include <sys/un.h>
#include <string.h> #include <string.h>
#include <errno.h>
#ifndef offsetof #ifndef offsetof
# define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER) # define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
@ -89,9 +124,10 @@ int RAND_query_egd_bytes(const char *path, unsigned char *buf, int bytes)
{ {
int ret = 0; int ret = 0;
struct sockaddr_un addr; struct sockaddr_un addr;
int len, num; int len, num, numbytes;
int fd = -1; int fd = -1;
unsigned char egdbuf[2]; int success;
unsigned char egdbuf[2], tempbuf[255], *retrievebuf;
memset(&addr, 0, sizeof(addr)); memset(&addr, 0, sizeof(addr));
addr.sun_family = AF_UNIX; addr.sun_family = AF_UNIX;
@ -101,96 +137,149 @@ int RAND_query_egd_bytes(const char *path, unsigned char *buf, int bytes)
len = offsetof(struct sockaddr_un, sun_path) + strlen(path); len = offsetof(struct sockaddr_un, sun_path) + strlen(path);
fd = socket(AF_UNIX, SOCK_STREAM, 0); fd = socket(AF_UNIX, SOCK_STREAM, 0);
if (fd == -1) return (-1); if (fd == -1) return (-1);
if (connect(fd, (struct sockaddr *)&addr, len) == -1) goto err; 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) while(bytes > 0)
{ {
egdbuf[0] = 1; egdbuf[0] = 1;
egdbuf[1] = bytes < 255 ? bytes : 255; egdbuf[1] = bytes < 255 ? bytes : 255;
write(fd, egdbuf, 2); numbytes = 0;
if (read(fd, egdbuf, 1) != 1) while (numbytes != 2)
{ {
ret=-1; num = write(fd, egdbuf + numbytes, 2 - numbytes);
goto err; 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)
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) if(egdbuf[0] == 0)
goto err; goto err;
num = read(fd, buf + ret, egdbuf[0]); if (buf)
if (num < 1) retrievebuf = buf + ret;
else
retrievebuf = tempbuf;
numbytes = 0;
while (numbytes != egdbuf[0])
{ {
ret=-1; num = read(fd, retrievebuf + numbytes, egdbuf[0] - numbytes);
goto err; 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 += num; }
bytes-=num; }
ret += egdbuf[0];
bytes -= egdbuf[0];
if (!buf)
RAND_seed(tempbuf, egdbuf[0]);
} }
err: err:
if (fd != -1) close(fd); if (fd != -1) close(fd);
return(ret); return(ret);
} }
int RAND_egd(const char *path)
int RAND_egd_bytes(const char *path, int bytes)
{ {
int num, ret = 0; int num, ret = 0;
unsigned char buf[256];
num = RAND_query_egd_bytes(path, buf, 255); num = RAND_query_egd_bytes(path, NULL, bytes);
if (num < 1) goto err; if (num < 1) goto err;
RAND_seed(buf, num);
if (RAND_status() == 1) if (RAND_status() == 1)
ret = num; ret = num;
err: err:
return(ret); return(ret);
} }
int RAND_egd_bytes(const char *path,int bytes)
{
int ret = 0;
struct sockaddr_un addr;
int len, num;
int fd = -1;
unsigned char buf[255];
memset(&addr, 0, sizeof(addr)); int RAND_egd(const char *path)
addr.sun_family = AF_UNIX;
if (strlen(path) > sizeof(addr.sun_path))
return (-1);
strcpy(addr.sun_path,path);
len = offsetof(struct sockaddr_un, sun_path) + strlen(path);
fd = socket(AF_UNIX, SOCK_STREAM, 0);
if (fd == -1) return (-1);
if (connect(fd, (struct sockaddr *)&addr, len) == -1) goto err;
while(bytes > 0)
{ {
buf[0] = 1; return (RAND_egd_bytes(path, 255));
buf[1] = bytes < 255 ? bytes : 255;
write(fd, buf, 2);
if (read(fd, buf, 1) != 1)
{
ret=-1;
goto err;
}
if(buf[0] == 0)
goto err;
num = read(fd, buf, buf[0]);
if (num < 1)
{
ret=-1;
goto err;
}
RAND_seed(buf, num);
if (RAND_status() != 1)
{
ret=-1;
goto err;
}
ret += num;
bytes-=num;
}
err:
if (fd != -1) close(fd);
return(ret);
} }