int process_header_end(request * req)
{
    if (!req->logline) {
        log_error_doc(req);
        fputs("No logline in process_header_end\n", stderr);
        send_r_error(req);
        return 0;
    }

    /* Percent-decode request */
    if (unescape_uri(req->request_uri, &(req->query_string)) == 0) {
        log_error_doc(req);
        fputs("URI contains bogus characters\n", stderr);
        send_r_bad_request(req);
        return 0;
    }

    /* clean pathname */
    clean_pathname(req->request_uri);

    if (req->request_uri[0] != '/') {
        log_error("URI does not begin with '/'\n");
        send_r_bad_request(req);
        return 0;
    }

    if (vhost_root) {
        ...
    }

    if (translate_uri(req) == 0) { /* unescape, parse uri */
        /* errors already logged */
        SQUASH_KA(req);
        return 0;               /* failure, close down */
    }

    if (req->method == M_POST) {
        ...
    }

    if (req->cgi_type) {
        return init_cgi(req);
    }

    req->status = WRITE;

    return init_get(req);       /* get and head */
}

static int init_script_alias(request * req, alias * current1, unsigned int uri_len)
{
    static char pathname[MAX_HEADER_LENGTH + 1];
    struct stat statbuf;

    int i = 0;
    char c;
    int err;

    /* copies the "real" path + the non-alias portion of the
       uri to pathname.
     */

    if (vhost_root) {
        ...
    } else {
        if (current1->real_len + uri_len -
            current1->fake_len + 1 > sizeof(pathname)) {
            log_error_doc(req);
            fputs("uri too long!\n", stderr);
            send_r_bad_request(req);
            return 0;
        }
        memcpy(pathname, current1->realname, current1->real_len);
        memcpy(pathname + current1->real_len,
               &req->request_uri[current1->fake_len],
               uri_len - current1->fake_len + 1); /* the +1 copies the NUL */
    }
#ifdef FASCIST_LOGGING
    log_error_time();
    fprintf(stderr,
            "%s:%d - pathname in init_script_alias is: \"%s\" (\"%s\")\n",
            __FILE__, __LINE__, pathname, pathname + current1->real_len);
#endif
    if (strncmp("nph-", pathname + current1->real_len, 4) == 0
        || (req->http_version == HTTP09))
        req->cgi_type = NPH;
    else
        req->cgi_type = CGI;

...


    req->pathname = strdup(pathname);
    if (!req->pathname) {
        boa_perror(req, "unable to strdup pathname for req->pathname");
        return 0;
    }

    return 1;
}

int IGD_CgiCall(undefined4 param_1,undefined4 param_2)

{
  size_t __n;
  undefined auStack20 [4];
  int local_10;
  code *local_c;
  
  local_c = (code *)0x0;
  local_c = (code *)IGD_GetCgiHandler(param_1);
  if (local_c == (code *)0x0) {
    local_10 = -0xefff;
  }
  else {
    __n = strlen("HTTP/1.1 200 OK\r\n");
    write(0x1f,"HTTP/1.1 200 OK\r\n",__n);
    local_10 = (*(code *)0x6598)(auStack20);
    if (local_10 == 0) {
      (*(code *)0x67d4)(param_1);
      local_10 = (*local_c)(0,param_2,auStack20);
    }
  }
  return local_10;
}

undefined4 IGD_GetCgiHandler(char *param_1)

{
  int iVar1;
  int local_c;
  
  local_c = 0;
  cgi_perm_flag = 0;
  while( true ) {
    if ((&IGD_CGI_FUN_MAP)[local_c * 3] == 0) {
      return 0;
    }
    iVar1 = strcmp((char *)(&IGD_CGI_FUN_MAP)[local_c * 3],param_1);
    if (iVar1 == 0) break;
    local_c = local_c + 1;
  }
  cgi_perm_flag = *(undefined4 *)(&DAT_0002e024 + local_c * 0xc);
  return *(undefined4 *)(&DAT_0002e020 + local_c * 0xc);
}

void uh_dispatch_add(struct dispatch_handler *d)
{
	list_add_tail(&d->list, &dispatch_handlers);
}

static struct dispatch_handler *
dispatch_find(const char *url, struct path_info *pi)
{
	struct dispatch_handler *d;

	list_for_each_entry(d, &dispatch_handlers, list) {
		if (pi) {
			if (d->check_url)
				continue;

			if (d->check_path(pi, url))
				return d;
		} else {
			if (d->check_path)
				continue;

			if (d->check_url(url))
				return d;
		}
	}

	return NULL;
}

static void cgi_handle_request(struct client *cl, char *url, struct path_info *pi)
{
	unsigned int mode = S_IFREG | S_IXOTH;
	char *escaped_url;

	if (!pi->ip && !((pi->stat.st_mode & mode) == mode)) {
		escaped_url = uh_htmlescape(url);

		uh_client_error(cl, 403, "Forbidden",
				"You don't have permission to access %s on this server.",
				escaped_url ? escaped_url : "the url");

		if (escaped_url)
			free(escaped_url);

		return;
	}

	if (!uh_create_process(cl, pi, url, cgi_main)) {
		uh_client_error(cl, 500, "Internal Server Error",
				"Failed to create CGI process: %s", strerror(errno));
		return;
	}

	return;
}

struct dispatch_handler cgi_dispatch = {
	.script = true,
	.check_path = check_cgi_path,
	.handle_request = cgi_handle_request,
};

