/**

* MojoSetup; a portable, flexible installation application.

*

* Please see the file LICENSE.txt in the source's root directory.

*

* This file written by Ryan C. Gordon.

*/

#if !SUPPORT_GUI_WWW

#error Something is wrong in the build system.

#endif

#define BUILDING_EXTERNAL_PLUGIN 1

#include "gui.h"

MOJOGUI_PLUGIN(www)

#if !GUI_STATIC_LINK_WWW

CREATE_MOJOGUI_ENTRY_POINT(www)

#endif

#include <stdarg.h>

#define FREE_AND_NULL(x) { free(x); x = NULL; }

// tapdance between things WinSock and BSD Sockets define differently...

#if PLATFORM_WINDOWS

#include <winsock.h>

typedef int socklen_t;

#define sockErrno() WSAGetLastError()

#define wouldBlockError(err) (err == WSAEWOULDBLOCK)

#define intrError(err) (err == WSAEINTR)

static inline void setBlocking(SOCKET s, boolean blocking)

{

u_long val = (blocking) ? 0 : 1;

ioctlsocket(s, FIONBIO, &val);

} // setBlocking

static const char *sockStrErrVal(int val)

{

STUBBED("Windows strerror");

} // sockStrErrVal

static boolean initSocketSupport(void)

{

WSADATA data;

int rc = WSAStartup(MAKEWORD(1, 1), &data);

if (rc != 0)

{

return false;

} // if

logInfo("www: WinSock initialized (want %0.%1, got %2.%3).",

numstr((int) (LOBYTE(data.wVersion))),

numstr((int) (HIBYTE(data.wVersion))),

numstr((int) (LOBYTE(data.wHighVersion))),

numstr((int) (HIBYTE(data.wHighVersion))));

logInfo("www: WinSock description: %0", data.szDescription);

logInfo("www: WinSock system status: %0", data.szSystemStatus);

logInfo("www: WinSock max sockets: %0", numstr((int) data.iMaxSockets));

return true;

} // initSocketSupport

#define deinitSocketSupport() WSACleanup()

#else

#include <unistd.h>

#include <errno.h>

#include <sys/types.h>

#include <sys/socket.h>

#include <netinet/in.h>

#include <arpa/inet.h>

#include <signal.h>

#include <netdb.h>

#include <fcntl.h>

typedef int SOCKET;

#define SOCKET_ERROR (-1)

#define INVALID_SOCKET (-1)

#define closesocket(x) close(x)

#define sockErrno() (errno)

#define sockStrErrVal(val) strerror(val)

#define intrError(err) (err == EINTR)

#define initSocketSupport() (true)

#define deinitSocketSupport()

static inline boolean wouldBlockError(int err)

{

return ((err == EWOULDBLOCK) || (err == EAGAIN));

} // wouldBlockError

static void setBlocking(SOCKET s, boolean blocking)

{

int flags = fcntl(s, F_GETFL, 0);

if (blocking)

flags &= ~O_NONBLOCK;

else

flags |= O_NONBLOCK;

fcntl(s, F_SETFL, flags);

} // setBlocking

#endif

#define sockStrError() (sockStrErrVal(sockErrno()))

typedef struct _S_WebRequest

{

char *key;

char *value;

struct _S_WebRequest *next;

} WebRequest;

static char *output = NULL;

static char *lastProgressType = NULL;

static char *lastComponent = NULL;

static char *baseUrl = NULL;

static WebRequest *webRequest = NULL;

static uint32 percentTicks = 0;

static SOCKET listenSocket = INVALID_SOCKET;

static SOCKET clientSocket = INVALID_SOCKET;

{

return MOJOGUI_PRIORITY_TRY_LAST;

} // MojoGui_www_priority

static void freeWebRequest(void)

{

while (webRequest)

{

WebRequest *next = webRequest->next;

free(webRequest->key);

free(webRequest->value);

free(webRequest);

webRequest = next;

} // while

} // freeWebRequest

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

{

if ((key != NULL) && (*key != '\0'))

{

WebRequest *req = (WebRequest *) xmalloc(sizeof (WebRequest));

req->key = xstrdup(key);

req->value = xstrdup(val);

req->next = webRequest;

webRequest = req;

} // if

} // addWebRequest

static int hexVal(char ch)

{

if ((ch >= 'a') && (ch <= 'f'))

else if ((ch >= '0') && (ch <= '9'))

return (ch - '0');

return -1;

} // hexVal

