ls2k
/
pmon
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

add nfs support.

master
root 15 years ago
committed by root
parent
d43f8a0569
commit
0cacd4243f
5 changed files with 1010 additions and 0 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 1
      Targets/Bonito2fdev/conf/Bonito.2fdev.via
  2. 1
      conf/files
  3. 4
      lib/libc/open.c
  4. 943
      pmon/netio/nfs.c
  5. 61
      pmon/netio/nfs.h

1
Targets/Bonito2fdev/conf/Bonito.2fdev.via
View File

@ -178,6 +178,7 @@ option VIA686B_POWERFIXUP
option DEVBD2F_VIA
#option USE_GPIO_SERIAL
select http
#select nfs
select tcp
select inet
select tftpd

1
conf/files
View File

@ -254,6 +254,7 @@ file pmon/netio/bootp.c inet
file pmon/netio/ifconfig.c inet
file pmon/netio/ping.c inet
file pmon/netio/tftplib.c inet
file pmon/netio/nfs.c inet
file pmon/netio/httplib.c inet & http & tcp
#file pmon/netio/udptty.c inet

4
lib/libc/open.c
View File

@ -89,6 +89,10 @@ open(filename, mode)
i = __try_open(dname, mode, NULL, lu, FS_FILE);
}
else if(strpat(dname, "http://*"))
{
i = __try_open(dname, mode, "net", lu, 0);
}
else if(strpat(dname, "nfs://*"))
{
i = __try_open(dname, mode, "net", lu, 0);
}

943
pmon/netio/nfs.c
View File

