// This is a C program that handles offloading of bandwidth from a web

// server. It's a sort of poor-man's Akamai. It doesn't need anything

// terribly complex (a webserver with cgi-bin support, a writable directory).

// It can run as a cgi-bin program, or as a quick-and-dirty standalone HTTP

// server.

//

// It works like this:

// - You have a webserver with dynamic content, and static content that

// may change arbitrarily (i.e. - various users making changes to their

// homepages, etc). This server is under a lot of load, mostly from

// the static content, which tends to be big. There may be multiple virtual

// hosts on this machine. We call this the "base" server.

// - You have at least one other webserver that you can use to offload some

// of the bandwidth. We call this the "offload" server.

// - You set up an Apache module (mod_offload) on the first server.

// mod_offload inserts itself into the request chain, and decides if a

// given file is safe static content (real file, not a script/cgi, no

// password, etc). In those cases, it sends a 302 redirect, pointing the

// client to the offload server.

// - The offload server gets a request from the redirected client. It then

// sends an HTTP HEAD request for the file in question to the base server

// while the client waits. It decides if it has the right file based on

// the HEAD. If it does, it serves the cached file.

// - If the file is out of date, or doesn't exist on the offload server, it

// sends a regular HTTP request for it to the base server and

// begins caching it. While caching it, it also feeds it to the client

// that has been waiting.

// - If another request comes in while the file is being cached, it will

// stream what is already there from disk, and then continue to feed as

// the rest shows up.

// !!! FIXME: issues to work out.

// - Need to have a way to clean out old files. If x.zip is on the base,

// gets cached, and then is deleted, it'll stay on the offload server

// forever. Getting a 404 from the HEAD request will clean it out, but

// the offload server needs to know to do that.

//

// Installation:

// You need a Unix-like system, like Linux, BSD, or Mac OS X. This won't

// work on Windows (try the PHP version there, you might have some luck).

// If you're building this as a standalone server, set the options you want,

// compile it and start it running.

// If you want to run as a cgi-bin program:

// You need Apache (or whatever) to push every web request to this program,

// presumably in a virtual host, if not the entire server.

//

// Assuming this program was at /www/cgi-bin/index.cgi, you would want to add

// this to Apache's config:

//

// AliasMatch ^.*$ "/www/cgi-bin/index.cgi"

//

// You might need a "AddHandler cgi-script .cgi" or some other magic.

//

// If you don't have control over the virtual host's config file, you can't

// use AliasMatch, but if you can put an .htaccess file in the root of the

// virtual host, you can get away with this:

//

//

// This will make all missing files (everything) run the script, which will

// then cache and distribute the correct content, including overriding the

// 404 status code with the correct one. Be careful about files that DO exist

// in that vhost directory, though. They won't offload.

//

// In this case, Apache will report the correct status message to the client,

// but log all offloaded files as 404 Not Found. This can't be helped. Run

// the server as standalone on a different port and have Apache proxy to it,

// or don't use Apache at all.

//

// You can offload multiple base servers with one box: set up one virtual host

// on the offload server for each base server. This lets each base server

// have its own cache and configuration.

//

// Restart the server so the AliasMatch configuration tweak is picked up.

//

// This file is written by Ryan C. Gordon (icculus@icculus.org).

/*

* Building:

*

* Edit offload_server_config.h to fit your needs, or override #defines

* on the command line. I use a shell script that looks like this:

*

* #!/bin/sh

*

* exec gcc \

* -DGDEBUG=0 \

* -DGDEBUGTOFILE=1 \

* -DGDEBUGDIR='"/home/icculus/offload2.icculus.org/logs"' \

* -DSHM_NAME='"mod-offload-offload2-icculus-org"' \

* -DGBASESERVER='"icculus.org"' \

* -DGLISTENPORT=9090 \

* -DGLISTENDAEMONIZE=1 \

* -DGLISTENTRUSTFWD='"127.0.0.1", "66.33.209.154"' \

* -g -O0 -Wall -o offload-daemon /home/icculus/mod_offload/nph-offload.c -lrt

*/

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <stdarg.h>

#include <stdint.h>

#include <time.h>

#include <errno.h>

#include <semaphore.h>

#include <limits.h>

#include <sys/stat.h>

#include <sys/socket.h>

#include <netinet/in.h>