static void unescapeUri(char *uri)

{

char *ptr = uri;

while ((ptr = strchr(ptr, '%')) != NULL)

{

int a, b;

if ((a = hexVal(ptr[1])) != -1)

{

if ((b = hexVal(ptr[2])) != -1)

{

*(ptr++) = (char) ((a * 16) + b);

memmove(ptr, ptr+2, strlen(ptr+1));

} // if

else

{

*(ptr++) = '?';

memmove(ptr, ptr+1, strlen(ptr));

} // else

} // if

else

{

*(ptr++) = '?';

} // else

} // while

} // unescapeUri

static int strAdd(char **ptr, size_t *len, size_t *alloc, const char *fmt, ...)

{

size_t avail = *alloc - *len;

va_list ap;

va_start(ap, fmt);

bw = vsnprintf(*ptr + *len, avail, fmt, ap);

va_end(ap);

if (bw >= avail)

{

const size_t add = (*alloc + (bw + 1)); // double plus the new len.

*alloc += add;

avail += add;

va_start(ap, fmt);

bw = vsnprintf(*ptr + *len, avail, fmt, ap);

va_end(ap);

} // if

*len += bw;

return bw;

} // strAdd

static char *htmlescape(const char *str)

{

size_t len = 0, alloc = 0;

char *retval = NULL;

char ch;

{

switch (ch)

{

case '&': strAdd(&retval, &len, &alloc, "&amp;"); break;

case '<': strAdd(&retval, &len, &alloc, "&lt;"); break;

case '>': strAdd(&retval, &len, &alloc, "&gt;"); break;

case '"': strAdd(&retval, &len, &alloc, "&quot;"); break;

case '\'': strAdd(&retval, &len, &alloc, "&#39;"); break;

default: strAdd(&retval, &len, &alloc, "%c", ch); break;

} // switch

} // while

return retval;

} // htmlescape

static const char *standardResponseHeaders =

"Content-Type: text/html; charset=utf-8\n"

"Accept-Ranges: none\n"

"Cache-Control: no-cache\n"

"Connection: close\n\n";

static void setHtmlString(char **str, int responseCode,

const char *responseString,

const char *title, const char *html)

{

size_t len = 0, alloc = 0;

FREE_AND_NULL(*str);

strAdd(str, &len, &alloc,

"HTTP/1.1 %d %s\n" // responseCode, responseString

"%s" // standardResponseHeaders

"<html>"

"<head>"

"<title>%s</title>" // title

"</head>"

"<body>%s</body>" // html

"</html>\n",

responseCode, responseString,

standardResponseHeaders,

title, html);

} // setHtmlString

static void setHtml(const char *title, const char *html)

{

setHtmlString(&output, 200, "OK", title, html);

} // setHtml

static void sendStringAndDrop(SOCKET *_s, const char *str)

{

SOCKET s = *_s;

int outlen = 0;

if (str == NULL)

str = "";

else

outlen = strlen(str);

setBlocking(s, true);

while (outlen > 0)

{

int rc = send(s, str, outlen, 0);

if (rc != SOCKET_ERROR)

{

str += rc;

outlen -= rc;

} // if

else

{

const int err = sockErrno();

if (!intrError(err))

{

break;

} // if

} // else

} // while

closesocket(s);

*_s = INVALID_SOCKET;

} // sendStringAndDrop

static void respond404(SOCKET *s)

{

char *str = NULL;

size_t len = 0, alloc = 0;

char *html = NULL;

strAdd(&html, &len, &alloc, "<center><h1>%s</h1></center>", text);

setHtmlString(&str, 404, text, text, html);

free(html);

free(text);

sendStringAndDrop(s, str);

free(str);

} // respond404

static boolean parseGet(char *get)

{

char *uri = NULL;

char *ver = NULL;

uri = strchr(get, ' ');

if (uri == NULL) return false;

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

ver = strchr(uri, ' ');

if (ver == NULL) return false;

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

if (strcmp(get, "GET") != 0) return false;

if (uri[0] != '/') return false;

uri++; // skip dirsep.

// !!! FIXME: we may want to feed stock files (<img> tags, etc)

// !!! FIXME: at some point in the future.

if ((uri[0] != '?') && (uri[0] != '\0')) return false;

if (strncmp(ver, "HTTP/", 5) != 0) return false;

if (*uri == '?')

uri++; // skip initial argsep.

do

{

char *next = strchr(uri, '&');

char *val = NULL;

if (next != NULL)

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

val = strchr(uri, '=');

if (val == NULL)

val = "";

else

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

unescapeUri(uri);

unescapeUri(val);

addWebRequest(uri, val);

uri = next;

} while (uri != NULL);

return true;

} // parseGet

