/*      $Id: isiboot.c,v 1.2 1999/12/26 14:33:33 nisimura Exp $ */

/*-
* Copyright (c) 2000 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by Tohru Nishimura.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
*    must display the following acknowledgement:
*        This product includes software developed by the NetBSD
*        Foundation, Inc. and its contributors.
* 4. Neither the name of The NetBSD Foundation nor the names of its
*    contributors may be used to endorse or promote products derived
*    from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/

#define TRACE(l, x) if ((l) <= dbg) printf x

#include <sys/types.h>
#include <fcntl.h>
#include <unistd.h>
#include <poll.h>
#include <errno.h>
#include <sys/socket.h>
#include <sys/ioctl.h>
#include <net/if.h>
#include <net/if_dl.h>
#include <net/bpf.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/*
* Following data format depends on m68k order, and aligned harmful
* to RISC processors.
*/
struct frame {
       u_int8_t dst[6];
       u_int8_t src[6];
       u_int16_t type;
       u_int16_t fill_0;
       u_int16_t seqno;
       u_int8_t opcode;
       u_int8_t fill_1;
       u_int8_t pos[4];
       u_int8_t siz[4];
       unsigned char data[1];
};
#define FRAMETYPE       0x80df
#define FRAMELEN        1468

#define CPY32(x,y) {                                            \
       u_int8_t *p = (y);                                      \
       (x) = (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3]; \
   } while (0)

struct station {
       int     fd;
       char    name[33];
       char    ifname[IFNAMSIZ];
       u_int8_t addr[6];
} station;

struct session {
       struct session *next;
       int state;
       FILE *file;
       u_int8_t addr[6];
} *activelist, *freelist;
#define NEWPOOL 10

#define WAITING 0       /* implicit state after receiving the first frame */
#define OPENING 1       /* waiting for OPEN after CONNECT is received */
#define TRANSFER 2      /* data transferring state after OPEN is well done */
static char *state[] = { "WAITING", "OPENING", "TRANSFER" };

#define CONNECT 0
#define OPEN 1
#define READ 2
#define CLOSE 4
static char *op[] = { "CONNECT", "OPEN", "READ", "WRITE", "CLOSE", "FIND" };

void createbpfport(char *, char **, int *, struct station *);
struct session *search(u_int8_t *);
void closedown(struct session *);
void makepool(void);
char *etheraddr(u_int8_t *);
int pickif(char *, u_int8_t *);

#define NEQ(x,y) strcmp(x,y)
#define FRAME(X) ((X)+((struct bpf_hdr *)X)->bh_hdrlen)

char usage[] = "usage: %s [-i interface] [-s directory] [-d tracelevel]\n";
char devbpf[] = "/dev/bpf?";

