int
isns_req_receive(int s, struct isns_req *req)
{
struct isns_hdr *hdr;
ssize_t res, len;
req->ir_usedlen = 0;
isns_req_getspace(req, sizeof(*hdr));
res = read(s, req->ir_buf, sizeof(*hdr));
if (res < (ssize_t)sizeof(*hdr))
return (-1);
req->ir_usedlen = sizeof(*hdr);
hdr = (struct isns_hdr *)req->ir_buf;
if (be16dec(hdr->ih_version) != ISNS_VERSION)
return (-1);
if ((be16dec(hdr->ih_flags) & (ISNS_FLAG_LAST | ISNS_FLAG_FIRST)) !=
(ISNS_FLAG_LAST | ISNS_FLAG_FIRST))
return (-1);
len = be16dec(hdr->ih_length);
isns_req_getspace(req, len);
res = read(s, &req->ir_buf[req->ir_usedlen], len);
if (res < len)
return (-1);
req->ir_usedlen += len;
return (0);
}
/*
* Decode the relevant fields of a sun disk label, and return zero if the
* magic and checksum works out OK.
*/
int
sunlabel_dec(void const *pp, struct sun_disklabel *sl)
{
const uint8_t *p;
size_t i;
u_int u;
p = pp;
for (i = 0; i < sizeof(sl->sl_text); i++)
sl->sl_text[i] = p[SL_TEXT + i];
sl->sl_rpm = be16dec(p + SL_RPM);
sl->sl_pcylinders = be16dec(p + SL_PCYLINDERS);
sl->sl_sparespercyl = be16dec(p + SL_SPARESPERCYL);
sl->sl_interleave = be16dec(p + SL_INTERLEAVE);
sl->sl_ncylinders = be16dec(p + SL_NCYLINDERS);
sl->sl_acylinders = be16dec(p + SL_ACYLINDERS);
sl->sl_ntracks = be16dec(p + SL_NTRACKS);
sl->sl_nsectors = be16dec(p + SL_NSECTORS);
for (i = 0; i < SUN_NPART; i++) {
sl->sl_part[i].sdkp_cyloffset = be32dec(p + SL_PART +
(i * SDKP_SIZEOF) + SDKP_CYLOFFSET);
sl->sl_part[i].sdkp_nsectors = be32dec(p + SL_PART +
(i * SDKP_SIZEOF) + SDKP_NSECTORS);
}
sl->sl_magic = be16dec(p + SL_MAGIC);
for (i = u = 0; i < SUN_SIZE; i += 2)
u ^= be16dec(p + i);
if (u == 0 && sl->sl_magic == SUN_DKMAGIC)
return (0);
else
return (EINVAL);
}
void
uuid_dec_be(void const *buf, struct uuid *uuid)
{
const uint8_t *p = buf;
int i;
uuid->time_low = be32dec(p);
uuid->time_mid = be16dec(p + 4);
uuid->time_hi_and_version = be16dec(p + 6);
uuid->clock_seq_hi_and_reserved = p[8];
uuid->clock_seq_low = p[9];
for (i = 0; i < _UUID_NODE_LEN; i++)
uuid->node[i] = p[10 + i];
}
/*
* Encode the relevant fields into a sun disklabel, compute new checksum.
*/
void
sunlabel_enc(void *pp, struct sun_disklabel *sl)
{
uint8_t *p;
size_t i;
u_int u;
p = pp;
for (i = 0; i < SL_TEXT_SIZEOF; i++)
p[SL_TEXT + i] = sl->sl_text[i];
be16enc(p + SL_RPM, sl->sl_rpm);
be16enc(p + SL_PCYLINDERS, sl->sl_pcylinders);
be16enc(p + SL_SPARESPERCYL, sl->sl_sparespercyl);
be16enc(p + SL_INTERLEAVE, sl->sl_interleave);
be16enc(p + SL_NCYLINDERS, sl->sl_ncylinders);
be16enc(p + SL_ACYLINDERS, sl->sl_acylinders);
be16enc(p + SL_NTRACKS, sl->sl_ntracks);
be16enc(p + SL_NSECTORS, sl->sl_nsectors);
for (i = 0; i < SUN_NPART; i++) {
be32enc(p + SL_PART + (i * SDKP_SIZEOF) + SDKP_CYLOFFSET,
sl->sl_part[i].sdkp_cyloffset);
be32enc(p + SL_PART + (i * SDKP_SIZEOF) + SDKP_NSECTORS,
sl->sl_part[i].sdkp_nsectors);
}
be16enc(p + SL_MAGIC, sl->sl_magic);
for (i = u = 0; i < SUN_SIZE; i += 2)
u ^= be16dec(p + i);
be16enc(p + SL_CKSUM, u);
}
static uint64_t tdecode(int t, ...)
{
uint8_t buf[16];
bool be = t > 0;
va_list ap;
uint64_t val = 777;
int i;
if (t < 0) t = -t;
va_start(ap, t);
memset(buf, 0xC1, sizeof(buf));
for (i = 0; i < t; i++)
buf[i] = va_arg(ap, int);
va_end(ap);
if (be) {
switch (t) {
case 2: val = be16dec(buf); break;
case 4: val = be32dec(buf); break;
case 8: val = be64dec(buf); break;
}
} else {
switch (t) {
case 2: val = le16dec(buf); break;
case 4: val = le32dec(buf); break;
case 8: val = le64dec(buf); break;
}
}
return val;
}
static void
g_dec_drvrdesc(u_char *ptr, struct g_apple_softc *sc)
{
sc->dd_bsiz = be16dec(ptr + 2);
sc->dd_blkcnt = be32dec(ptr + 4);
sc->dd_drvrcnt = be32dec(ptr + 16);
}
static struct servent *
_servent_getbyport(struct servent_data *sd, struct servent *sp, int port,
const char *proto)
{
if ((sd->flags & (_SV_CDB | _SV_PLAINFILE)) == 0)
return NULL;
if (sd->flags & _SV_CDB) {
uint8_t buf[255 + 4];
size_t protolen;
const uint8_t *data;
const void *data_ptr;
size_t datalen;
port = be16toh(port);
if (proto != NULL && *proto == '\0')
return NULL;
if (proto != NULL)
protolen = strlen(proto);
else
protolen = 0;
if (port < 0 || port > 65536)
return NULL;
buf[0] = 0;
buf[1] = protolen;
be16enc(buf + 2, port);
memcpy(buf + 4, proto, protolen);
if (cdbr_find(sd->cdb, buf, 4 + protolen,
&data_ptr, &datalen))
return NULL;
if (datalen < protolen + 4)
return NULL;
data = data_ptr;
if (be16dec(data) != port)
return NULL;
if (protolen) {
if (data[2] != protolen)
return NULL;
if (memcmp(data + 3, proto, protolen + 1))
return NULL;
}
return _servent_parsedb(sd, sp, data, datalen);
} else {
while (_servent_getline(sd) != -1) {
if (_servent_parseline(sd, sp) == NULL)
continue;
if (sp->s_port != port)
continue;
if (proto == NULL || strcmp(sp->s_proto, proto) == 0)
return sp;
}
return NULL;
}
}
unsigned int
peak_tcp_prepare(struct peak_packet *packet)
{
struct tcphdr *th = packet->flow.th;
unsigned int flow_hlen, flags;
flow_hlen = th->th_off << 2;
if (unlikely(flow_hlen < sizeof(*th) ||
flow_hlen > TCP_MAXHLEN)) {
return (1);
}
if (unlikely(flow_hlen > packet->flow_len)) {
return (1);
}
if (unlikely(!th->th_sport || !th->th_dport)) {
return (1);
}
/* XXX verify checksum */
flags = th->th_flags;
if (flags & TH_SYN) {
if (flags & TH_RST) {
return (1);
}
} else {
if (!(flags & (TH_ACK|TH_RST))) {
return (1);
}
}
if (!(flags & TH_ACK)) {
if (flags & (TH_FIN|TH_PUSH|TH_URG)) {
return (1);
}
}
packet->app.raw = packet->flow.raw + flow_hlen;
packet->app_len = packet->flow_len - flow_hlen;
packet->flow_sport = be16dec(&th->th_sport);
packet->flow_dport = be16dec(&th->th_dport);
packet->flow_hlen = flow_hlen;
return (0);
}
static u_int64_t
elf_get_quarter(Elf32_Ehdr *e, void *base, elf_member_t member)
{
u_int64_t val;
val = 0;
switch (e->e_ident[EI_CLASS]) {
case ELFCLASS32:
base = (char *)base + elf32_offsets[member];
switch (e->e_ident[EI_DATA]) {
case ELFDATA2MSB:
val = be16dec(base);
break;
case ELFDATA2LSB:
val = le16dec(base);
break;
case ELFDATANONE:
errx(1, "invalid data format");
}
break;
case ELFCLASS64:
base = (char *)base + elf64_offsets[member];
switch (e->e_ident[EI_DATA]) {
case ELFDATA2MSB:
val = be16dec(base);
break;
case ELFDATA2LSB:
val = le16dec(base);
break;
case ELFDATANONE:
errx(1, "invalid data format");
}
break;
case ELFCLASSNONE:
errx(1, "invalid class");
}
return val;
}
static void
le_lebuffer_copytodesc(struct lance_softc *sc, void *fromv, int off, int len)
{
struct le_lebuffer_softc *lesc = (struct le_lebuffer_softc *)sc;
caddr_t from = fromv;
for (; len >= 8; len -= 8, off += 8, from += 8)
bus_write_8(lesc->sc_bres, off, be64dec(from));
for (; len >= 4; len -= 4, off += 4, from += 4)
bus_write_4(lesc->sc_bres, off, be32dec(from));
for (; len >= 2; len -= 2, off += 2, from += 2)
bus_write_2(lesc->sc_bres, off, be16dec(from));
if (len == 1)
bus_write_1(lesc->sc_bres, off, *from);
}
/*
* Encode the relevant fields into a sun disklabel, compute new checksum.
*/
void
sunlabel_enc(void *pp, struct sun_disklabel *sl)
{
uint8_t *p;
size_t i;
u_int u;
p = pp;
for (i = 0; i < SL_TEXT_SIZEOF; i++)
p[SL_TEXT + i] = sl->sl_text[i];
be16enc(p + SL_RPM, sl->sl_rpm);
be16enc(p + SL_PCYLINDERS, sl->sl_pcylinders);
be16enc(p + SL_SPARESPERCYL, sl->sl_sparespercyl);
be16enc(p + SL_INTERLEAVE, sl->sl_interleave);
be16enc(p + SL_NCYLINDERS, sl->sl_ncylinders);
be16enc(p + SL_ACYLINDERS, sl->sl_acylinders);
be16enc(p + SL_NTRACKS, sl->sl_ntracks);
be16enc(p + SL_NSECTORS, sl->sl_nsectors);
for (i = 0; i < SUN_NPART; i++) {
be32enc(p + SL_PART + (i * SDKP_SIZEOF) + SDKP_CYLOFFSET,
sl->sl_part[i].sdkp_cyloffset);
be32enc(p + SL_PART + (i * SDKP_SIZEOF) + SDKP_NSECTORS,
sl->sl_part[i].sdkp_nsectors);
}
be16enc(p + SL_MAGIC, sl->sl_magic);
if (sl->sl_vtoc_sane == SUN_VTOC_SANE
&& sl->sl_vtoc_nparts == SUN_NPART) {
/*
* Write SVR4-compatible VTOC elements.
*/
be32enc(p + SL_VTOC_VERS, sl->sl_vtoc_vers);
be32enc(p + SL_VTOC_SANITY, SUN_VTOC_SANE);
memcpy(p + SL_VTOC_VOLNAME, sl->sl_vtoc_volname,
SUN_VOLNAME_LEN);
be16enc(p + SL_VTOC_NPART, SUN_NPART);
for (i = 0; i < SUN_NPART; i++) {
be16enc(p + SL_VTOC_MAP + (i * SVTOC_SIZEOF)
+ SVTOC_TAG,
sl->sl_vtoc_map[i].svtoc_tag);
be16enc(p + SL_VTOC_MAP + (i * SVTOC_SIZEOF)
+ SVTOC_FLAG,
sl->sl_vtoc_map[i].svtoc_flag);
}
}
for (i = u = 0; i < SUN_SIZE; i += 2)
u ^= be16dec(p + i);
be16enc(p + SL_CKSUM, u);
}
int
isns_req_send(int s, struct isns_req *req)
{
struct isns_hdr *hdr;
int res;
hdr = (struct isns_hdr *)req->ir_buf;
be16enc(hdr->ih_length, req->ir_usedlen - sizeof(*hdr));
be16enc(hdr->ih_flags, be16dec(hdr->ih_flags) |
ISNS_FLAG_LAST | ISNS_FLAG_FIRST);
be16enc(hdr->ih_transaction, 0);
be16enc(hdr->ih_sequence, 0);
res = write(s, req->ir_buf, req->ir_usedlen);
return ((res < 0) ? -1 : 0);
}
static void
test_load(const char *file, const unsigned int *len, const size_t count)
{
struct peak_load *trace = peak_load_init(file);
struct ether_header *eth;
size_t i;
assert(trace);
eth = (struct ether_header *)trace->buf;
for (i = 0; i < count; ++i) {
assert(peak_load_next(trace) == len[i]);
assert(be16dec(ð->ether_type) == ETHERTYPE_IP);
}
assert(!peak_load_next(trace));
assert(!peak_load_next(trace));
peak_load_exit(trace);
}
static int
vend_rfc1048(u_char *cp, u_int len)
{
u_char *ep;
int size;
u_char tag;
const char *val;
#ifdef BOOTP_DEBUG
if (debug)
printf("vend_rfc1048 bootp info. len=%d\n", len);
#endif
ep = cp + len;
/* Step over magic cookie */
cp += sizeof(int);
setenv_(cp, ep, NULL);
while (cp < ep) {
tag = *cp++;
size = *cp++;
if (tag == TAG_END)
break;
if (tag == TAG_SUBNET_MASK) {
bcopy(cp, &netmask, sizeof(netmask));
}
if (tag == TAG_GATEWAY) {
bcopy(cp, &gateip.s_addr, sizeof(gateip.s_addr));
}
if (tag == TAG_SWAPSERVER) {
/* let it override bp_siaddr */
bcopy(cp, &rootip.s_addr, sizeof(rootip.s_addr));
}
if (tag == TAG_ROOTPATH) {
if ((val = getenv("dhcp.root-path")) == NULL)
val = (const char *)cp;
strlcpy(rootpath, val, sizeof(rootpath));
}
if (tag == TAG_HOSTNAME) {
if ((val = getenv("dhcp.host-name")) == NULL)
val = (const char *)cp;
strlcpy(hostname, val, sizeof(hostname));
}
if (tag == TAG_INTF_MTU) {
intf_mtu = 0;
if ((val = getenv("dhcp.interface-mtu")) != NULL) {
unsigned long tmp;
char *end;
errno = 0;
/*
* Do not allow MTU to exceed max IPv4 packet
* size, max value of 16-bit word.
*/
tmp = strtoul(val, &end, 0);
if (errno != 0 ||
*val == '\0' || *end != '\0' ||
tmp > USHRT_MAX) {
printf("%s: bad value: \"%s\", "
"ignoring\n",
"dhcp.interface-mtu", val);
} else {
intf_mtu = (u_int)tmp;
}
}
if (intf_mtu == 0)
intf_mtu = be16dec(cp);
}
#ifdef SUPPORT_DHCP
if (tag == TAG_DHCP_MSGTYPE) {
if(*cp != expected_dhcpmsgtype)
return(-1);
dhcp_ok = 1;
}
if (tag == TAG_SERVERID) {
bcopy(cp, &dhcp_serverip.s_addr,
sizeof(dhcp_serverip.s_addr));
}
#endif
cp += size;
}
return(0);
}
/*
* Decode the relevant fields of a sun disk label, and return zero if the
* magic and checksum works out OK.
*/
int
sunlabel_dec(void const *pp, struct sun_disklabel *sl)
{
const uint8_t *p;
size_t i;
u_int u;
uint32_t vtocsane;
uint16_t npart;
p = pp;
for (i = 0; i < sizeof(sl->sl_text); i++)
sl->sl_text[i] = p[SL_TEXT + i];
sl->sl_rpm = be16dec(p + SL_RPM);
sl->sl_pcylinders = be16dec(p + SL_PCYLINDERS);
sl->sl_sparespercyl = be16dec(p + SL_SPARESPERCYL);
sl->sl_interleave = be16dec(p + SL_INTERLEAVE);
sl->sl_ncylinders = be16dec(p + SL_NCYLINDERS);
sl->sl_acylinders = be16dec(p + SL_ACYLINDERS);
sl->sl_ntracks = be16dec(p + SL_NTRACKS);
sl->sl_nsectors = be16dec(p + SL_NSECTORS);
for (i = 0; i < SUN_NPART; i++) {
sl->sl_part[i].sdkp_cyloffset = be32dec(p + SL_PART +
(i * SDKP_SIZEOF) + SDKP_CYLOFFSET);
sl->sl_part[i].sdkp_nsectors = be32dec(p + SL_PART +
(i * SDKP_SIZEOF) + SDKP_NSECTORS);
}
sl->sl_magic = be16dec(p + SL_MAGIC);
vtocsane = be32dec(p + SL_VTOC_SANITY);
npart = be16dec(p + SL_VTOC_NPART);
if (vtocsane == SUN_VTOC_SANE && npart == SUN_NPART) {
/*
* Seems we've got SVR4-compatible VTOC information
* as well, decode it.
*/
sl->sl_vtoc_sane = vtocsane;
sl->sl_vtoc_vers = be32dec(p + SL_VTOC_VERS);
memcpy(sl->sl_vtoc_volname, p + SL_VTOC_VOLNAME,
SUN_VOLNAME_LEN);
sl->sl_vtoc_nparts = SUN_NPART;
for (i = 0; i < SUN_NPART; i++) {
sl->sl_vtoc_map[i].svtoc_tag = be16dec(p +
SL_VTOC_MAP + (i * SVTOC_SIZEOF) + SVTOC_TAG);
sl->sl_vtoc_map[i].svtoc_flag = be16dec(p +
SL_VTOC_MAP + (i * SVTOC_SIZEOF) + SVTOC_FLAG);
}
}
for (i = u = 0; i < SUN_SIZE; i += 2)
u ^= be16dec(p + i);
if (u == 0 && sl->sl_magic == SUN_DKMAGIC)
return (0);
else
return (EINVAL);
}
struct servent *
_servent_parsedb(struct servent_data *sd, struct servent *sp,
const uint8_t *data, size_t len)
{
char **q;
size_t i;
int oerrno;
if ((sd->flags & _SV_STAYOPEN) == 0) {
if (len > sd->cdb_buf_len) {
void *tmp = realloc(sd->cdb_buf, len);
if (tmp == NULL)
goto fail;
sd->cdb_buf = tmp;
sd->cdb_buf_len = len;
}
memcpy(sd->cdb_buf, data, len);
data = sd->cdb_buf;
}
if (len < 2)
goto fail;
sp->s_port = htobe16(be16dec(data));
data += 2;
len -= 2;
if (len == 0 || len < (size_t)data[0] + 2)
goto fail;
sp->s_proto = __UNCONST(data + 1);
if (sp->s_proto[data[0]] != '\0')
goto fail;
len -= 2 + data[0];
data += 2 + data[0];
if (len == 0)
goto fail;
if (len < (size_t)data[0] + 2)
goto fail;
sp->s_name = __UNCONST(data + 1);
len -= 2 + data[0];
data += 2 + data[0];
if (sd->aliases == NULL) {
sd->maxaliases = 10;
sd->aliases = malloc(sd->maxaliases * sizeof(char *));
if (sd->aliases == NULL)
goto fail;
}
sp->s_aliases = sd->aliases;
i = 0;
while (len) {
if (len < (size_t)data[0] + 2)
goto fail;
if (i == sd->maxaliases - 2) {
sd->maxaliases *= 2;
q = realloc(sd->aliases, sd->maxaliases * sizeof(*q));
if (q == NULL)
goto fail;
sp->s_aliases = sd->aliases = q;
}
sp->s_aliases[i++] = __UNCONST(data + 1);
len -= 2 + data[0];
data += 2 + data[0];
}
sp->s_aliases[i] = NULL;
return sp;
fail:
oerrno = errno;
endservent_r(sd);
errno = oerrno;
return NULL;
}