static boolean parseRequest(char *reqstr)

{

do

{

char *next = strchr(reqstr, '\n');

char *val = NULL;

if (next != NULL)

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

val = strchr(reqstr, ':');

if (val == NULL)

val = "";

else

{

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

while (*val == ' ')

val++;

} // else

if (*reqstr != '\0')

{

size_t len = 0, alloc = 0;

char *buf = NULL;

strAdd(&buf, &len, &alloc, "HTTP-%s", reqstr);

addWebRequest(buf, val);

free(buf);

} // if

reqstr = next;

} while (reqstr != NULL);

return true;

} // parseRequest

static WebRequest *servePage(boolean blocking)

{

int newline = 0;

char ch = 0;

struct sockaddr_in addr;

socklen_t addrlen = 0;

int s = 0;

char *reqstr = NULL;

size_t len = 0, alloc = 0;

int err = 0;

freeWebRequest();

if (listenSocket == INVALID_SOCKET)

return NULL;

if (clientSocket != INVALID_SOCKET) // response to feed to client.

sendStringAndDrop(&clientSocket, output);

if (blocking)

setBlocking(listenSocket, true);

do

{

s = accept(listenSocket, (struct sockaddr *) &addr, &addrlen);

err = sockErrno();

} while ( (s == INVALID_SOCKET) && (intrError(err)) );

if (blocking)

setBlocking(listenSocket, false); // reset what we toggled up there.

if (s == INVALID_SOCKET)

{

if (wouldBlockError(err))

assert(!blocking);

else

{

closesocket(listenSocket); // make all future i/o fail too.

listenSocket = INVALID_SOCKET;

} // else

return NULL;

} // if

setBlocking(s, true);

// Doing this one char at a time isn't efficient, but it's easy.

while (1)

{

if (recv(s, &ch, 1, 0) == SOCKET_ERROR)

{

const int err = sockErrno();

if (!intrError(err)) // just try again on interrupt.

{

FREE_AND_NULL(reqstr);

closesocket(s);

s = INVALID_SOCKET;

break;

} // if

} // if

else if (ch == '\n') // newline

{

if (++newline == 2)

break; // end of request.

strAdd(&reqstr, &len, &alloc, "\n");

} // if

else if (ch != '\r')

{

newline = 0;

strAdd(&reqstr, &len, &alloc, "%c", ch);

} // else if

} // while

if (reqstr != NULL)

{

char *get = NULL;

char *ptr = strchr(reqstr, '\n');

if (ptr != NULL)

{

*ptr = '\0';

ptr++;

} // if

// reqstr is the GET (or whatever) request, ptr is the rest.

if (ptr == NULL)

{

*ptr = '\0';

len = 0;

} // if

else

{

len = strlen(ptr);

memmove(reqstr, ptr, len+1);

} // else

// okay, now (get) and (reqptr) are separate strings.

// These parse*() functions update (webRequest).

if ( (parseGet(get)) && (parseRequest(reqstr)) )

else

{

freeWebRequest();

respond404(&s);

} // else

free(reqstr);

free(get);

} // if

clientSocket = s;

return webRequest;

} // servePage

static SOCKET create_listen_socket(short portnum)

{

SOCKET s = INVALID_SOCKET;

int protocol = 0; // pray this is right.

struct protoent *prot;

setprotoent(0);

prot = getprotobyname("tcp");

if (prot != NULL)

protocol = prot->p_proto;

s = socket(PF_INET, SOCK_STREAM, protocol);

if (s == INVALID_SOCKET)

else

{

boolean success = false;

struct sockaddr_in addr;

addr.sin_family = AF_INET;

addr.sin_port = htons(portnum);

addr.sin_addr.s_addr = INADDR_ANY; // !!! FIXME: bind to localhost.

// So we can bind this socket over and over in debug runs...

#if ((!defined _NDEBUG) && (!defined NDEBUG))

{

int on = 1;

}

#endif

else

{

logInfo("www: socket created on port %0",

numstr(portnum));

success = true;

} // else

if (!success)

{

closesocket(s);

s = INVALID_SOCKET;

} // if

} // if

return s;

} // create_listen_socket

static boolean MojoGui_www_init(void)

