int
key_gendes (des_block *key)
{
struct sockaddr_in sin;
CLIENT *client;
int socket;
enum clnt_stat stat;
sin.sin_family = AF_INET;
sin.sin_port = 0;
sin.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
__bzero (sin.sin_zero, sizeof (sin.sin_zero));
socket = RPC_ANYSOCK;
client = INTUSE(clntudp_bufcreate) (&sin, (u_long) KEY_PROG,
(u_long) KEY_VERS, trytimeout, &socket,
RPCSMALLMSGSIZE, RPCSMALLMSGSIZE);
if (client == NULL)
return -1;
stat = clnt_call (client, KEY_GEN, (xdrproc_t) INTUSE(xdr_void), NULL,
(xdrproc_t) INTUSE(xdr_des_block), (caddr_t) key,
tottimeout);
clnt_destroy (client);
__close (socket);
if (stat != RPC_SUCCESS)
return -1;
return 0;
}
static void
universal (struct svc_req *rqstp, SVCXPRT *transp_l)
{
int prog, proc;
char *outdata;
char xdrbuf[UDPMSGSIZE];
struct proglst_ *pl;
char *buf = NULL;
/*
* enforce "procnum 0 is echo" convention
*/
if (rqstp->rq_proc == NULLPROC)
{
if (INTUSE(svc_sendreply) (transp_l, (xdrproc_t)INTUSE(xdr_void),
(char *) NULL) == FALSE)
{
__write (STDERR_FILENO, "xxx\n", 4);
exit (1);
}
return;
}
prog = rqstp->rq_prog;
proc = rqstp->rq_proc;
for (pl = proglst; pl != NULL; pl = pl->p_nxt)
if (pl->p_prognum == prog && pl->p_procnum == proc)
{
/* decode arguments into a CLEAN buffer */
__bzero (xdrbuf, sizeof (xdrbuf)); /* required ! */
if (!svc_getargs (transp_l, pl->p_inproc, xdrbuf))
{
INTUSE(svcerr_decode) (transp_l);
return;
}
outdata = (*(pl->p_progname)) (xdrbuf);
if (outdata == NULL && pl->p_outproc != (xdrproc_t)INTUSE(xdr_void))
/* there was an error */
return;
if (!INTUSE(svc_sendreply) (transp_l, pl->p_outproc, outdata))
{
if (__asprintf (&buf, _("trouble replying to prog %d\n"),
pl->p_prognum) < 0)
buf = NULL;
goto err_out2;
}
/* free the decoded arguments */
(void) svc_freeargs (transp_l, pl->p_inproc, xdrbuf);
return;
}
if (__asprintf (&buf, _("never registered prog %d\n"), prog) < 0)
buf = NULL;
err_out2:
if (buf == NULL)
exit (1);
__fxprintf (NULL, "%s", buf);
free (buf);
exit (1);
}
void cmain (void)
{
/*
* init variable sections
*/
__memcpy (__sdata2_start, __sdata2_load, __sdata2_end - __sdata2_start);
__memcpy (__sdata_start , __sdata_load , __sdata_end - __sdata_start);
__memcpy (__data_start , __data_load , __data_end - __data_start);
__bzero (__sbss2_start , __sbss2_end - __sbss2_start);
__bzero (__sbss_start , __sbss_end - __sbss_start);
__bzero (__bss_start , __bss_end - __bss_start);
/* printk( "start of BSP\n"); */
boot_card(0);
/* printk( "end of BSP\n"); */
__outb (0x92, 0x01);
while (1)
;
}
/*
* Bind a socket to a privileged IP port
*/
int
bindresvport (int sd, struct sockaddr_in *sin)
{
static short port;
struct sockaddr_in myaddr;
int i;
#define STARTPORT 600
#define LOWPORT 512
#define ENDPORT (IPPORT_RESERVED - 1)
#define NPORTS (ENDPORT - STARTPORT + 1)
static short startport = STARTPORT;
if (sin == (struct sockaddr_in *) 0)
{
sin = &myaddr;
__bzero (sin, sizeof (*sin));
sin->sin_family = AF_INET;
}
else if (sin->sin_family != AF_INET)
{
__set_errno (EAFNOSUPPORT);
return -1;
}
if (port == 0)
{
port = (__getpid () % NPORTS) + STARTPORT;
}
/* Initialize to make gcc happy. */
int res = -1;
int nports = ENDPORT - startport + 1;
int endport = ENDPORT;
again:
for (i = 0; i < nports; ++i)
{
sin->sin_port = htons (port++);
if (port > endport)
port = startport;
res = __bind (sd, (const struct sockaddr *)sin, sizeof (struct sockaddr_in));
if (res >= 0 || errno != EADDRINUSE)
break;
}
if (i == nports && startport != LOWPORT)
{
startport = LOWPORT;
endport = STARTPORT - 1;
nports = STARTPORT - LOWPORT;
port = LOWPORT + port % (STARTPORT - LOWPORT);
goto again;
}
return res;
}
/*
* Usage:
* xprt = svctcp_create(sock, send_buf_size, recv_buf_size);
*
* Creates, registers, and returns a (rpc) tcp based transporter.
* Once *xprt is initialized, it is registered as a transporter
* see (svc.h, xprt_register). This routine returns
* a NULL if a problem occurred.
*
* If sock<0 then a socket is created, else sock is used.
* If the socket, sock is not bound to a port then svctcp_create
* binds it to an arbitrary port. The routine then starts a tcp
* listener on the socket's associated port. In any (successful) case,
* xprt->xp_sock is the registered socket number and xprt->xp_port is the
* associated port number.
*
* Since tcp streams do buffered io similar to stdio, the caller can specify
* how big the send and receive buffers are via the second and third parms;
* 0 => use the system default.
*/
SVCXPRT *
svctcp_create (int sock, u_int sendsize, u_int recvsize)
{
bool_t madesock = FALSE;
SVCXPRT *xprt;
struct tcp_rendezvous *r;
struct sockaddr_in addr;
socklen_t len = sizeof (struct sockaddr_in);
if (sock == RPC_ANYSOCK)
{
if ((sock = __socket (AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
{
perror (_("svc_tcp.c - tcp socket creation problem"));
return (SVCXPRT *) NULL;
}
madesock = TRUE;
}
__bzero ((char *) &addr, sizeof (addr));
addr.sin_family = AF_INET;
if (bindresvport (sock, &addr))
{
addr.sin_port = 0;
(void) __bind (sock, (struct sockaddr *) &addr, len);
}
if ((__getsockname (sock, (struct sockaddr *) &addr, &len) != 0) ||
(__listen (sock, SOMAXCONN) != 0))
{
perror (_("svc_tcp.c - cannot getsockname or listen"));
if (madesock)
(void) __close (sock);
return (SVCXPRT *) NULL;
}
r = (struct tcp_rendezvous *) mem_alloc (sizeof (*r));
xprt = (SVCXPRT *) mem_alloc (sizeof (SVCXPRT));
if (r == NULL || xprt == NULL)
{
(void) __fxprintf (NULL, "%s: %s", __func__, _("out of memory\n"));
mem_free (r, sizeof (*r));
mem_free (xprt, sizeof (SVCXPRT));
return NULL;
}
r->sendsize = sendsize;
r->recvsize = recvsize;
xprt->xp_p2 = NULL;
xprt->xp_p1 = (caddr_t) r;
xprt->xp_verf = _null_auth;
xprt->xp_ops = &svctcp_rendezvous_op;
xprt->xp_port = ntohs (addr.sin_port);
xprt->xp_sock = sock;
xprt_register (xprt);
return xprt;
}
static void
universal (struct svc_req *rqstp, SVCXPRT *transp)
{
int prog, proc;
char *outdata;
char xdrbuf[UDPMSGSIZE];
struct proglst *pl;
/*
* enforce "procnum 0 is echo" convention
*/
if (rqstp->rq_proc == NULLPROC)
{
if (svc_sendreply (transp, (xdrproc_t)xdr_void, (char *) NULL) == FALSE)
{
(void) fprintf (stderr, "xxx\n");
exit (1);
}
return;
}
prog = rqstp->rq_prog;
proc = rqstp->rq_proc;
for (pl = proglst; pl != NULL; pl = pl->p_nxt)
if (pl->p_prognum == prog && pl->p_procnum == proc)
{
/* decode arguments into a CLEAN buffer */
__bzero (xdrbuf, sizeof (xdrbuf)); /* required ! */
if (!svc_getargs (transp, pl->p_inproc, xdrbuf))
{
svcerr_decode (transp);
return;
}
outdata = (*(pl->p_progname)) (xdrbuf);
if (outdata == NULL && pl->p_outproc != (xdrproc_t)xdr_void)
/* there was an error */
return;
if (!svc_sendreply (transp, pl->p_outproc, outdata))
{
(void) fprintf (stderr,
_ ("trouble replying to prog %d\n"),
pl->p_prognum);
exit (1);
}
/* free the decoded arguments */
(void) svc_freeargs (transp, pl->p_inproc, xdrbuf);
return;
}
(void) fprintf (stderr, _ ("never registered prog %d\n"), prog);
exit (1);
}
static void bzero_func() {
char* val;
for(int i = 0; i < 4000; i++) {
val = malloc(i);
__bzero(val, i);
for(int j = 0; j < i; j++) {
assert_int_equal(0, val[j]);
}
free(val);
val = NULL;
}
}
/* Clear memory. Can't alias to bzero because it's not defined in the
same translation unit. */
void
__aeabi_memclr (void *dest, size_t n)
{
__bzero (dest, n);
}
/*
* Generic client creation: takes (hostname, program-number, protocol) and
* returns client handle. Default options are set, which the user can
* change using the rpc equivalent of ioctl()'s.
*/
CLIENT *
clnt_create (const char *hostname, u_long prog, u_long vers,
const char *proto)
{
struct hostent hostbuf, *h;
size_t hstbuflen;
char *hsttmpbuf;
struct protoent protobuf, *p;
size_t prtbuflen;
char *prttmpbuf;
struct sockaddr_in sin;
struct sockaddr_un sun;
int sock;
struct timeval tv;
CLIENT *client;
int herr;
if (strcmp (proto, "unix") == 0)
{
__bzero ((char *)&sun, sizeof (sun));
sun.sun_family = AF_UNIX;
strcpy (sun.sun_path, hostname);
sock = RPC_ANYSOCK;
client = INTUSE(clntunix_create) (&sun, prog, vers, &sock, 0, 0);
if (client == NULL)
return NULL;
#if 0
/* This is not wanted. This would disable the user from having
a timeout in the clnt_call() call. Only a call to cnlt_control()
by the user should set the timeout value. */
tv.tv_sec = 25;
tv.tv_usec = 0;
clnt_control (client, CLSET_TIMEOUT, (char *)&tv);
#endif
return client;
}
hstbuflen = 1024;
hsttmpbuf = __alloca (hstbuflen);
while (__gethostbyname_r (hostname, &hostbuf, hsttmpbuf, hstbuflen,
&h, &herr) != 0
|| h == NULL)
if (herr != NETDB_INTERNAL || errno != ERANGE)
{
get_rpc_createerr().cf_stat = RPC_UNKNOWNHOST;
return NULL;
}
else
{
/* Enlarge the buffer. */
hstbuflen *= 2;
hsttmpbuf = __alloca (hstbuflen);
}
if (h->h_addrtype != AF_INET)
{
/*
* Only support INET for now
*/
struct rpc_createerr *ce = &get_rpc_createerr ();
ce->cf_stat = RPC_SYSTEMERROR;
ce->cf_error.re_errno = EAFNOSUPPORT;
return NULL;
}
sin.sin_family = h->h_addrtype;
sin.sin_port = 0;
__bzero (sin.sin_zero, sizeof (sin.sin_zero));
memcpy ((char *) &sin.sin_addr, h->h_addr, h->h_length);
prtbuflen = 1024;
prttmpbuf = __alloca (prtbuflen);
while (__getprotobyname_r (proto, &protobuf, prttmpbuf, prtbuflen, &p) != 0
|| p == NULL)
if (errno != ERANGE)
{
struct rpc_createerr *ce = &get_rpc_createerr ();
ce->cf_stat = RPC_UNKNOWNPROTO;
ce->cf_error.re_errno = EPFNOSUPPORT;
return NULL;
}
else
{
/* Enlarge the buffer. */
prtbuflen *= 2;
prttmpbuf = __alloca (prtbuflen);
}
sock = RPC_ANYSOCK;
switch (p->p_proto)
{
case IPPROTO_UDP:
tv.tv_sec = 5;
tv.tv_usec = 0;
client = INTUSE(clntudp_create) (&sin, prog, vers, tv, &sock);
if (client == NULL)
{
return NULL;
}
#if 0
/* This is not wanted. This would disable the user from having
a timeout in the clnt_call() call. Only a call to cnlt_control()
by the user should set the timeout value. */
tv.tv_sec = 25;
clnt_control (client, CLSET_TIMEOUT, (char *)&tv);
#endif
break;
case IPPROTO_TCP:
client = INTUSE(clnttcp_create) (&sin, prog, vers, &sock, 0, 0);
if (client == NULL)
{
return NULL;
}
#if 0
/* This is not wanted. This would disable the user from having
a timeout in the clnt_call() call. Only a call to cnlt_control()
by the user should set the timeout value. */
tv.tv_sec = 25;
tv.tv_usec = 0;
clnt_control (client, CLSET_TIMEOUT, (char *)&tv);
#endif
break;
default:
{
struct rpc_createerr *ce = &get_rpc_createerr ();
ce->cf_stat = RPC_SYSTEMERROR;
ce->cf_error.re_errno = EPFNOSUPPORT;
}
return (NULL);
}
return client;
}
int
__quickstat (const char *_path, struct stat *st, int lflag)
{
char tmpbuf[PATH_MAX];
char *path = (char *) _path;
int nval;
long r;
if (!_path) {
__set_errno (EFAULT);
return -1;
}
if (*_path == '\0') {
__set_errno (ENOENT);
return -1;
}
if (__libc_unix_names)
nval = 0;
else {
/* _unx2dos returns 1 for device names (like /dev/con) */
path = tmpbuf;
nval = _unx2dos(_path, path, sizeof (tmpbuf));
}
r = __sys_stat (path, st, lflag, 0);
if (r != -ENOSYS) {
if (r) {
if ((r == -ENOTDIR) && _enoent (path)) {
r = -ENOENT;
}
__set_errno (-r);
return -1;
}
return 0;
}
{
char *ext, drv;
_DTA d;
_DTA *olddta;
int isdot = 0;
int isdir = 0;
__bzero (st, sizeof (*st));
/* Otherwise, check to see if we have a name like CON: or AUX: */
if (nval == 1) {
st->st_mode = S_IFCHR | 0600;
st->st_flags = 0;
st->st_ino = __inode++;
st->st_rdev = 0;
st->st_mtime = st->st_ctime = st->st_atime = 0;
st->st_dev = 0;
st->st_nlink = 1;
st->st_uid = geteuid();
st->st_gid = getegid();
st->st_size = st->st_blocks = 0;
st->st_blksize = 1024;
return 0;
}
/* A file name: check for root directory of a drive */
if (path[0] == '\\' && path[1] == 0) {
drv = Dgetdrv() + 'A';
isdir = 1;
goto rootdir;
}
if (((drv = path[0]) != 0) && path[1] == ':' &&
(path[2] == 0 || (path[2] == '\\' && path[3] == 0)) ) {
rootdir:
isdir = 1;
st->st_mode = S_IFDIR | 0755;
st->st_flags = 0;
st->st_dev = isupper(drv) ? drv - 'A' : drv - 'a';
st->st_ino = 2;
st->st_mtime = st->st_ctime = st->st_atime = 0;
goto fill_dir;
}
/* Forbid wildcards in path names */
if (index(path, '*') || index (path, '?')) {
__set_errno (ENOENT);
return -1;
}
/* NOTE: Fsfirst(".",-1) or Fsfirst("..",-1) both fail under TOS,
* so we kludge around this by using the fact that Fsfirst(".\*.*"
* or "..\*.*" will return the correct file first (except, of course,
* in root directories :-( ).
* NOTE2: Some versions of TOS don't like Fsfirst("RCS\\", -1) either,
* so we do the same thing if the path ends in '\\'.
*/
/* Find the end of the string. */
for (ext = path; ext[0] && ext[1]; ext++) ;
/* Add appropriate kludge if necessary. */
if (*ext == '.' && (ext == path || ext[-1] == '\\' || ext[-1] == '.')) {
isdot = 1;
strcat (path, "\\*.*");
} else if (*ext == '\\') {
isdot = 1;
strcat (path, "*.*");
}
olddta = Fgetdta();
Fsetdta(&d);
r = Fsfirst (path, 0xff);
Fsetdta (olddta);
if (r < 0) {
if (isdot && r == -ENOENT) goto rootdir;
__set_errno (-r);
return -1;
}
if (isdot && ((d.dta_name[0] != '.') || (d.dta_name[1]))) {
goto rootdir;
}
if (((drv = *path) != 0) && path[1] == ':')
st->st_dev = _toupper (drv) - 'A';
else
st->st_dev = Dgetdrv ();
st->st_ino = __inode++;
st->st_flags = 0;
st->st_mode = 0644 | (isdir ? S_IFDIR | 0111 : S_IFREG);
if (st->st_flags & FA_RDONLY)
st->st_mode &= ~0222; /* no write permission */
if (st->st_flags & FA_HIDDEN)
st->st_mode &= ~0444; /* no read permission */
/* Check for a file with an executable extension */
ext = strrchr(_path, '.');
if (ext) {
if (!strcmp (ext, ".app") || !strcmp (ext, ".gtp") ||
!strcmp (ext, ".ttp") || !strcmp (ext, ".prg") ||
!strcmp (ext, ".tos")) {
st->st_mode |= 0111;
}
}
if ((st->st_mode & S_IFMT) == S_IFREG) {
st->st_size = d.dta_size;
/* In Unix, blocks are measured in 512 bytes */
st->st_blocks = (st->st_size + 511) / 512;
st->st_nlink = 1; /* we dont have hard links */
} else {
fill_dir:
st->st_size = 1024;
st->st_blocks = 2;
st->st_nlink = 2; /* "foo" && "foo/.." */
}
st->st_uid = geteuid(); /* the current user owns every file */
st->st_gid = getegid();
st->st_blksize = 1024;
}
return 0;
}
/*
* emulate berzerkly lseek too
*/
off_t
__lseek (int handle, off_t offset, int mode)
{
long current_pos;
long expected_pos;
long new_pos;
char buf[256];
if ( (mode == SEEK_END) || (offset <= 0) )
/* do it the usual way */
{
current_pos = Fseek (offset, handle, mode);
if (current_pos < 0)
{
if (-current_pos == EBADARG)
__set_errno(EINVAL); /* filesystems should return this - fix up */
else
__set_errno ((int) -current_pos);
return -1L;
}
return current_pos;
}
current_pos = Fseek (0L, handle, SEEK_CUR); /* find out where we are */
if (current_pos < 0)
{
if (-current_pos == EBADARG)
__set_errno(EINVAL); /* filesystems should return this - fix up */
else
__set_errno ((int) -current_pos); /* an unseekable device */
return -1L;
}
if (mode == SEEK_SET)
expected_pos = offset;
else
expected_pos = offset + current_pos;
new_pos = Fseek (offset, handle, mode);
if (new_pos == expected_pos)
return new_pos;
/* otherwise extend file -- zero filling the hole */
if (new_pos < 0) /* error? */
{
new_pos = Fseek (0L, handle, SEEK_END); /* go to eof */
}
__bzero (buf, (size_t)256);
while (expected_pos > new_pos)
{
offset = expected_pos - new_pos;
if (offset > 256)
offset = 256;
if((current_pos = write(handle, buf, offset)) != offset)
return((current_pos > 0) ? (new_pos + current_pos) :
-1L); /* errno set by write */
new_pos += offset;
}
return(new_pos);
}