#include <arpa/inet.h>

#define GSERVERSTRING "nph-offload.c/" GVERSION

#include "offload_server_config.h"

#define OFFLOAD_NUMSTR2(x) #x

#define OFFLOAD_NUMSTR(x) OFFLOAD_NUMSTR2(x)

#define GBASESERVERPORTSTR OFFLOAD_NUMSTR(GBASESERVERPORT)

#ifdef __GNUC__

#define ISPRINTF(x,y) __attribute__((format (printf, x, y)))

#else

#define ISPRINTF(x,y)

#endif

#ifdef max

#undef max

#endif

#ifndef AI_ADDRCONFIG

#define AI_ADDRCONFIG 0

#endif

#ifndef AI_NUMERICSERV

#define AI_NUMERICSERV 0

#endif

#ifndef AI_V4MAPPED

#define AI_V4MAPPED 0

#endif

typedef int8_t int8;

typedef uint8_t uint8;

typedef int16_t int16;

typedef uint16_t uint16;

typedef int32_t int32;

typedef uint32_t uint32;

extern char **environ;

static int GHttpStatus = 0;

static int64 GBytesSent = 0;

static const char *Guri = NULL;

static const char *GRemoteAddr = NULL;

static const char *GReferer = NULL;

static const char *GUserAgent = NULL;

static const char *GReqVersion = NULL;

static const char *GReqMethod = NULL;

static char *GFilePath = NULL;

static void *GSemaphore = NULL;

static int GSemaphoreOwned = 0;

static FILE *GDebugFilePointer = NULL;

#if !GNOCACHE

static char *GMetaDataPath = NULL;

#endif

static void failure_location(const char *, const char *, const char *);

static inline void failure(const char *httperr, const char *errmsg)

{

failure_location(httperr, errmsg, NULL);

} // failure

#if ( ((GDEBUG) && (GDEBUGTOFILE)) == 0 )

#else

static FILE *getDebugFilePointer(void)

{

if (GDebugFilePointer == NULL)

{

char buf[PATH_MAX];

GDebugFilePointer = fopen(buf, "a");

} // if

return GDebugFilePointer;

} // getDebugFilePointer

#endif

#if ((!GDEBUG) && defined(__GNUC__))

#else

static void debugEcho(const char *fmt, ...) ISPRINTF(1, 2);

static void debugEcho(const char *fmt, ...)

{

#if GDEBUG

#if !GDEBUGTOFILE

FILE *fp = stdout;

#else

FILE *fp = getDebugFilePointer();

#endif

if (fp != NULL)

{

if (GIsCacheProcess)

fputs("(cache process) ", fp);

va_list ap;

va_start(ap, fmt);

vfprintf(fp, fmt, ap);

va_end(ap);

fputs("\n", fp);

fflush(fp);

} // else

#endif

} // debugEcho

#endif

static void *createSemaphore(const int initialVal)

{

void *retval = NULL;

const int value = initialVal ? 0 : 1;

int created = 1;

if ((retval == (void *) SEM_FAILED) && (errno == EEXIST))

{

created = 0;

debugEcho("(semaphore already exists, just opening existing one.)");

} // if

if (retval == (void *) SEM_FAILED)

return NULL;

return retval;

} // createSemaphore

static void getSemaphore(void)

{

debugEcho("grabbing semaphore...(owned %d time(s).)", GSemaphoreOwned);

if (GSemaphoreOwned++ > 0)

return;

if (GSemaphore != NULL)

{

if (sem_wait(GSemaphore) == -1)

failure("503 Service Unavailable", "Couldn't lock semaphore.");

} // if

else

{

debugEcho("(have to create semaphore...)");

GSemaphore = createSemaphore(0);

if (GSemaphore == NULL)

failure("503 Service Unavailable", "Couldn't allocate semaphore.");

} // else

} // getSemaphore

static void putSemaphore(void)

{

if (GSemaphoreOwned == 0)

return;

if (--GSemaphoreOwned == 0)

{

if (GSemaphore != NULL)

{

if (sem_post(GSemaphore) == -1)

failure("503 Service Unavailable", "Couldn't unlock semaphore.");

} // if

} // if

debugEcho("released semaphore...(now owned %d time(s).)", GSemaphoreOwned);

} // putSemaphore