{

size_t len = 0, alloc = 0;

short portnum = 7341; // !!! FIXME: try some random ports.

percentTicks = 0;

if (!initSocketSupport())

{

return false;

} // if

listenSocket = create_listen_socket(portnum);

if (listenSocket < 0)

{

return false;

} // if

setBlocking(listenSocket, false);

strAdd(&baseUrl, &len, &alloc, "http://localhost:%d/", (int) portnum);

return true;

} // MojoGui_www_init

static void MojoGui_www_deinit(void)

{

// Catch any waiting browser connections...and tell them to buzz off! :)

char *donetitle = htmlescape(_("Shutting down..."));

char *donetext = htmlescape(_("You can close this browser now."));

size_t len = 0, alloc = 0;

char *html = NULL;

setHtml(donetitle, html);

free(html);

free(donetitle);

free(donetext);

while (servePage(false) != NULL) { /* no-op. */ }

freeWebRequest();

FREE_AND_NULL(output);

FREE_AND_NULL(lastProgressType);

FREE_AND_NULL(lastComponent);

FREE_AND_NULL(baseUrl);

if (clientSocket != INVALID_SOCKET)

{

closesocket(clientSocket);

clientSocket = INVALID_SOCKET;

} // if

if (listenSocket != INVALID_SOCKET)

{

closesocket(listenSocket);

listenSocket = INVALID_SOCKET;

} // if

deinitSocketSupport();

} // MojoGui_www_deinit

int bcount)

{

char *htmltitle = htmlescape(title);

boolean sawPage = false;

int answer = -1;

int i = 0;

char *html = NULL;

size_t len = 0, alloc = 0;

strAdd(&html, &len, &alloc,

"<center>"

"<form name='form_%s' method='get'>" // pagename

"<input type='hidden' name='page' value='%s'>" // pagename

"<table>"

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

{

const char *button = buttons[i];

strAdd(&html, &len, &alloc,

"<input type='submit' name='%s' value='%s'>", button, loc);

} // for

strAdd(&html, &len, &alloc,

"</td>"

"</tr>"

"</table>"

"</form>"

"</center>");

setHtml(htmltitle, html);

free(htmltitle);

free(html);

while ((!sawPage) || (answer == -1))

{

WebRequest *req = servePage(true);

sawPage = false;

answer = -1;

while (req != NULL)

{

const char *k = req->key;

const char *v = req->value;

if ( (strcmp(k, "page") == 0) && (strcmp(v, pagename) == 0) )

sawPage = true;

else

{

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

{

if (strcmp(k, buttons[i]) == 0)

{

answer = i;

break;

} // if

} // for

} // else

req = req->next;

} // while

return answer;

} // doPromptPage

static void MojoGui_www_msgbox(const char *title, const char *text)

{

} // MojoGui_www_msgbox

static boolean MojoGui_www_promptyn(const char *title, const char *text,

boolean defval)

// !!! FIXME:

// We currently ignore defval

int i, rc;

char *htmltext = htmlescape(text);

const char *locButtons[] = { htmlescape(_("No")), htmlescape(_("Yes")) };

STATICARRAYLEN(buttons));

free(htmltext);

for (i = 0; i < STATICARRAYLEN(locButtons); i++)

free((void *) locButtons[i]);

return (rc == 1);

} // MojoGui_www_promptyn

static MojoGuiYNAN MojoGui_www_promptynan(const char *title, const char *text,

boolean defval)

// !!! FIXME:

// We currently ignore defval

int i, rc;

char *htmltext = htmlescape(text);

const char *buttons[] = { "no", "yes", "always", "never" };

const char *locButtons[] = {

htmlescape(_("No")),

htmlescape(_("Yes")),

htmlescape(_("Always")),

htmlescape(_("Never")),

STATICARRAYLEN(buttons));

free(htmltext);

for (i = 0; i < STATICARRAYLEN(locButtons); i++)

free((void *) locButtons[i]);

return (MojoGuiYNAN) rc;

} // MojoGui_www_promptynan

static boolean MojoGui_www_start(const char *title,

const MojoGuiSplash *splash)

{

return true;

} // MojoGui_www_start

static void MojoGui_www_stop(void)

{

// no-op.

} // MojoGui_www_stop

static int MojoGui_www_readme(const char *name, const uint8 *data,

size_t datalen, boolean can_back,

boolean can_fwd)