@ -0,0 +1,943 @@
#undef _KERNEL
#include <sys/types.h>
#include <sys/param.h>
#include <sys/socket.h>
#include <sys/ioctl.h>
#include <sys/file.h>
#include <sys/time.h>
#include <sys/syslog.h>
#include <sys/endian.h>
#include <netinet/in.h>
#include <stdio.h>
#include <errno.h>
#include <netdb.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <file.h>
#include <net/if.h>
#include <pmon.h>
#include "nfs.h"
#include "netio.h"
//#if defined(CONFIG_CMD_NET) && defined(CONFIG_CMD_NFS)
#define HASHES_PER_LINE 65 /* Number of "loading" hashes per line */
#define NFS_RETRY_COUNT 30
#define NFS_TIMEOUT 2000UL
typedef ulong IPaddr_t;
typedef unsigned char uchar;
void ip_to_string(IPaddr_t x, char *s);
IPaddr_t string_to_ip(char *s);
void print_IPaddr(IPaddr_t x);
static char* basename (char *);
static char* dirname (char *);
extern void log __P((int kind, const char *fmt, ...));
extern in_addr_t inet_addr __P((const char *));
static void NfsSend (void);
static void NfsHandler (uchar *pkt, void *buf, /*unsigned dest, unsigned src*/ unsigned len);
//unsigned long simple_strtoul(const char *, char **, unsigned int);
static int
store_block (uchar *, void *, unsigned, unsigned);
static int fs_mounted = 0;
static unsigned long rpc_id = 0;
static int nfs_offset = -1;
static int nfs_len;
static char dirfh[NFS_FHSIZE]; /* file handle of directory */
static char filefh[NFS_FHSIZE]; /* file handle of kernel image */
static int NfsDownloadState;
static unsigned long NfsServerIP;
static int NfsSrvMountPort;
static int NfsSrvNfsPort;
static int NfsOurPort;
static int NfsTimeoutCount;
static int NfsState;
#define STATE_RPCLOOKUP_PROG_MOUNT_REQ 1
#define STATE_RPCLOOKUP_PROG_NFS_REQ 2
#define STATE_MOUNT_REQ 3
#define STATE_UMOUNT_REQ 4
#define STATE_LOOKUP_REQ 5
#define STATE_READ_REQ 6
#define STATE_READLINK_REQ 7
static char default_filename[64];
static char *nfs_filename;
static char *nfs_path;
static char nfs_path_buff[2048];
int NetState;
static struct sockaddr_in sin;
static int sock;
static short oflags;
static int sock;
static int foffs;
static int nfs_open (int , struct Url *, int, int);
static int nfs_read (int, void *, int);
static int nfs_write (int, const void *, int);
static off_t nfs_lseek (int , long, int);
static int nfs_close(int);
//static struct nfsfile *nfsp;
int damn() {
printf("%s\n", "Oh~Come On! For the love of God!");
}
static int nfs_open(int fd, struct Url *url, int flags, int perms) {
struct hostent *hp;
const char *mode;
char *host;
char hbuf[MAXHOSTNAMELEN];
struct rpc_t pktbuf;
nfs_path = (char *)nfs_path_buff;
oflags = flags & O_ACCMODE;
if(oflags != O_RDONLY && oflags != O_WRONLY) {
errno = EACCES;
return -1;
}
if(strlen(url->hostname) != 0) {
host = url->hostname;
} else {
log(LOG_INFO, "nfs: missing/bad host name: %s\n", url->filename);
errno = EDESTADDRREQ;
return -1;
}
// fp = (struct nfsfile *)malloc(sizeof(struct nfsfile));
// if(!fp) {
// errno = ENOBUFS;
// return -1;
// }
NfsServerIP = string_to_ip(host);
strcpy(nfs_path, url->filename);
nfs_filename = basename(nfs_path);
nfs_path = dirname(nfs_path);
puts("File transfer via NFS from server ");
print_IPaddr(NfsServerIP);
printf("nfs_filename : %s\n", nfs_filename);
printf("nfs_path : %s\n", nfs_path);
// puts("; out IP address is ");
// print_IPaddr(NetOurIP);
sock = socket(AF_INET, SOCK_DGRAM, 0);
if(sock < 0) goto error;
sin.sin_family = AF_INET;
sin.sin_port = htons(1000);
if(bind(sock, (struct sockaddr *)&sin, sizeof(sin)) < 0)
goto error;
hp = gethostbyname(host);
if(hp) {
sin.sin_family = hp->h_addrtype;
bcopy(hp->h_addr, (void *)&sin.sin_addr, hp->h_length);
strncpy(hbuf, hp->h_name, sizeof(hbuf)-1);
hbuf[sizeof(hbuf)-1] = 0;
host = hbuf;
} else {
sin.sin_family = AF_INET;
sin.sin_addr.s_addr = inet_addr(host);
if(sin.sin_addr.s_addr == -1) {
log(LOG_INFO, "nfs: bad internet address: %s\n", host);
errno = EADDRNOTAVAIL;
goto error;
}
}
// sin.sin_port = SUNRPC_PORT;
NfsState = STATE_RPCLOOKUP_PROG_MOUNT_REQ;
NfsSend();
while(NfsState != STATE_READ_REQ || NfsState == STATE_UMOUNT_REQ) {
NfsHandler((uchar *)&pktbuf, NULL, sizeof(struct rpc_t));
}
if(NfsState == STATE_READ_REQ)
return 0;
error:
if(sock >= 0)
close(sock);
// free(fp);
return -1;
}
static int nfs_close(int fd) {
return 0;
}
static int start, end, off;
struct rpc_t readbuf;
static int nfs_read_reply (uchar *,void *, unsigned int);
static int nfs_read(int fd, void *buf, int nread) {
// nfs_len = n;
// printf("%d bytes requested....\n", nfs_len);
/*
NfsSend();
while(NfsState != STATE_UMOUNT_REQ) {
NfsHandler((uchar *)&pktbuf, buf, n);
}
return n;
*/
int nb, n;
start = off = 0;
NfsSend();
end = nfs_read_reply((uchar *)&readbuf, buf, n);
nfs_offset += end;
for(nb = nread; nb != 0 && off >= start && off < end; ) {
if(off >= start && off < end) {
n = end - off;
if(n > nb) n = nb;
store_block ((uchar *)&readbuf+sizeof(readbuf.u.reply), buf, off, n);
off += n;
nb -= n;
}
if(off >= end) {
NfsSend();
n = nfs_read_reply ((uchar *)&readbuf, buf, n);
if(n > 0) nfs_offset += n;
start = end;
end = start + n;
}
}
printf("nfs_read %d\n", nread-nb);
return nread - nb;
}
static int nfs_write(int fd, const void *buf, int n) {
return -1;
}
static off_t nfs_lseek(int fd, long offset, int whence) {
printf("nfs_lseek...offset = %d\n", offset);
return (nfs_offset = offset);
}
static NetFileOps nfsops = {
"nfs",
nfs_open,
nfs_read,
nfs_write,
nfs_lseek,
NULL,
nfs_close,
};
static void init_nfs __P((void)) __attribute__ ((constructor));
static void init_nfs(void) {
netfs_init(&nfsops);
}
static int
store_block (uchar * src, void *dest, unsigned offset, unsigned len)
{
/* ulong newsize = offset + len;
#ifdef CONFIG_SYS_DIRECT_FLASH_NFS
int i, rc = 0;
for (i=0; i<CONFIG_SYS_MAX_FLASH_BANKS; i++) {
if (load_addr + offset >= flash_info[i].start[0]) {
rc = 1;
break;
}
}
if (rc) {
rc = flash_write ((uchar *)src, (ulong)(load_addr+offset), len);
if (rc) {
flash_perror (rc);
return -1;
}
} else
{
(void)memcpy ((void *)(load_addr + offset), src, len);
}
if (NetBootFileXferSize < (offset+len))
NetBootFileXferSize = newsize; */
// printf("len = %d\n", len);
bcopy(src, dest+offset, len);
// printf("buf addr = 0x%x\n", dest+offset);
return 0;
}
static char*
basename (char *path)
{
char *fname;
fname = path + strlen(path) - 1;
while (fname >= path) {
if (*fname == '/') {
fname++;
break;
}
fname--;
}
return fname;
}
static char*
dirname (char *path)
{
char *fname;
fname = basename (path);
--fname;
*fname = '\0';
return path;
}
/**************************************************************************
RPC_ADD_CREDENTIALS - Add RPC authentication/verifier entries
**************************************************************************/
static long *rpc_add_credentials (long *p)
{
int hl;
int hostnamelen;
char hostname[256];
strcpy (hostname, "");
hostnamelen=strlen (hostname);
/* Here's the executive summary on authentication requirements of the
* various NFS server implementations: Linux accepts both AUTH_NONE
* and AUTH_UNIX authentication (also accepts an empty hostname field
* in the AUTH_UNIX scheme). *BSD refuses AUTH_NONE, but accepts
* AUTH_UNIX (also accepts an empty hostname field in the AUTH_UNIX
* scheme). To be safe, use AUTH_UNIX and pass the hostname if we have
* it (if the BOOTP/DHCP reply didn't give one, just use an empty
* hostname). */
hl = (hostnamelen + 3) & ~3;
/* Provide an AUTH_UNIX credential. */
*p++ = htonl(1); /* AUTH_UNIX */
*p++ = htonl(hl+20); /* auth length */
*p++ = htonl(0); /* stamp */
*p++ = htonl(hostnamelen); /* hostname string */
if (hostnamelen & 3) {
*(p + hostnamelen / 4) = 0; /* add zero padding */
}
memcpy (p, hostname, hostnamelen);
p += hl / 4;
*p++ = 0; /* uid */
*p++ = 0; /* gid */
*p++ = 0; /* auxiliary gid list */
/* Provide an AUTH_NONE verifier. */
*p++ = 0; /* AUTH_NONE */
*p++ = 0; /* auth length */
return p;
}
/**************************************************************************
RPC_LOOKUP - Lookup RPC Port numbers
**************************************************************************/
static void
rpc_req (int rpc_prog, int rpc_proc, uint32_t *data, int datalen)
{
struct rpc_t pkt;
unsigned long id;
uint32_t *p;
int pktlen;
int sport;
int n = 0;
id = ++rpc_id;
pkt.u.call.id = htonl(id);
pkt.u.call.type = htonl(MSG_CALL);
pkt.u.call.rpcvers = htonl(2); /* use RPC version 2 */
pkt.u.call.prog = htonl(rpc_prog);
pkt.u.call.vers = htonl(2); /* portmapper is version 2 */
pkt.u.call.proc = htonl(rpc_proc);
p = (uint32_t *)&(pkt.u.call.data);
if (datalen)
memcpy ((char *)p, (char *)data, datalen*sizeof(uint32_t));
pktlen = (char *)p + datalen*sizeof(uint32_t) - (char *)&pkt;
// memcpy ((char *)NetTxPacket + NetEthHdrSize() + IP_HDR_SIZE, (char *)&pkt, pktlen);
if (rpc_prog == PROG_PORTMAP)
sport = SUNRPC_PORT;
else if (rpc_prog == PROG_MOUNT)
sport = NfsSrvMountPort;
else
sport = NfsSrvNfsPort;
sin.sin_port = htons(sport);
// NetSendUDPPacket (NetServerEther, NfsServerIP, sport, NfsOurPort, pktlen);
n = sendto(sock, &pkt, pktlen, 0, (struct sockaddr *)&sin, sizeof(sin));
// printf("In rpc_req -- %d bytes have been sent ...\n", n);
}
/**************************************************************************
RPC_LOOKUP - Lookup RPC Port numbers
**************************************************************************/
static void
rpc_lookup_req (int prog, int ver)
{
uint32_t data[16];
data[0] = 0; data[1] = 0; /* auth credential */
data[2] = 0; data[3] = 0; /* auth verifier */
data[4] = htonl(prog);
data[5] = htonl(ver);
data[6] = htonl(17); /* IP_UDP */
data[7] = 0;
rpc_req (PROG_PORTMAP, PORTMAP_GETPORT, data, 8);
}
/**************************************************************************
NFS_MOUNT - Mount an NFS Filesystem
**************************************************************************/
static void
nfs_mount_req (char *path)
{
uint32_t data[1024];
uint32_t *p;
int len;
int pathlen;
pathlen = strlen (path);
p = &(data[0]);
p = (uint32_t *)rpc_add_credentials((long *)p);
*p++ = htonl(pathlen);
if (pathlen & 3) *(p + pathlen / 4) = 0;
memcpy (p, path, pathlen);
p += (pathlen + 3) / 4;
len = (uint32_t *)p - (uint32_t *)&(data[0]);
rpc_req (PROG_MOUNT, MOUNT_ADDENTRY, data, len);
}
/**************************************************************************
NFS_UMOUNTALL - Unmount all our NFS Filesystems on the Server
**************************************************************************/
static void
nfs_umountall_req (void)
{
uint32_t data[1024];
uint32_t *p;
int len;
if ((NfsSrvMountPort == -1) || (!fs_mounted)) {
/* Nothing mounted, nothing to umount */
return;
}
p = &(data[0]);
p = (uint32_t *)rpc_add_credentials ((long *)p);
len = (uint32_t *)p - (uint32_t *)&(data[0]);
rpc_req (PROG_MOUNT, MOUNT_UMOUNTALL, data, len);
}
/***************************************************************************
* NFS_READLINK (AH 2003-07-14)
* This procedure is called when read of the first block fails -
* this probably happens when it's a directory or a symlink
* In case of successful readlink(), the dirname is manipulated,
* so that inside the nfs() function a recursion can be done.
**************************************************************************/
static void
nfs_readlink_req (void)
{
uint32_t data[1024];
uint32_t *p;
int len;
p = &(data[0]);
p = (uint32_t *)rpc_add_credentials ((long *)p);
memcpy (p, filefh, NFS_FHSIZE);
p += (NFS_FHSIZE / 4);
len = (uint32_t *)p - (uint32_t *)&(data[0]);
rpc_req (PROG_NFS, NFS_READLINK, data, len);
}
/**************************************************************************
NFS_LOOKUP - Lookup Pathname
**************************************************************************/
static void
nfs_lookup_req (char *fname)
{
uint32_t data[1024];
uint32_t *p;
int len;
int fnamelen;
fnamelen = strlen (fname);
p = &(data[0]);
p = (uint32_t *)rpc_add_credentials ((long *)p);
memcpy (p, dirfh, NFS_FHSIZE);
p += (NFS_FHSIZE / 4);
*p++ = htonl(fnamelen);
if (fnamelen & 3) *(p + fnamelen / 4) = 0;
memcpy (p, fname, fnamelen);
p += (fnamelen + 3) / 4;
len = (uint32_t *)p - (uint32_t *)&(data[0]);
rpc_req (PROG_NFS, NFS_LOOKUP, data, len);
}
/**************************************************************************
NFS_READ - Read File on NFS Server
**************************************************************************/
static void
nfs_read_req (int offset, int readlen)
{
uint32_t data[1024];
uint32_t *p;
int len;
p = &(data[0]);
p = (uint32_t *)rpc_add_credentials ((long *)p);
memcpy (p, filefh, NFS_FHSIZE);
p += (NFS_FHSIZE / 4);
*p++ = htonl(offset);
*p++ = htonl(readlen);
*p++ = 0;
len = (uint32_t *)p - (uint32_t *)&(data[0]);
rpc_req (PROG_NFS, NFS_READ, data, len);
}
/**************************************************************************
RPC request dispatcher
**************************************************************************/
static void
NfsSend (void)
{
#ifdef NFS_DEBUG
printf ("%s\n", __FUNCTION__);
#endif
switch (NfsState) {
case STATE_RPCLOOKUP_PROG_MOUNT_REQ:
rpc_lookup_req (PROG_MOUNT, 1);
break;
case STATE_RPCLOOKUP_PROG_NFS_REQ:
rpc_lookup_req (PROG_NFS, 2);
break;
case STATE_MOUNT_REQ:
nfs_mount_req (nfs_path);
break;
case STATE_UMOUNT_REQ:
nfs_umountall_req ();
break;
case STATE_LOOKUP_REQ:
nfs_lookup_req (nfs_filename);
break;
case STATE_READ_REQ:
nfs_read_req (nfs_offset, nfs_len);
break;
case STATE_READLINK_REQ:
nfs_readlink_req ();
break;
}
}
/**************************************************************************
Handlers for the reply from server
**************************************************************************/
static int
rpc_lookup_reply (int prog, uchar *pkt, unsigned len)
{
struct rpc_t rpc_pkt;
memcpy ((unsigned char *)&rpc_pkt, pkt, len);
#ifdef NFS_DEBUG
printf ("%s\n", __FUNCTION__);
#endif
if (ntohl(rpc_pkt.u.reply.id) != rpc_id)
return -1;
if (rpc_pkt.u.reply.rstatus ||
rpc_pkt.u.reply.verifier ||
rpc_pkt.u.reply.astatus) {
return -1;
}
switch (prog) {
case PROG_MOUNT:
NfsSrvMountPort = ntohl(rpc_pkt.u.reply.data[0]);
printf("PROG_MOUNT -- NfsSrvMountPort = %d\n", NfsSrvMountPort);
break;
case PROG_NFS:
NfsSrvNfsPort = ntohl(rpc_pkt.u.reply.data[0]);
printf("PROG_NFS -- NfsSrvNfsPort = %d\n", NfsSrvNfsPort);
break;
}
return 0;
}
static int
nfs_mount_reply (uchar *pkt, unsigned len)
{
struct rpc_t rpc_pkt;
#ifdef NFS_DEBUG
printf ("%s\n", __FUNCTION__);
#endif
memcpy ((unsigned char *)&rpc_pkt, pkt, len);
if (ntohl(rpc_pkt.u.reply.id) != rpc_id)
return -1;
if (rpc_pkt.u.reply.rstatus ||
rpc_pkt.u.reply.verifier ||
rpc_pkt.u.reply.astatus ||
rpc_pkt.u.reply.data[0]) {
return -1;
}
fs_mounted = 1;
memcpy (dirfh, rpc_pkt.u.reply.data + 1, NFS_FHSIZE);
return 0;
}
static int
nfs_umountall_reply (uchar *pkt, unsigned len)
{
struct rpc_t rpc_pkt;
#ifdef NFS_DEBUG
printf ("%s\n", __FUNCTION__);
#endif
memcpy ((unsigned char *)&rpc_pkt, pkt, len);
if (ntohl(rpc_pkt.u.reply.id) != rpc_id)
return -1;
if (rpc_pkt.u.reply.rstatus ||
rpc_pkt.u.reply.verifier ||
rpc_pkt.u.reply.astatus) {
return -1;
}
fs_mounted = 0;
memset (dirfh, 0, sizeof(dirfh));
return 0;
}
static int
nfs_lookup_reply (uchar *pkt, unsigned len)
{
struct rpc_t rpc_pkt;
#ifdef NFS_DEBUG
printf ("%s\n", __FUNCTION__);
#endif
memcpy ((unsigned char *)&rpc_pkt, pkt, len);
if (ntohl(rpc_pkt.u.reply.id) != rpc_id)
return -1;
if (rpc_pkt.u.reply.rstatus ||
rpc_pkt.u.reply.verifier ||
rpc_pkt.u.reply.astatus ||
rpc_pkt.u.reply.data[0]) {
return -1;
}
memcpy (filefh, rpc_pkt.u.reply.data + 1, NFS_FHSIZE);
return 0;
}
static int
nfs_readlink_reply (uchar *pkt, unsigned len)
{
struct rpc_t rpc_pkt;
int rlen;
#ifdef NFS_DEBUG
printf ("%s\n", __FUNCTION__);
#endif
memcpy ((unsigned char *)&rpc_pkt, pkt, len);
if (ntohl(rpc_pkt.u.reply.id) != rpc_id)
return -1;
if (rpc_pkt.u.reply.rstatus ||
rpc_pkt.u.reply.verifier ||
rpc_pkt.u.reply.astatus ||
rpc_pkt.u.reply.data[0]) {
return -1;
}
rlen = ntohl (rpc_pkt.u.reply.data[1]); /* new path length */
if (*((char *)&(rpc_pkt.u.reply.data[2])) != '/') {
int pathlen;
strcat (nfs_path, "/");
pathlen = strlen(nfs_path);
memcpy (nfs_path+pathlen, (uchar *)&(rpc_pkt.u.reply.data[2]), rlen);
nfs_path[pathlen+rlen+1] = 0;
} else {
memcpy (nfs_path, (uchar *)&(rpc_pkt.u.reply.data[2]), rlen);
nfs_path[rlen] = 0;
}
return 0;
}
static int
nfs_read_reply (uchar *pkt, void *buf, unsigned len)
{
int rlen;
struct sockaddr_in from;
int fromlen, n;
struct rpc_t pktbuf;
#ifdef NFS_DEBUG_nop
printf ("%s\n", __FUNCTION__);
#endif
n = recvfrom(sock, &pktbuf, sizeof(struct rpc_t), 0, (struct sockaddr *)&from, &fromlen);
memcpy(pkt, &pktbuf, sizeof(struct rpc_t));
pkt = (struct rpc_t *)pkt;
if (ntohl(pktbuf.u.reply.id) != rpc_id)
return -1;
if (pktbuf.u.reply.rstatus ||
pktbuf.u.reply.verifier ||
pktbuf.u.reply.astatus ||
pktbuf.u.reply.data[0]) {
if (pktbuf.u.reply.rstatus) {
return -9999;
}
if (pktbuf.u.reply.astatus) {
return -9999;
}
return -ntohl(pktbuf.u.reply.data[0]);;
}
if ((nfs_offset!=0) && !((nfs_offset) % (NFS_READ_SIZE/2*10*HASHES_PER_LINE))) {
puts ("\n");
}
if (!(nfs_offset % ((NFS_READ_SIZE/2)*10))) {
putchar ('#');
}
rlen = ntohl(pktbuf.u.reply.data[18]);
// printf("%d bytes have been read from nfs server...\n", rlen);
// if ( store_block ((uchar *)pkt+sizeof(rpc_pkt.u.reply), buf, nfs_offset, rlen) )
// return -9999;
return rlen;
}
static void
NfsHandler (uchar *pkt, void * buf, /*unsigned dest, unsigned src,*/ unsigned len)
{
int rlen;
struct sockaddr_in from;
int fromlen;
int n;
#ifdef NFS_DEBUG
printf ("%s\n", __FUNCTION__);
#endif
// n = recvfrom(sock, pkt, len, 0,
// (struct sockaddr *)&from, &fromlen);
n = recvfrom(sock, pkt, sizeof(struct rpc_t), 0, (struct sockaddr *)&from, &fromlen);
// printf("In NfsHandler -- %d bytes have been received...\n", n);
if(n < 0) {
perror("nfs: recvfrom");
return;
}
// if (dest != NfsOurPort) return;
switch (NfsState) {
case STATE_RPCLOOKUP_PROG_MOUNT_REQ:
rpc_lookup_reply (PROG_MOUNT, pkt, n);
NfsState = STATE_RPCLOOKUP_PROG_NFS_REQ;
NfsSend ();
break;
case STATE_RPCLOOKUP_PROG_NFS_REQ:
rpc_lookup_reply (PROG_NFS, pkt, n);
NfsState = STATE_MOUNT_REQ;
NfsSend ();
break;
case STATE_MOUNT_REQ:
if (nfs_mount_reply(pkt, n)) {
puts ("*** ERROR: Cannot mount\n");
/* just to be sure... */
NfsState = STATE_UMOUNT_REQ;
NfsSend ();
} else {
NfsState = STATE_LOOKUP_REQ;
NfsSend ();
}
break;
case STATE_UMOUNT_REQ:
if (nfs_umountall_reply(pkt, n)) {
puts ("*** ERROR: Cannot umount\n");
// NetState = NETLOOP_FAIL;
} else {
puts ("\ndone\n");
NetState = NfsDownloadState;
}
break;
case STATE_LOOKUP_REQ:
if (nfs_lookup_reply(pkt, n)) {
puts ("*** ERROR: File lookup fail\n");
NfsState = STATE_UMOUNT_REQ;
NfsSend ();
} else {
NfsState = STATE_READ_REQ;
nfs_offset = 0;
nfs_len = NFS_READ_SIZE;
// NfsSend ();
}
break;
case STATE_READLINK_REQ:
if (nfs_readlink_reply(pkt, n)) {
puts ("*** ERROR: Symlink fail\n");
NfsState = STATE_UMOUNT_REQ;
NfsSend ();
} else {
#ifdef NFS_DEBUG
printf ("Symlink --> %s\n", nfs_path);
#endif
nfs_filename = basename (nfs_path);
nfs_path = dirname (nfs_path);
NfsState = STATE_MOUNT_REQ;
NfsSend ();
}
break;
case STATE_READ_REQ:
rlen = nfs_read_reply (pkt, buf, n);
// NetSetTimeout (NFS_TIMEOUT, NfsTimeout);
if (rlen > 0) {
nfs_offset += rlen;
// NfsSend ();
}
else if ((rlen == -NFSERR_ISDIR)||(rlen == -NFSERR_INVAL)) {
/* symbolic link */
NfsState = STATE_READLINK_REQ;
NfsSend ();
} else {
if ( ! rlen ) //NfsDownloadState = NETLOOP_SUCCESS;
NfsState = STATE_UMOUNT_REQ;
// NfsSend ();
}
break;
}
}
void ip_to_string(IPaddr_t x, char *s) {
x = ntohl(x);
sprintf(s, "%d.%d.%d.%d",
(int)((x >> 24) & 0xff),
(int)((x >> 16) & 0xff),
(int)((x >> 8) & 0xff), (int)((x >> 0) & 0xff)
);
}
IPaddr_t string_to_ip(char *s) {
IPaddr_t addr;
char *e;
int i;
if(s == NULL) return 0;
for(addr = 0, i =0; i < 4; ++i) {
ulong val = s ? strtoul(s, &e, 10) : 0;
addr <<= 8;
addr |= (val & 0xFF);
if(s)
s = (*e) ? e+1 : e;
}
return htonl(addr);
}
void print_IPaddr(IPaddr_t x) {
char tmp[16];
ip_to_string(x, tmp);
puts(tmp);
}
/*
unsigned long simple_strtoul(const char *cp, char **endp, unsigned int base) {
unsigned long result = 0, value;
if(*cp == '0') {
cp++;
if((*cp == 'x') && isxdigit(cp[1])) {
base = 16;
cp++;
}
if(!base) base = 8;
}
if(!base) base = 10;
while(isxdigit(*cp) && (value = isdigit(*cp) ? *cp-'0' : (islower(*cp)
? toupper(*cp) : *cp)-'A'+10) < base) {
result = result*base + value;
cp++;
}
if(endp)
*endp = (char *)cp;
return result;
}
*/