static int initWebs()
{
	struct hostent	*hp;
	struct in_addr	intaddr;
	char			host[128], dir[128], webdir[128];
	char			*cp;
	char_t			wbuf[128];

    /* ... */

/*
 *	Configure the web server options before opening the web server
 */
	websSetDefaultDir(webdir);
	cp = inet_ntoa(intaddr);
	ascToUni(wbuf, cp, min(strlen(cp) + 1, sizeof(wbuf)));
	websSetIpaddr(wbuf);
	ascToUni(wbuf, host, min(strlen(host) + 1, sizeof(wbuf)));
	websSetHost(wbuf);

    /* ... */

/*
 * 	First create the URL handlers. Note: handlers are called in sorted order
 *	with the longest path handler examined first. Here we define the security 
 *	handler, forms handler and the default web page handler.
 */
	websUrlHandlerDefine(T(""), NULL, 0, websSecurityHandler, 
		WEBS_HANDLER_FIRST);
	websUrlHandlerDefine(T("/goform"), NULL, 0, websFormHandler, 0);
	websUrlHandlerDefine(T("/cgi-bin"), NULL, 0, websCgiHandler, 0);
	websUrlHandlerDefine(T(""), NULL, 0, websDefaultHandler, 
		WEBS_HANDLER_LAST); 

/*
 *	Now define two test procedures. Replace these with your application
 *	relevant ASP script procedures and form functions.
 */
	websAspDefine(T("aspTest"), aspTest);
	websFormDefine(T("formTest"), formTest);

/*
 *	Create the Form handlers for the User Management pages
 */
#ifdef USER_MANAGEMENT_SUPPORT
	formDefineUserMgmt();
#endif

/*
 *	Create a handler for the default home page
 */
	websUrlHandlerDefine(T("/"), NULL, 0, websHomePageHandler, 0); 
	return 0;
}

/************************************* Code ***********************************/
/*
 *	Process a form request. Returns 1 always to indicate it handled the URL
 */

int websFormHandler(webs_t wp, char_t *urlPrefix, char_t *webDir, int arg, 
	char_t *url, char_t *path, char_t *query)
{
	sym_t		*sp;
	char_t		formBuf[FNAMESIZE];
	char_t		*cp, *formName;
	int			(*fn)(void *sock, char_t *path, char_t *args);

	a_assert(websValid(wp));
	a_assert(url && *url);
	a_assert(path && *path == '/');

	websStats.formHits++;

/*
 *	Extract the form name
 */
	gstrncpy(formBuf, path, TSZ(formBuf));
	if ((formName = gstrchr(&formBuf[1], '/')) == NULL) {
		websError(wp, 200, T("Missing form name"));
		return 1;
	}
	formName++;
	if ((cp = gstrchr(formName, '/')) != NULL) {
		*cp = '\0';
	}

/*
 *	Lookup the C form function first and then try tcl (no javascript support 
 *	yet).
 */
	sp = symLookup(formSymtab, formName);
	if (sp == NULL) {
		websError(wp, 200, T("Form %s is not defined"), formName);
	} else {
		fn = (int (*)(void *, char_t *, char_t *)) sp->content.value.integer;
		a_assert(fn);
		if (fn) {
/*
 *			For good practice, forms must call websDone()
 */
			(*fn)((void*) wp, formName, query);

/*
 *			Remove the test to force websDone, since this prevents
 *			the server "push" from a form>
 */
#if 0 /* push */
			if (websValid(wp)) {
				websError(wp, 200, T("Form didn't call websDone"));
			}
#endif /* push */
		}
	}
	return 1;
}

/******************************************************************************/
/*
 *	Define a form function in the "form" map space.
 */

int websFormDefine(char_t *name, void (*fn)(webs_t wp, char_t *path, 
	char_t *query))
{
	a_assert(name && *name);
	a_assert(fn);

	if (fn == NULL) {
		return -1;
	}

	symEnter(formSymtab, name, valueInteger((int) fn), (int) NULL);
	return 0;
}

          websSetDefaultDir(acStack336);
          __s1 = inet_ntoa(__in);
          sVar5 = strlen(__s1);
          uVar6 = sVar5 + 1;
          if (0x7f < uVar6) {
            uVar6 = 0x80;
          }
          ascToUni(auStack208,__s1,uVar6);
          websSetIpaddr(auStack208);
          websSetHost(auStack208);
          websSetDefaultPage("default.asp");
          websSetPassword(PTR_DAT_004c19a4);
          websOpenServer(DAT_004c1994,DAT_004c1998);
          websUrlHandlerDefine(&DAT_00473984,0,0,websSecurityHandler,1);
          websUrlHandlerDefine("/goform",0,0,websFormHandler,0);
          websUrlHandlerDefine("/cgi-bin",0,0,websCgiHandler,0);
          websUrlHandlerDefine("/sharefile",0,0,websShareFileHandler,0);
          websUrlHandlerDefine(&DAT_00473984,0,0,websDefaultHandler,2);
          formDefineUtilities();
          formDefineInternet();
          form_define_ip_control();
          formDefineQoS();
          formDefineWireless();
          formDefineInic();
          formDefineFirewall();
          formDefineManagement();
          formDefineLogout();
          formDefineWizard();
          formDefineVPN();
          formDefineHttpSharefile();
          websUrlHandlerDefine(&DAT_00471298,0,0,&LAB_0045df0c,0);

void formDefineQoS(void)

{
  websFormDefine("QoSPortSetup",&LAB_0046d75c);
  websFormDefine("qosClassifier",&LAB_0046c590);
  websFormDefine("QoSSetup",FUN_0046db08);
  websFormDefine("QoSDeleteULRules",&LAB_0046d5d4);
  websFormDefine("QoSDeleteDLRules",&LAB_0046d5f8);
  websFormDefine("QoSLoadDefaultProfile",&LAB_0046d61c);
                    /* WARNING: Could not recover jumptable at 0x0046e84c. Too many branches */
                    /* WARNING: Treating indirect jump as call */
  websAspDefine("QoSisPortBasedQoSSupport",&LAB_0046e73c);
  return;
}