static inline int process_dead(const pid_t pid)

{

return ( (pid <= 0) || ((kill(pid, 0) == -1) && (errno == ESRCH)) );

} // process_dead

#if GMAXDUPEDOWNLOADS <= 0

#define setDownloadRecord()

#define removeDownloadRecord()

#else

// we can track this many concurrent connections in a block of shared memory.

// If DownloadRecord is 24 bytes, then 512 records is 12 kilobytes (usually,

// three pages of memory). If you actually have more than this many concurrent

// connections then we'll just stop checking for dupes in things that didn't

// fit in the table...frankly, if your server is still standing with 512

// active HTTP downloads, you probably don't care about download accelerators

// anyhow. :)

#define MAX_DOWNLOAD_RECORDS 512

typedef struct

{

pid_t pid;

uint8 sha1[20];

} DownloadRecord;

static DownloadRecord *GAllDownloads = NULL;

static DownloadRecord *GMyDownload = NULL;

#define DUPE_FORBID_TEXT \

"403 Forbidden - " GSERVERSTRING "\n\n" \

"Your network address has too many connections for this specific file.\n" \

"Please disable any 'download accelerators' and try again.\n\n" \

typedef struct

{

uint32 state[5];

uint32 count[2];

uint8 buffer[64];

} Sha1;

static void Sha1_init(Sha1 *context);

static void Sha1_append(Sha1 *context, const uint8 *data, uint32 len);

static void Sha1_finish(Sha1 *context, uint8 digest[20]);

static void setDownloadRecord()

{

const pid_t mypid = getpid();

int dupes = 0;

int i = 0;

int fd = -1;

Sha1 sha1data;

uint8 sha1[20];

DownloadRecord *downloads = NULL;

const size_t maplen = sizeof (DownloadRecord) * MAX_DOWNLOAD_RECORDS;

return; // oh well.

GAllDownloads = GMyDownload = NULL;

getSemaphore();

if (fd < 0)

{

if (fd < 0)

{

putSemaphore();

debugEcho("shm_open() failed: %s", strerror(errno));

return; // oh well.

} // if

} // if

ftruncate(fd, maplen);

void *ptr = mmap(0, maplen, (PROT_READ|PROT_WRITE), MAP_SHARED, fd, 0);

close(fd); // mapping remains.

if (ptr == MAP_FAILED)

{

putSemaphore();

debugEcho("mmap() failed: %s", strerror(errno));

return;

} // if

GAllDownloads = downloads = (DownloadRecord *) ptr;

Sha1_init(&sha1data);

Sha1_append(&sha1data, (const uint8 *) Guri, strlen(Guri) + 1);

Sha1_finish(&sha1data, sha1);

for (i = 0; i < MAX_DOWNLOAD_RECORDS; i++, downloads++)

{

const pid_t pid = downloads->pid;

if (pid <= 0) // unused slot.

GMyDownload = downloads; // take slot.

else if (memcmp(downloads->sha1, sha1, sizeof (sha1)) == 0)

{

// make sure this isn't a killed process.

if ( (pid == mypid) || (process_dead(pid)) )

{

debugEcho("pid #%d died at some point.", (int) pid);

downloads->pid = 0;

GMyDownload = downloads; // take slot.

} // if

else

{

debugEcho("pid #%d still alive, dupe slot.", (int) pid);

dupes++;

} // else

} // else if

} // for

debugEcho("Saw %d dupes.", dupes);

if (dupes >= GMAXDUPEDOWNLOADS)

failure("403 Forbidden", DUPE_FORBID_TEXT); // will put semaphore.

else if (GMyDownload == NULL) // Have fun, downloader accelerator!

debugEcho("no free download slots! Can't add ourselves.");

else

{

debugEcho("Got download slot #%d", (int) (GMyDownload-GAllDownloads));

GMyDownload->pid = mypid;

memcpy(GMyDownload->sha1, sha1, sizeof (sha1));

} // else

putSemaphore();

} // setDownloadRecord

static void removeDownloadRecord()

{

if (!GAllDownloads)

return;

getSemaphore();

if (GMyDownload != NULL)

GMyDownload->pid = 0;

putSemaphore();

munmap(GAllDownloads, sizeof (DownloadRecord) * MAX_DOWNLOAD_RECORDS);

GAllDownloads = GMyDownload = NULL;

} // removeDownloadRecord