main(argc, argv)
       int argc;
       char *argv[];
{
       int cc, nread, iolen, pos, siz, dbg;
       char *ifname, *bootwd, *p, *iobuf;
       struct session *cp;
       struct frame *fp;
       struct pollfd pollfd;
       static u_int8_t om[6] = { 0, 0, 0xA, 0, 0, 0 }; /* XXX */

       if (geteuid() != 0)
               fprintf(stderr, "WARNING: run by non root priviledge\n");

       ifname = bootwd = NULL;
       dbg = 0;
       while ((cc = getopt(argc, argv, "i:s:d:")) != -1) {
               switch (cc) {
               case 'i':
                       ifname = optarg;
                       break;
               case 's':
                       bootwd = optarg;
                       break;
               case 'd':
                       dbg = atoi(optarg);
                       break;
               default:
                       fprintf(stderr, usage, argv[0]);
                       exit(1);
               }
       }
       argv += optind;
       argc -= optind;

       memset(station.name, 0, sizeof(station.name));
       gethostname(station.name, sizeof(station.name) - 1);
       if ((p = strchr(station.name, '.')) != NULL)
               *p = '\0';

       createbpfport(ifname, &iobuf, &iolen, &station);

       if (bootwd != NULL && chroot(bootwd) < 0) {
               perror(argv[0]);
               exit(1);
       }

       pollfd.fd = station.fd;
       pollfd.events = POLLIN;
       for (;;) {
               poll(&pollfd, 1, INFTIM);
               read(pollfd.fd, iobuf, iolen);  /* returns 1468 */
               fp = (struct frame *)FRAME(iobuf);
               if (memcmp(fp->dst, om, 3) == 0)
                       continue;
               cp = search(fp->src);
               TRACE(2, ("[%s] ", etheraddr(fp->src)));
               switch (cp->state) {
               case WAITING:
                       if (fp->opcode != CONNECT)
                               continue;
                       else if (NEQ(fp->data, station.name)) {
                               TRACE(3, ("'%s' not for me\n", fp->data));
                               continue;
                       }
                       cp->state = OPENING;
                       TRACE(2, ("new connection\n"));
                       break;
               case OPENING:
                       if (fp->opcode != OPEN)
                               goto aborting;  /* out of phase */
                       cp->file = fopen(fp->data, "r");
                       if (cp->file == NULL) {
                               TRACE(1, ("filed to open '%s'\n", fp->data));
                               goto closedown; /* no such file */
                       }
                       cp->state = TRANSFER;
                       TRACE(2, ("opened '%s'\n", fp->data));
                       break;
               case TRANSFER:
                       if (fp->opcode == CLOSE) {
                               TRACE(2, ("connection closed\n"));
                               goto closedown; /* close request */
                       }
                       if (fp->opcode != READ)
                               goto aborting;  /* out of phase */
                       CPY32(siz, fp->siz);
                       CPY32(pos, fp->pos);
                       nread = siz;
                       if (fseek(cp->file, pos, 0L) < 0
                            || fread(fp->data, 1, nread, cp->file) < nread) {
                               memset(fp->siz, 0, 4); /* corrupted file */
                       }
                       TRACE(3, ("%d@%d\n", siz, pos));
                       break;
               aborting:
                       TRACE(1, ("out of phase\n"));
               closedown:
                       closedown(cp);
                       fp->opcode = CLOSE;
                       break;
               }
               memcpy(fp->dst, fp->src, 6);
               memcpy(fp->src, station.addr, 6);
               write(pollfd.fd, fp, FRAMELEN);
       }
       /* NOTREACHED */
}

struct session *
search(client)
       u_int8_t client[];
{
       struct session *cp;

       for (cp = activelist; cp; cp = cp->next) {
               if (memcmp(client, cp->addr, 6) == 0)
                       return cp;
       }
       if (freelist == NULL)
               makepool();
       cp = freelist;
       freelist = cp->next;
       cp->next = activelist;
       activelist = cp;

       cp->state = WAITING;
       cp->file = NULL;
       bcopy(client, cp->addr, 6);
       return cp;
}

void
closedown(cp)
       struct session *cp;
{
       struct session *cpp;

       cpp = activelist;
       if (cpp == cp)
               activelist = cp->next;
       else {
               do {
                       if (cpp->next == cp)
                               break;
               } while (NULL != (cpp = cpp->next)); /* should never happen */
               cpp->next = cp->next;
       }
       cp->next = freelist;
       freelist = cp;

       if (cp->file)
               fclose(cp->file);
       cp->file = NULL;
       bzero(cp->addr, 6);
}

void
makepool()
{
       struct session *cp;
       int n;

       freelist = cp = malloc(sizeof(struct session) * NEWPOOL);
       for (n = 0; n < NEWPOOL; n++) {
               cp->next = cp + 1;
               memset(cp->addr, 0, 6);
               cp++;
       }
       cp[-1].next = NULL;
}