{

char *text = NULL;

size_t len = 0, alloc = 0;

int i, rc;

int cancelbutton = -1;

int backbutton = -1;

int fwdbutton = -1;

int bcount = 0;

const char *buttons[4] = { NULL, NULL, NULL, NULL };

const char *locButtons[4] = { NULL, NULL, NULL, NULL };

assert(STATICARRAYLEN(buttons) == STATICARRAYLEN(locButtons));

cancelbutton = bcount++;

if (can_back)

{

backbutton = bcount++;

buttons[backbutton] = "back";

} // if

if (can_fwd)

{

fwdbutton = bcount++;

buttons[fwdbutton] = "next";

} // if

strAdd(&text, &len, &alloc, "<pre>\n%s\n</pre>", htmldata);

free(htmldata);

free(text);

for (i = 0; i < STATICARRAYLEN(locButtons); i++)

free((void *) locButtons[i]);

if (rc == backbutton)

return -1;

else if (rc == cancelbutton)

return 0;

return 1;

} // MojoGui_www_readme

static int MojoGui_www_options(MojoGuiSetupOptions *opts,

boolean can_back, boolean can_fwd)

{

// !!! FIXME: write me.

STUBBED("www options");

return 1;

} // MojoGui_www_options

static char *MojoGui_www_destination(const char **recommends, int recnum,

int *command, boolean can_back,

boolean can_fwd)

{

char *html = NULL;

size_t len = 0, alloc = 0;

boolean checked = true;

int cancelbutton = -1;

int backbutton = -1;

int fwdbutton = -1;

int bcount = 0;

int rc = 0;

int i = 0;

const char *buttons[4] = { NULL, NULL, NULL, NULL };

const char *locButtons[4] = { NULL, NULL, NULL, NULL };

assert(STATICARRAYLEN(buttons) == STATICARRAYLEN(locButtons));

cancelbutton = bcount++;

buttons[cancelbutton] = "cancel";

if (can_back)

{

backbutton = bcount++;

buttons[backbutton] = "back";

} // if

if (can_fwd)

{

fwdbutton = bcount++;

buttons[fwdbutton] = "next";

} // if

strAdd(&html, &len, &alloc,

"<form name='form_destination' method='get'>"

"<table>");

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

{

strAdd(&html, &len, &alloc,

"<tr>"

"<td>"

"<input type='radio' name='dest' %s value='%s'>%s"

"</td>"

"</tr>",

((checked) ? "checked='true'" : ""), recommends[i], recommends[i]);

checked = false;

} // for

strAdd(&html, &len, &alloc,

"<tr>"

"<td>"

"<input type='radio' name='dest' %s value='*'>"

"<input type='text' name='customdest' value=''>"

"</td>"

"</tr>"

"</table>"

"</form>", ((checked) ? "checked='true'" : ""));

rc = doPromptPage(title, html, true, "destination",

buttons, locButtons, bcount);

free(title);

free(html);

for (i = 0; i < STATICARRAYLEN(locButtons); i++)

free((void *) locButtons[i]);

if (rc == backbutton)

*command = -1;

else if (rc == cancelbutton)

*command = 0;

else

{

const char *dest = NULL;

const char *customdest = NULL;

WebRequest *req = webRequest;

while (req != NULL)

{

const char *k = req->key;

const char *v = req->value;

if (strcmp(k, "dest") == 0)

dest = v;

else if (strcmp(k, "customdest") == 0)

customdest = v;

req = req->next;

} // while

if (dest != NULL)

{

if (strcmp(dest, "*") == 0)

dest = customdest;

} // if

if (dest == NULL)

*command = 0; // !!! FIXME: maybe loop with doPromptPage again.

else

{

*command = 1;

} // else

} // else

return retval;

} // MojoGui_www_destination

static int MojoGui_www_productkey(const char *desc, const char *fmt,

char *buf, const int buflen,

boolean can_back, boolean can_fwd)

{

char *prompt = xstrdup(_("Please enter your product key"));

int retval = -1;

char *html = NULL;

size_t len = 0, alloc = 0;

int cancelbutton = -1;

int backbutton = -1;

int fwdbutton = -1;

int bcount = 0;

int rc = 0;

int i = 0;

const char *buttons[4] = { NULL, NULL, NULL, NULL };

const char *locButtons[4] = { NULL, NULL, NULL, NULL };

assert(STATICARRAYLEN(buttons) == STATICARRAYLEN(locButtons));

cancelbutton = bcount++;

buttons[cancelbutton] = "cancel";

locButtons[cancelbutton] = xstrdup(_("Cancel"));

if (can_back)