#endif

// strftime()'s "%a" gives you locale-dependent strings...

static const char *GWeekday[] = {

"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat",

};

// strftime()'s "%b" gives you locale-dependent strings...

static const char *GMonth[] = {

"Jan", "Feb", "Mar", "Apr", "May", "Jun",

"Jul", "Aug", "Sep", "Oct", "Nov", "Dec",

};

{

time_t now = time(NULL);

const struct tm *tm = gmtime(&now);

} // make_date_header

#if GDEBUG

static void printf_date_header(FILE *out)

{

char buf[128];

if (out == NULL)

return;

make_date_header(buf, sizeof (buf));

fprintf(out, "%s", buf);

static void terminate(void);

static void write_string(const int fd, const char *str)

{

size_t avail = strlen(str);

while (avail > 0)

{

ssize_t rc = write(fd, str, avail);

if ((rc == -1) && (errno == EINTR))

continue;

if (rc <= 0)

{

debugEcho("write_string(): write() failed! (%s)\n", strerror(errno));

terminate();

} // if

avail -= rc;

str += rc;

} // while

} // write_string

static void write_header(const char *key, const char *val)

{

write_string(GSocket, key);

write_string(GSocket, val);

write_string(GSocket, "\r\n");

} // write_header

static void write_date_header(void)

{

char buf[128];

make_date_header(buf, sizeof (buf));

write_string(GSocket, buf);

} // write_date_header

static int64 atoi64(const char *str)

{

int64 retval = 0;

int64 mult = 1;

int i = 0;

while (*str == ' ')

str++;

if (*str == '-')

{

mult = -1;

str++;

} // if

while (1)

{

const char ch = str[i];

if ((ch < '0') || (ch > '9'))

break;

i++;

} // for

while (--i >= 0)

{

const char ch = str[i];

retval += ((int64) (ch - '0')) * mult;

mult *= 10;

} // while

return retval;

} // atoi64

static void *xmalloc(const size_t len)

{

void *ptr = malloc(len);

if (ptr == NULL)

failure("500 Internal Server Error", "Out of memory.");

return ptr;

} // xmalloc

static char *xstrdup(const char *str)

{

char *ptr = (char *) xmalloc(strlen(str) + 1);

strcpy(ptr, str);

return ptr;

} // xstrdup

static char *makeStr(const char *fmt, ...) ISPRINTF(1, 2);

static char *makeStr(const char *fmt, ...)

{

va_list ap;

char ch;

va_start(ap, fmt);

const int len = vsnprintf(&ch, 1, fmt, ap);

va_end(ap);

char *retval = (char *) xmalloc(len + 1);

va_start(ap, fmt);

vsnprintf(retval, len + 1, fmt, ap);

va_end(ap);

return retval;

} // makeStr

// a hashtable would be more sane, but really, we're talking about a handful

// of items, so this is probably the lower memory option, and it's fast

// enough for the simplicity.

typedef struct list

{

const char *key;

const char *value;

struct list *next;

} list;

static const char *listSet(list **l, const char *key, const char *value)

{

// maybe substring of current item, so copy it before we free() anything.

const char *newvalue = xstrdup(value);

list *item = *l;

while (item)

{

if (strcmp(item->key, key) == 0)

break;

item = item->next;

} // while

if (item != NULL)

free((void *) item->value);

else

{

item = (list *) xmalloc(sizeof (list));

item->key = xstrdup(key);

item->next = *l;

*l = item;

} // else

item->value = newvalue;

return newvalue;

} // listSet

static const char *listFind(const list *l, const char *key)

{

const list *item = l;

while (item)

{

if (strcmp(item->key, key) == 0)

break;

item = item->next;

} // while

return item ? item->value : NULL;

} // listFind

static void listFree(list **l)

{

list *item = *l;

while (item)

{

list *next = item->next;

free((void *) item->key);

free((void *) item->value);

free(item);

item = next;

} // while

*l = NULL;

} // listFree

#if GSETPROCTITLE

#if defined(__linux__)

// okay.

#else

#warning GSETPROCTITLE not currently supported on this platform.

#undef GSETPROCTITLE

#define GSETPROCTITLE 0

#endif

#endif

#if !GSETPROCTITLE

#define copyEnv(x) getenv(x)

#define freeEnvCopies()

#else

static char **GArgv = NULL;

static char *GLastArgv = NULL;

static int GMaxArgvLen = 0;

static int GNoMoreGetEnv = 0;

static list *GEnvCopies = NULL;

static const char *copyEnv(const char *key)

{

const char *retval = listFind(GEnvCopies, key);

if ((retval == NULL) && (!GNoMoreGetEnv))

{

const char *envr = getenv(key);

if (envr != NULL)

retval = listSet(&GEnvCopies, key, envr);

} // if

return retval;

} // copyEnv

static inline void freeEnvCopies(void)

{

listFree(&GEnvCopies);

} // freeEnvCopies

#endif

#if !GLOGACTIVITY

#define outputLogEntry()

#else

static void outputLogEntry(void)

{

FILE *out = fopen(GLOGFILE, "a");

if (out == NULL)

debugEcho("Failed to open log file for append!");

else

{

// Apache Combined Log Format:

// http://httpd.apache.org/docs/1.3/logs.html#combined

// !!! FIXME: auth and identd?

time_t now = time(NULL);

const struct tm *tm = localtime(&now);

fprintf(out,

"%s - - [%02d/%s/%d:%02d:%02d:%02d %c%02d%02d]"

" \"%s %s%s%s\" %d %lld \"%s\" \"%s\"\n",

GRemoteAddr, tm->tm_mday, GMonth[tm->tm_mon],

tm->tm_year+1900, tm->tm_hour, tm->tm_min,

tm->tm_sec, (tm->tm_gmtoff < 0) ? '-' : '+',

(int) (abs((int) tm->tm_gmtoff) / (60*60)),

(int) (abs((int) tm->tm_gmtoff) % (60*60)),

GReqMethod ? GReqMethod : "",

Guri ? Guri : "",

(GReqVersion && *GReqVersion) ? " " : "",

GReqVersion ? GReqVersion : "",

GHttpStatus, (long long) GBytesSent,

GReferer ? GReferer : "-",

GUserAgent ? GUserAgent : "-");

fclose(out);

} // else

} // outputLogEntry

#endif

static void terminate(void)

{

if (!GIsCacheProcess)

{

debugEcho("offload program is terminating...");

while (GSemaphoreOwned > 0)

putSemaphore();

} // if

if (GDebugFilePointer != NULL)

fclose(GDebugFilePointer);

#if GLISTENPORT

char ch = 0;

shutdown(GSocket, SHUT_RDWR);

while (recv(GSocket, &ch, sizeof (ch), 0) > 0) {}

close(GSocket);

#endif

if (stdin) fclose(stdin);

if (stdout) fclose(stdout);

if (stderr) fclose(stderr);

stdin = stdout = stderr = NULL;

freeEnvCopies();

exit(0);

} // terminate

static void failure_location(const char *httperr, const char *errmsg,

const char *location)

{

if (strncasecmp(httperr, "HTTP", 4) == 0)

{

const char *ptr = strchr(httperr, ' ');

if (ptr != NULL)

httperr = ptr+1;

} // if

if (!GHttpStatus)

GHttpStatus = atoi(httperr);

debugEcho("failure() called:");

debugEcho(" %s", httperr);

debugEcho(" %s", errmsg);

write_header("HTTP/1.1 ", httperr);

write_header("Status: ", httperr);

write_header("Server: ", httperr);

write_date_header();

write_header("Location: ", location);

write_header("Connection: ", "close");

write_header("Content-type: ", "text/plain; charset=utf-8");

write_header("", "");

write_header("", errmsg);

} // if

terminate();

} // failure_location