char *
etheraddr(e)
       u_int8_t e[];
{
       static char address[18];

       sprintf(address,
               "%x:%x:%x:%x:%x:%x", e[0], e[1], e[2], e[3], e[4], e[5]);
       return address;
}

static struct bpf_insn bpf_insn[] = {
#define FRAMEHEADER ((struct frame *)0)
   { BPF_LD|BPF_H|BPF_ABS,  0, 0, (long)&FRAMEHEADER->type },
   { BPF_JMP|BPF_JEQ|BPF_K, 0, 1, FRAMETYPE },
   { BPF_RET|BPF_K,         0, 0, FRAMELEN },
   { BPF_RET|BPF_K,         0, 0, 0x0 }
#undef FRAMEHEADER
};
static struct bpf_program bpf_pgm = {
   sizeof(bpf_insn)/sizeof(bpf_insn[0]), bpf_insn
};

void
createbpfport(ifname, iobufp, iolenp, st)
       char *ifname;
       char **iobufp;
       int *iolenp;
       struct station *st;
{
       int n, fd;
       char xname[IFNAMSIZ];
       u_int8_t dladdr[6];

       n = 0;
       do {
               devbpf[8] = n + '0';
               fd = open(devbpf, O_RDWR, 0);
               if (fd > 0)
                       goto found;
       } while (errno != ENOENT && ++n < 10);
       fprintf(stderr, "No bpf device available\n");
       exit(1);
found:
       memset(xname, 0, sizeof(memset));
       if (ifname != NULL)
               strcpy(xname, ifname);
       if (pickif(xname, dladdr) < 0) {
               fprintf(stderr, "No network interface available\n");
               exit(1);
       }
       ioctl(fd, BIOCSETIF, xname);
       ioctl(fd, BIOCGDLT, &n);        /* XXX - should check whether EN10MB */
       n = 1; ioctl(fd, BIOCIMMEDIATE, &n);
       ioctl(fd, BIOCGBLEN, &n);
       ioctl(fd, BIOCSETF, &bpf_pgm);

       *iobufp = (char *)malloc(n);
       *iolenp = n;
       st->fd = fd;
       memcpy(st->ifname, xname, IFNAMSIZ);
       memcpy(st->addr, dladdr, 6);
}

int
pickif(xname, dladdr)
       char *xname;
       u_int8_t dladdr[6];
{
#define MATCH(x,v) ((v)==((v)&(x)))
       int s, len, excess, error;
       struct ifconf ifconfs;
       struct ifreq *ifr, reqbuf[32];

       s = socket(AF_INET, SOCK_DGRAM, 0);
       ifconfs.ifc_len = sizeof(reqbuf);
       ifconfs.ifc_buf = (caddr_t)reqbuf;
       ioctl(s, SIOCGIFCONF, &ifconfs);
       ifr = ifconfs.ifc_req;
       len = ifconfs.ifc_len;
       error = -1;
       while (len > 0) {
               excess = ifr->ifr_addr.sa_len - sizeof(struct sockaddr);
               if (ifr->ifr_addr.sa_family == AF_LINK) {
                       struct sockaddr_dl *sdl = (void *)&ifr->ifr_addr;

                       memcpy(dladdr, (caddr_t)LLADDR(sdl), sdl->sdl_alen);
                       ioctl(s, SIOCGIFFLAGS, ifr);
                       if (MATCH(ifr->ifr_flags, IFF_UP|IFF_BROADCAST)) {
                               if (xname[0] == '\0') {
                                       strcpy(xname, ifr->ifr_name);
                                       error = 0;
                                       break;
                               }
                               else if (strcmp(xname, ifr->ifr_name) == 0) {
                                       error = 0;
                                       break;
                               }
                       }
               }
               ifr += 1;
               len -= sizeof(struct ifreq);
               if (excess > 0) {
                       ifr = (struct ifreq *)((char *)ifr + excess);
                       len -= excess;
               }
       }
       close(s);
       return error;
#undef MATCH
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.