61
pmon/netio/nfs.h
View File

@ -0,0 +1,61 @@
#ifndef __NFS_H__
#define __NFS_H__
#define SUNRPC_PORT 111
#define NFS_READ_SIZE 1024
#define NFS_MAXLINKDEPTH 16
#define PROG_PORTMAP 100000
#define PROG_NFS 100003
#define PROG_MOUNT 100005
#define MSG_CALL 0
#define MSG_REPLY 1
#define PORTMAP_GETPORT 3
#define MOUNT_ADDENTRY 1
#define MOUNT_UMOUNTALL 4
#define NFS_LOOKUP 4
#define NFS_READLINK 5
#define NFS_READ 6
#define NFS_FHSIZE 32
#define NFSERR_PERM 1
#define NFSERR_NOENT 2
#define NFSERR_ACCES 13
#define NFSERR_ISDIR 21
#define NFSERR_INVAL 22
#define NFS_MAXLINKDEPTH 16
struct rpc_t {
union {
uint8_t data[2048];
struct {
uint32_t id;
uint32_t type;
uint32_t rpcvers;
uint32_t prog;
uint32_t vers;
uint32_t proc;
uint32_t data[1];
} call;
struct {
uint32_t id;
uint32_t type;
uint32_t rstatus;
uint32_t verifier;
uint32_t v2;
uint32_t astatus;
uint32_t data[19];
} reply;
} u;
};
#endif
Write Preview
Loading…
Cancel
Save