static int invalidContentRange(const int64 startRange, const int64 endRange,

const int64 max)

{

if ((startRange < 0) || (startRange >= max))

return 1;

else if ((endRange < 0) || (endRange >= max))

return 1;

else if (startRange > endRange)

return 1;

return 0;

} // invalidContentRange

#if !GDEBUG

write_header("HTTP/1.1 ", "200 OK");

write_header("Status: ", "200 OK");

write_header("Content-type: ", "text/plain; charset=utf-8");

write_date_header();

write_header("Server: ", GSERVERSTRING);

write_header("Connection: ", "close");

write_header("", "");

#endif

debugEcho("%s", "");

debugEcho("%s", "");

debugEcho("%s", "");

debugEcho("Offload Debug Run!");

debugEcho("%s", "");

debugEcho("Base server: %s", GBASESERVER);

debugEcho("User wants to get: %s", Guri);

debugEcho("Client User-Agent: %s", GUserAgent);

debugEcho("Referrer string: %s", GReferer);

debugEcho("Request method: %s", GReqMethod);

debugEcho("Timeout for HTTP HEAD request is %d", GTIMEOUT);

debugEcho("Data cache goes in %s", GOFFLOADDIR);

debugEcho("My PID: %d\n", (int) getpid());

debugEcho("%s", "");

