int main()
{
char cmdline[BUFMAX];
scrub(cmdline);
while(1){
//read in a command
fflush(stdout);
read(0,cmdline,BUFMAX);
//check for special io cases: <,>,or |
bool diffin = (strpbrk(cmdline,"<")!=NULL);
bool diffout = (strpbrk(cmdline,">")!=NULL);
bool mario = (strpbrk(cmdline,"|")!=NULL);
//if the command is exit, exit
if((strncmp(cmdline,"exit",4)==0)||(strncmp(cmdline,"quit",4)==0)){
printf("Bye!\n");
return(0);//should this be exit(0)? Does it matter? I think this is right
}else if(strncmp(cmdline,"cd",2)==0){
cd(cmdline);
//if the command is cd, change directory
}else if(diffin){
//do stuff- redirect from some input file, I guess
}else if((!mario)&&(!diffout)){
//do stuff- there's no redirect or pipe of any kind
}else if((!mario)&&(diffout)){
//do stuff- redirect out, but no pipe
}else if((mario)&&(!diffout)){
//do stuff- no redirect out, but a pipe is involved
char* jrr = strtok(cmdline, "|\n");
char left[256];
char right[256];
strcpy(left,jrr);
jrr = strtok(NULL, "|\n");
strcpy(right, jrr);
printf("\nLeft = ");
printf(left);
printf("\nRight = ");
printf(right);
printf("\n");
scrub(left);
scrub(right);
}else if((mario)&&(diffout)){
//do stuff- redirect out AND there's a pipe
}else{
printf("\nThis happened. Probably a bug, huh?\n");
}
}
return(0);
}
static void
grub_stop(void)
{
struct stat buf;
if (chdir("/boot/grub") != 0) {
perror("cannot chdir to /boot/grub/");
exit(-1);
}
if (stat("grub.conf", &buf) == 0) {
if (unlink("grub.conf") < 0) {
perror("cannot unlink /boot/grub/grub.conf");
exit(-1);
}
}
system("cp grub-orig.conf grub.conf");
/*
* if the node PXE installed, then put the boot record back
*/
if (stat("/boot/grub/pxe-install", &buf) == 0) {
scrub(BOOTABLE);
}
} /* grub_stop */
static void
grub_start(const char *target)
{
struct stat buf;
char errstr[128];
char cmd[128];
if (chdir("/boot/grub") != 0) {
perror("cannot chdir to /boot/grub/");
exit(-1);
}
if (stat("grub.conf", &buf) == 0) {
if (unlink("grub.conf") < 0) {
perror("cannot unlink /boot/grub/grub.conf");
exit(-1);
}
}
sprintf(cmd, "cp %s grub.conf", target);
system(cmd);
/*
* if the node PXE installed, then make the boot disk unbootable
*/
if (doScrub && stat("/boot/grub/pxe-install", &buf) == 0) {
scrub(UNBOOTABLE);
}
} /* grub_start */
void out_free(void *block, oskit_size_t size)
{
check_guard("post", block+size);
block -= GUARD_SIZE;
size += GUARD_SIZE * 2;
check_guard("pre", block);
scrub(block,size);
in_free(block,size);
}
bool Lexicon::contains(const std::string& word) const {
if (word.empty()) {
return false;
}
std::string scrubbed = word;
if (!scrub(scrubbed)) {
return false;
}
return containsHelper(m_root, scrubbed, /* isPrefix */ false);
}
bool Lexicon::containsPrefix(const std::string& prefix) const {
if (prefix.empty()) {
return true;
}
std::string scrubbed = prefix;
if (!scrub(scrubbed)) {
return false;
}
return containsHelper(m_root, scrubbed, /* isPrefix */ true);
}
bool Lexicon::remove(const std::string& word) {
if (word.empty()) {
return false;
}
std::string scrubbed = word;
if (!scrub(scrubbed)) {
return false;
}
return removeHelper(m_root, scrubbed, /* originalWord */ scrubbed, /* isPrefix */ false);
}
bool Lexicon::add(const std::string& word) {
if (word.empty()) {
return false;
}
std::string scrubbed = word;
if (!scrub(scrubbed)) {
return false;
}
return addHelper(m_root, scrubbed, /* originalWord */ scrubbed);
}
int main (int argc, char **argv) {
init();
if (fork() !=0 ) return 0;
(void) signal(SIGCLD, SIG_IGN);
(void) signal(SIGHUP, SIG_IGN);
scrub();
logText("Starting");
serverListen(8082);
fail("testing failure");
}
bool Lexicon::removePrefix(const std::string& prefix) {
if (prefix.empty()) {
bool result = !isEmpty();
clear();
return result;
}
std::string scrubbed = prefix;
if (!scrub(scrubbed)) {
return false;
}
return removeHelper(m_root, scrubbed, /* originalWord */ scrubbed, /* isPrefix */ true);
}
static int
dnsTimeoutHandler(TimeEventHandlerPtr event)
{
DnsQueryPtr query = *(DnsQueryPtr*)event->data;
ObjectPtr object = query->object;
int rc;
/* People are reporting that this does happen. And I have no idea why. */
if(!queryInFlight(query)) {
do_log(L_ERROR, "BUG: timing out martian query (%s, flags: 0x%x).\n",
scrub(query->name->string), (unsigned)object->flags);
return 1;
}
query->timeout = MAX(10, query->timeout * 2);
if(query->timeout > dnsMaxTimeout) {
abortObject(object, 501, internAtom("Timeout"));
goto fail;
} else {
rc = sendQuery(query);
if(rc < 0) {
if(rc != -EWOULDBLOCK && rc != -EAGAIN && rc != -ENOBUFS) {
abortObject(object, 501,
internAtomError(-rc,
"Couldn't send DNS query"));
goto fail;
}
/* else let it timeout */
}
query->timeout_handler =
scheduleTimeEvent(query->timeout, dnsTimeoutHandler,
sizeof(query), &query);
if(query->timeout_handler == NULL) {
do_log(L_ERROR, "Couldn't schedule DNS timeout handler.\n");
abortObject(object, 501,
internAtom("Couldn't schedule DNS timeout handler"));
goto fail;
}
return 1;
}
fail:
removeQuery(query);
object->flags &= ~OBJECT_INPROGRESS;
if(query->inet4) releaseAtom(query->inet4);
if(query->inet6) releaseAtom(query->inet6);
free(query);
releaseNotifyObject(object);
return 1;
}
static void
grub_stop(void)
{
struct stat buf;
if (chdir("/boot/grub") != 0) {
perror("cannot chdir to /boot/grub/");
exit(-1);
}
/*
* if the node PXE installed, then put the boot record back
*/
if (stat("/boot/grub/pxe-install", &buf) == 0) {
scrub(BOOTABLE);
}
} /* grub_stop */
static void
grub_start(const char *target)
{
struct stat buf;
/* char errstr[128]; */
/* Global: int doScrub */
if (chdir("/boot/grub") != 0) {
perror("cannot chdir to /boot/grub/");
exit(-1);
}
/*
* if the node PXE installed, then make the boot disk unbootable
*/
if (doScrub && stat("/boot/grub/pxe-install", &buf) == 0) {
scrub(UNBOOTABLE);
}
} /* grub_start */
void TFrameHandle::scrubXsheet(int r0, int r1, TXsheet *xsheet, double framePerSecond)
{
m_xsheet = xsheet;
if (!scrub(r0, r1, framePerSecond))
m_xsheet = 0;
}
void TFrameHandle::scrubColumn(int r0, int r1, TXshSoundColumn *audioColumn, double framePerSecond)
{
m_audioColumn = audioColumn;
if (!scrub(r0, r1, framePerSecond))
m_audioColumn = 0;
}
void MobileVRInterface::set_position_from_sensors() {
_THREAD_SAFE_METHOD_
// this is a helper function that attempts to adjust our transform using our 9dof sensors
// 9dof is a misleading marketing term coming from 3 accelerometer axis + 3 gyro axis + 3 magnetometer axis = 9 axis
// but in reality this only offers 3 dof (yaw, pitch, roll) orientation
uint64_t ticks = OS::get_singleton()->get_ticks_usec();
uint64_t ticks_elapsed = ticks - last_ticks;
float delta_time = (double)ticks_elapsed / 1000000.0;
// few things we need
Input *input = Input::get_singleton();
Vector3 down(0.0, -1.0, 0.0); // Down is Y negative
Vector3 north(0.0, 0.0, 1.0); // North is Z positive
// make copies of our inputs
bool has_grav = false;
Vector3 acc = input->get_accelerometer();
Vector3 gyro = input->get_gyroscope();
Vector3 grav = input->get_gravity();
Vector3 magneto = scale_magneto(input->get_magnetometer()); // this may be overkill on iOS because we're already getting a calibrated magnetometer reading
if (sensor_first) {
sensor_first = false;
} else {
acc = scrub(acc, last_accerometer_data, 2, 0.2);
magneto = scrub(magneto, last_magnetometer_data, 3, 0.3);
};
last_accerometer_data = acc;
last_magnetometer_data = magneto;
if (grav.length() < 0.1) {
// not ideal but use our accelerometer, this will contain shakey shakey user behaviour
// maybe look into some math but I'm guessing that if this isn't available, its because we lack the gyro sensor to actually work out
// what a stable gravity vector is
grav = acc;
if (grav.length() > 0.1) {
has_grav = true;
};
} else {
has_grav = true;
};
bool has_magneto = magneto.length() > 0.1;
if (gyro.length() > 0.1) {
/* this can return to 0.0 if the user doesn't move the phone, so once on, it's on */
has_gyro = true;
};
if (has_gyro) {
// start with applying our gyro (do NOT smooth our gyro!)
Basis rotate;
rotate.rotate(orientation.get_axis(0), gyro.x * delta_time);
rotate.rotate(orientation.get_axis(1), gyro.y * delta_time);
rotate.rotate(orientation.get_axis(2), gyro.z * delta_time);
orientation = rotate * orientation;
tracking_state = ARVRInterface::ARVR_NORMAL_TRACKING;
};
///@TODO improve this, the magnetometer is very fidgity sometimes flipping the axis for no apparent reason (probably a bug on my part)
// if you have a gyro + accelerometer that combo tends to be better then combining all three but without a gyro you need the magnetometer..
if (has_magneto && has_grav && !has_gyro) {
// convert to quaternions, easier to smooth those out
Quat transform_quat(orientation);
Quat acc_mag_quat(combine_acc_mag(grav, magneto));
transform_quat = transform_quat.slerp(acc_mag_quat, 0.1);
orientation = Basis(transform_quat);
tracking_state = ARVRInterface::ARVR_NORMAL_TRACKING;
} else if (has_grav) {
// use gravity vector to make sure down is down...
// transform gravity into our world space
grav.normalize();
Vector3 grav_adj = orientation.xform(grav);
float dot = grav_adj.dot(down);
if ((dot > -1.0) && (dot < 1.0)) {
// axis around which we have this rotation
Vector3 axis = grav_adj.cross(down);
axis.normalize();
Basis drift_compensation(axis, acos(dot) * delta_time * 10);
orientation = drift_compensation * orientation;
};
};
// JIC
orientation.orthonormalize();
last_ticks = ticks;
};
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Lab Required Functions - public
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
bool Hash::insert(int x)
{
if (contains(x))
return false;
int index = 0;
std::cout << "Load factor: " << (float(active + 1) / float(m_size)) << std::endl;
if ((float(active + 1) / float(m_size)) > 0.5)
{
Hash* tempList = new Hash();
Node* temp = m_front;
for (int i = 0; i < m_size; i++)
{
if (temp->getValue() != -1)
tempList->addBack(temp->getValue());
temp = temp->getNext();
}//for - gather hashed data
tempList->addBack(x);
//scrub hash
scrub();
//reset active
active = 0;
//adjust list for new bucket size (after calculating next prime #)
adjust(getPrime(m_size));
for ( ; !tempList->isEmpty(); )
{
int val = tempList->pop();
for(int i = 0; i < m_size; i++)
{
temp = m_front;
index = hash(val, i);
for (int k = 0; k < index; k++)
temp = temp->getNext();
if (temp->getValue() == -1)
{
temp->setValue(val);
active++;
//break loop
i = m_size;
}
//else keep going while hash = -1 with true flag
}//for each entry in the hash table (mod makes this cycle through every element)
}//for - while tempList is not empty
delete tempList;
return true;
}//if - rehash everything!
else
{
//insert new value
Node* temp = m_front;
for(int i = 0; i < m_size; i++)
{
temp = m_front;
index = hash(x, i);
//std::cout << "Val: " << i << " hash: " << index << std::endl;
for (int k = 0; k < index; k++)
temp = temp->getNext();
if (temp->getValue() == -1)
{
//std::cout << "Inserting value at: " << i << std::endl;
temp->setValue(x);
active++;
return true;
}
else if (temp->getValue() == x)
i = m_size; // duplicate precaution - really should never happen
//else keep going while hash = -1 with true flag
}//for each entry in the hash table (mod makes this cycle through every element)
}
return false;
}//insert
static int
dnsReplyHandler(int abort, FdEventHandlerPtr event)
{
int fd = event->fd;
char buf[2048];
int len, rc;
ObjectPtr object;
unsigned ttl = 0;
AtomPtr name, value, message = NULL;
int id;
int af;
DnsQueryPtr query;
AtomPtr cname = NULL;
if(abort) {
dnsSocketHandler = NULL;
rc = establishDnsSocket();
if(rc < 0) {
do_log(L_ERROR, "Couldn't reestablish DNS socket.\n");
/* At this point, we should abort all in-flight
DNS requests. Oh, well, they'll timeout anyway. */
}
return 1;
}
len = recv(fd, buf, 2048, 0);
if(len <= 0) {
if(errno == EINTR || errno == EAGAIN) return 0;
/* This is where we get ECONNREFUSED for an ICMP port unreachable */
do_log_error(L_ERROR, errno, "DNS: recv failed");
dnsGethostbynameFallback(-1, message);
return 0;
}
/* This could be a late reply to a query that timed out and was
resent, a reply to a query that timed out, or a reply to an
AAAA query when we already got a CNAME reply to the associated
A. We filter such replies straight away, without trying to
parse them. */
rc = dnsReplyId(buf, 0, len, &id);
if(rc < 0) {
do_log(L_WARN, "Short DNS reply.\n");
return 0;
}
if(!findQuery(id, NULL)) {
return 0;
}
rc = dnsDecodeReply(buf, 0, len, &id, &name, &value, &af, &ttl);
if(rc < 0) {
assert(value == NULL);
/* We only want to fallback on gethostbyname if we received a
reply that we could not understand. What about truncated
replies? */
if(rc < 0) {
do_log_error(L_WARN, -rc, "DNS");
if(dnsUseGethostbyname >= 2 ||
(dnsUseGethostbyname &&
(rc != -EDNS_HOST_NOT_FOUND && rc != -EDNS_NO_RECOVERY &&
rc != -EDNS_FORMAT))) {
dnsGethostbynameFallback(id, message);
return 0;
} else {
message = internAtom(pstrerror(-rc));
}
} else {
assert(name != NULL && id >= 0 && af >= 0);
}
}
query = findQuery(id, name);
if(query == NULL) {
/* Duplicate id ? */
releaseAtom(value);
releaseAtom(name);
return 0;
}
/* We're going to use the information in this reply. If it was an
error, construct an empty atom to distinguish it from information
we're still waiting for. */
if(value == NULL)
value = internAtom("");
again:
if(af == 4) {
if(query->inet4 == NULL) {
query->inet4 = value;
query->ttl4 = current_time.tv_sec + ttl;
} else
releaseAtom(value);
} else if(af == 6) {
if(query->inet6 == NULL) {
query->inet6 = value;
query->ttl6 = current_time.tv_sec + ttl;
} else
releaseAtom(value);
} else if(af == 0) {
/* Ignore errors in this case. */
if(query->inet4 && query->inet4->length == 0) {
releaseAtom(query->inet4);
query->inet4 = NULL;
}
if(query->inet6 && query->inet6->length == 0) {
releaseAtom(query->inet6);
query->inet6 = NULL;
}
if(query->inet4 || query->inet6) {
do_log(L_WARN, "Host %s has both %s and CNAME -- "
"ignoring CNAME.\n", scrub(query->name->string),
query->inet4 ? "A" : "AAAA");
releaseAtom(value);
value = internAtom("");
af = query->inet4 ? 4 : 6;
goto again;
} else {
cname = value;
}
}
if(rc >= 0 && !cname &&
((dnsQueryIPv6 < 3 && query->inet4 == NULL) ||
(dnsQueryIPv6 > 0 && query->inet6 == NULL)))
return 0;
/* This query is complete */
cancelTimeEvent(query->timeout_handler);
object = query->object;
if(object->flags & OBJECT_INITIAL) {
assert(!object->headers);
if(cname) {
assert(query->inet4 == NULL && query->inet6 == NULL);
object->headers = cname;
object->expires = current_time.tv_sec + ttl;
} else if((!query->inet4 || query->inet4->length == 0) &&
(!query->inet6 || query->inet6->length == 0)) {
releaseAtom(query->inet4);
releaseAtom(query->inet6);
object->expires = current_time.tv_sec + dnsNegativeTtl;
abortObject(object, 500, retainAtom(message));
} else if(!query->inet4 || query->inet4->length == 0) {
object->headers = query->inet6;
object->expires = query->ttl6;
releaseAtom(query->inet4);
} else if(!query->inet6 || query->inet6->length == 0) {
object->headers = query->inet4;
object->expires = query->ttl4;
releaseAtom(query->inet6);
} else {
/* need to merge results */
char buf[1024];
if(query->inet4->length + query->inet6->length > 1024) {
releaseAtom(query->inet4);
releaseAtom(query->inet6);
abortObject(object, 500, internAtom("DNS reply too long"));
} else {
if(dnsQueryIPv6 <= 1) {
memcpy(buf, query->inet4->string, query->inet4->length);
memcpy(buf + query->inet4->length,
query->inet6->string + 1, query->inet6->length - 1);
} else {
memcpy(buf, query->inet6->string, query->inet6->length);
memcpy(buf + query->inet6->length,
query->inet4->string + 1, query->inet4->length - 1);
}
object->headers =
internAtomN(buf,
query->inet4->length +
query->inet6->length - 1);
if(object->headers == NULL)
abortObject(object, 500,
internAtom("Couldn't allocate DNS atom"));
}
object->expires = MIN(query->ttl4, query->ttl6);
}
object->age = current_time.tv_sec;
object->flags &= ~(OBJECT_INITIAL | OBJECT_INPROGRESS);
} else {
do_log(L_WARN, "DNS object ex nihilo for %s.\n",
scrub(query->name->string));
}
removeQuery(query);
free(query);
releaseAtom(name);
releaseAtom(message);
releaseNotifyObject(object);
return 0;
}
static int
dnsDecodeReply(char *buf, int offset, int n, int *id_return,
AtomPtr *name_return, AtomPtr *value_return,
int *af_return, unsigned *ttl_return)
{
int i = offset, j, m;
int id = -1, b23, qdcount, ancount, nscount, arcount, rdlength;
int class, type;
unsigned int ttl;
char b[2048];
int af = -1;
AtomPtr name = NULL, value;
char addresses[1024];
int addr_index = 0;
int error = EDNS_NO_ADDRESS;
unsigned final_ttl = 7 * 24 * 3600;
int dnserror;
if(n - i < 12) {
error = EDNS_INVALID;
goto fail;
}
DO_NTOHS(id, &buf[i]); i += 2;
DO_NTOHS(b23, &buf[i]); i += 2;
DO_NTOHS(qdcount, &buf[i]); i += 2;
DO_NTOHS(ancount, &buf[i]); i += 2;
DO_NTOHS(nscount, &buf[i]); i += 2;
DO_NTOHS(arcount, &buf[i]); i += 2;
do_log(D_DNS,
"DNS id %d, b23 0x%x, qdcount %d, ancount %d, "
"nscount %d, arcount %d\n",
id, b23, qdcount, ancount, nscount, arcount);
if((b23 & (0xF870)) != 0x8000) {
do_log(L_ERROR, "Incorrect DNS reply (b23 = 0x%x).\n", b23);
error = EDNS_INVALID;
goto fail;
}
dnserror = b23 & 0xF;
if(b23 & 0x200) {
do_log(L_WARN, "Truncated DNS reply (b23 = 0x%x).\n", b23);
}
if(dnserror || qdcount != 1) {
if(!dnserror)
do_log(L_ERROR,
"Unexpected number %d of DNS questions.\n", qdcount);
if(dnserror == 1)
error = EDNS_FORMAT;
else if(dnserror == 2)
error = EDNS_NO_RECOVERY;
else if(dnserror == 3)
error = EDNS_HOST_NOT_FOUND;
else if(dnserror == 4 || dnserror == 5)
error = EDNS_REFUSED;
else if(dnserror == 0)
error = EDNS_INVALID;
else
error = EUNKNOWN;
goto fail;
}
/* We do this early, so that we can return the address family to
the caller in case of error. */
i = labelsToString(buf, i, n, b, 2048, &m);
if(i < 0) {
error = EDNS_FORMAT;
goto fail;
}
DO_NTOHS(type, &buf[i]); i += 2;
DO_NTOHS(class, &buf[i]); i += 2;
if(type == 1)
af = 4;
else if(type == 28)
af = 6;
else {
error = EDNS_FORMAT;
goto fail;
}
do_log(D_DNS, "DNS q: ");
do_log_n(D_DNS, b, m);
do_log(D_DNS, " (%d, %d)\n", type, class);
name = internAtomLowerN(b, m);
if(name == NULL) {
error = ENOMEM;
goto fail;
}
if(class != 1) {
error = EDNS_FORMAT;
goto fail;
}
#define PARSE_ANSWER(kind, label) \
do { \
i = labelsToString(buf, i, 1024, b, 2048, &m); \
if(i < 0) goto label; \
DO_NTOHS(type, &buf[i]); i += 2; if(i > 1024) goto label; \
DO_NTOHS(class, &buf[i]); i += 2; if(i > 1024) goto label; \
DO_NTOHL(ttl, &buf[i]); i += 4; if(i > 1024) goto label; \
DO_NTOHS(rdlength, &buf[i]); i += 2; if(i > 1024) goto label; \
do_log(D_DNS, "DNS " kind ": "); \
do_log_n(D_DNS, b, m); \
do_log(D_DNS, " (%d, %d): %d bytes, ttl %u\n", \
type, class, rdlength, ttl); \
} while(0)
for(j = 0; j < ancount; j++) {
PARSE_ANSWER("an", fail);
if(strcasecmp_n(name->string, b, m) == 0) {
if(class != 1) {
do_log(D_DNS, "DNS: %s: unknown class %d.\n",
name->string, class);
error = EDNS_UNSUPPORTED;
goto cont;
}
if(type == 1 || type == 28) {
if((type == 1 && rdlength != 4) ||
(type == 28 && rdlength != 16)) {
do_log(L_ERROR,
"DNS: %s: unexpected length %d of %s record.\n",
scrub(name->string),
rdlength, type == 1 ? "A" : "AAAA");
error = EDNS_INVALID;
if(rdlength <= 0 || rdlength >= 32)
goto fail;
goto cont;
}
if(af == 0) {
do_log(L_WARN, "DNS: %s: host has both A and CNAME -- "
"ignoring CNAME.\n", scrub(name->string));
addr_index = 0;
af = -1;
}
if(type == 1) {
if(af < 0)
af = 4;
else if(af == 6) {
do_log(L_WARN, "Unexpected AAAA reply.\n");
goto cont;
}
} else {
if(af < 0)
af = 6;
else if(af == 4) {
do_log(L_WARN, "Unexpected A reply.\n");
goto cont;
}
}
if(addr_index == 0) {
addresses[0] = DNS_A;
addr_index++;
} else {
if(addr_index > 1000) {
error = EDNS_INVALID;
goto fail;
}
}
assert(addresses[0] == DNS_A);
if(final_ttl > ttl)
final_ttl = ttl;
memset(&addresses[addr_index], 0, sizeof(HostAddressRec));
if(type == 1) {
addresses[addr_index] = 4;
memcpy(addresses + addr_index + 1, buf + i, 4);
} else {
addresses[addr_index] = 6;
memcpy(addresses + addr_index + 1, buf + i, 16);
}
addr_index += sizeof(HostAddressRec);
} else if(type == 5) {
int j, k;
if(af != 0 && addr_index > 0) {
do_log(L_WARN, "DNS: host has both CNAME and A -- "
"ignoring CNAME.\n");
goto cont;
}
af = 0;
if(addr_index != 0) {
/* Only warn if the CNAMEs are not identical */
char tmp[512]; int jj, kk;
assert(addresses[0] == DNS_CNAME);
jj = labelsToString(buf, i, n,
tmp, 512, &kk);
if(jj < 0 ||
kk != strlen(addresses + 1) ||
memcmp(addresses + 1, tmp, kk) != 0) {
do_log(L_WARN, "DNS: "
"%s: host has multiple CNAMEs -- "
"ignoring subsequent.\n",
scrub(name->string));
}
goto cont;
}
addresses[0] = DNS_CNAME;
addr_index++;
j = labelsToString(buf, i, n,
addresses + 1, 1020, &k);
if(j < 0) {
addr_index = 0;
error = ENAMETOOLONG;
continue;
}
addr_index = k + 1;
} else {
error = EDNS_NO_ADDRESS;
i += rdlength;
continue;
}
}
cont:
i += rdlength;
}
#if (LOGGING_MAX & D_DNS)
for(j = 0; j < nscount; j++) {
PARSE_ANSWER("ns", nofail);
i += rdlength;
}
for(j = 0; j < arcount; j++) {
PARSE_ANSWER("ar", nofail);
i += rdlength;
}
nofail:
#endif
#undef PARSE_ANSWER
do_log(D_DNS, "DNS: %d bytes\n", addr_index);
if(af < 0)
goto fail;
value = internAtomN(addresses, addr_index);
if(value == NULL) {
error = ENOMEM;
goto fail;
}
assert(af >= 0);
*id_return = id;
*name_return = name;
*value_return = value;
*af_return = af;
*ttl_return = final_ttl;
return 1;
fail:
*id_return = id;
*name_return = name;
*value_return = NULL;
*af_return = af;
return -error;
}