debugEcho("%s", "");

int i;

debugEcho("Command line: %d items...", argc);

for (i = 0; i < argc; i++)

debugEcho(" argv[%d] = '%s'", i, argv[i]);

debugEcho("%s", "");

debugEcho("%s", "");

debugEcho("Environment...");

for (i = 0; envp[i]; i++)

debugEcho(" %s", envp[i]);

debugEcho("%s", "");

debugEcho("%s", "");

} // debugInit

#endif

static void readHeaders(const int fd, list **headers)

{

const time_t endtime = time(NULL) + GTIMEOUT;

int br = 0;

char buf[1024];

int seenresponse = 0;

while (1)

{

const time_t now = time(NULL);

int rc = -1;

fd_set rfds;

if (endtime >= now)

{

struct timeval tv;

FD_ZERO(&rfds);

FD_SET(fd, &rfds);

tv.tv_sec = endtime - now;

tv.tv_usec = 0;

rc = select(fd+1, &rfds, NULL, NULL, &tv);

} // if

if ((rc <= 0) || (FD_ISSET(fd, &rfds) == 0))

failure("503 Service Unavailable", "Timeout while talking to offload host.");

// we can only read one byte at a time, since we don't want to

// read past end of headers, into actual content, here.

if (read(fd, buf + br, 1) != 1)

failure("503 Service Unavailable", "Read error while talking to offload host.");

if (buf[br] == '\r')

; // ignore these.

else if (buf[br] == '\n')

{

if (br == 0) // empty line, end of headers.

return;

buf[br] = '\0';

if (seenresponse)

{

ptr = strchr(buf, ':');

if (ptr != NULL)

{

*(ptr++) = '\0';

while (*ptr == ' ')

ptr++;

listSet(headers, buf, ptr);

} // if

} // if

else

{

listSet(headers, "response", buf);

{

ptr = strchr(buf + 5, ' ');

if (ptr != NULL)

{

char *start = ptr + 1;

ptr = strchr(start, ' ');

if (ptr != NULL)

*ptr = '\0';

listSet(headers, "response_code", start);

ptr = start;

} // if

} // if

seenresponse = 1;

} // else

if (ptr == NULL)

failure("503 Service Unavailable", "Bogus response from offload host server.");

br = 0;

} // if

else

{

br++;

if (br >= sizeof (buf))

failure("503 Service Unavailable", "Buffer overflow.");

} // else

} // while

} // readHeaders

static void doWrite(const int fd, const char *str)

{

const int len = strlen(str);

int bw = 0;

const time_t endtime = time(NULL) + GTIMEOUT;

while (bw < len)

{

const time_t now = time(NULL);

int rc = -1;

fd_set wfds;

if (endtime >= now)

{

struct timeval tv;

FD_ZERO(&wfds);

FD_SET(fd, &wfds);

tv.tv_sec = endtime - now;

tv.tv_usec = 0;

rc = select(fd+1, NULL, &wfds, NULL, &tv);

} // if

if ((rc <= 0) || (FD_ISSET(fd, &wfds) == 0))

failure("503 Service Unavailable", "Timeout while talking to offload base server.");

rc = write(fd, str + bw, len - bw);

if (rc <= 0) // error? closed connection?

failure("503 Service Unavailable", "Write error while talking to offload base server.");

bw += rc;

} // while

} // doWrite

static int doHttp(const char *method, list **headers)

{

struct addrinfo hints;

memset(&hints, '\0', sizeof (hints));

{

debugEcho("getaddrinfo failure: %s", gai_strerror(rc));

int fd = -1;

struct addrinfo *addr;

for (addr = dns; addr != NULL; addr = addr->ai_next)

{