int main() {
const char * old_domain_name = get_domain_name();
const char * old_host_name = get_host_name();
step("parent: old domainname: %s", old_domain_name);
step("parent: old hostname: %s", old_host_name);
step("parent: fork");
if (fork()) {
step("parent: wait for child to exit");
int status = 0;
do wait(&status); while (!WIFEXITED(status));
assertStrEquals("parent: domain name", old_domain_name, get_domain_name());
assertStrEquals("parent: host name", old_host_name, get_host_name());
} else {
step("child: create container with separate uts namespace");
struct slc_create_container_parameters params;
initialize_default_fs_root(¶ms.fs_root);
slc_create_container(¶ms, 0);
const char * new_domain_name = "new_domain_name";
const char * new_host_name = "new_host_name";
step("child: set domain name to '%s'", new_domain_name);
setdomainname(new_domain_name, strlen(new_domain_name));
assertStrEquals("child: domain name", new_domain_name, get_domain_name());
step("child: set host name to '%s'", new_host_name);
sethostname(new_host_name, strlen(new_host_name));
assertStrEquals("child: host name", new_host_name, get_host_name());
}
return 0;
}
void make_connection(struct connection *c, int port, int *sock, void (*func)(struct connection *))
{
int as;
unsigned char *host;
struct conn_info *b;
if (!(host = get_host_name(c->url))) {
setcstate(c, S_INTERNAL);
abort_connection(c);
return;
}
if (c->newconn)
internal("already making a connection");
b = mem_alloc(sizeof(struct conn_info));
b->func = func;
b->sock = sock;
b->port = port;
c->newconn = b;
log_data("\nCONNECTION: ", 13);
log_data(host, strlen(host));
log_data("\n", 1);
if (c->no_cache >= NC_RELOAD) as = find_host_no_cache(host, &b->addr, &c->dnsquery, (void(*)(void *, int))dns_found, c);
else as = find_host(host, &b->addr, &c->dnsquery, (void(*)(void *, int))dns_found, c);
mem_free(host);
if (as) setcstate(c, S_DNS);
}
void add_cookies(unsigned char **s, int *l, unsigned char *url)
{
int nc = 0;
struct c_domain *cd;
struct cookie *c, *d;
unsigned char *server = get_host_name(url);
unsigned char *data = get_url_data(url);
if (data > url) data--;
foreach (cd, c_domains) if (is_in_domain(cd->domain, server)) goto ok;
mem_free(server);
return;
ok:
foreachback (c, all_cookies) if (is_in_domain(c->domain, server)) if (is_path_prefix(c->path, data)) {
if (cookie_expired(c)) {
d = c;
c = c->prev;
del_from_list(d);
free_cookie(d);
mem_free(d);
continue;
}
if (c->secure && casecmp(url, cast_uchar "https://", 8)) continue;
if (!nc) add_to_str(s, l, cast_uchar "Cookie: "), nc = 1;
else add_to_str(s, l, cast_uchar "; ");
add_to_str(s, l, c->name);
if (c->value) {
add_to_str(s, l, cast_uchar "=");
add_to_str(s, l, c->value);
}
}
if (nc) add_to_str(s, l, cast_uchar "\r\n");
mem_free(server);
}
std::string get_host_name(boost::exception_ptr const& e)
{
try {
boost::rethrow_exception(e);
}
catch (boost::exception const& be) {
return get_host_name(be);
}
}
int check_http_server_bugs(unsigned char *url, struct http_connection_info *info, unsigned char *head)
{
unsigned char *server;
int i, bugs;
if (!http_bugs.allow_blacklist || info->http10) return 0;
if (!(server = parse_http_header(head, "Server", NULL))) return 0;
bugs = 0;
for (i = 0; buggy_servers[i].name; i++) if (strstr(server, buggy_servers[i].name)) bugs |= buggy_servers[i].bugs;
mem_free(server);
if (bugs && (server = get_host_name(url))) {
add_blacklist_entry(server, bugs);
mem_free(server);
return bugs & ~BL_NO_RANGE;
}
return 0;
}
void mailto_func(struct session *ses, unsigned char *url)
{
unsigned char *user, *host, *m;
int f = 1;
if (!(user = get_user_name(url))) goto fail;
if (!(host = get_host_name(url))) goto fail1;
m = mem_alloc(strlen(user) + strlen(host) + 2);
f = 0;
strcpy(m, user);
strcat(m, "@");
strcat(m, host);
check_shell_security(&m);
prog_func(ses->term, &mailto_prog, m, TEXT(T_MAIL));
mem_free(m);
mem_free(host);
fail1:
mem_free(user);
fail:
if (f) msg_box(ses->term, NULL, TEXT(T_BAD_URL_SYNTAX), AL_CENTER, TEXT(T_BAD_MAILTO_URL), NULL, 1, TEXT(T_CANCEL), NULL, B_ENTER | B_ESC);
}
int proxy_server()
{
int rx_bytes = 0, post_data_size = 0;
int lsock = 0, csock = 0, client_data_size = 0;
int result_size = 0, err_code = 0, id = 0;
int addrlen = sizeof(struct sockaddr_in);
struct sockaddr_in clientaddr;
char *buffer = NULL, *post_data = NULL;
char *host = NULL, *url = NULL;
char *query = NULL, *fifo_file = NULL;
char *get_data = NULL;
char *client_data = NULL, *headers = NULL;
char *server_ip = NULL;
memset((void *) &clientaddr,0,addrlen);
server_ip = config_get_server_ip();
/* Create TCP socket */
if((lsock = create_socket(server_ip,PROXY_PORT,SOCK_STREAM)) == SOCK_FAIL) {
glog("Failed to create TCP socket for proxy server",LOG_ERROR_TYPE);
if(server_ip) free(server_ip);
return EXIT_FAILURE;
}
if(server_ip) free(server_ip);
/* Infinite receive loop */
while(1) {
/* Accept incoming connection */
if((csock = accept(lsock,(struct sockaddr *) &clientaddr,(socklen_t *) &addrlen)) < 0) {
glog("Failed to accept TCP connection to proxy server",LOG_ERROR_TYPE);
if(buffer) free(buffer);
return EXIT_FAILURE;
}
if(!fork()) {
/* Receive client request */
if((buffer = receive(lsock,SOCK_STREAM,&rx_bytes,csock,&clientaddr)) == NULL) {
glog("Failed to read data from client request sent to proxy server",LOG_ERROR_TYPE);
exit(EXIT_FAILURE);
}
if(is_using_proxy(buffer)) {
/* Get the target's IP address */
host = get_host_name(buffer);
/* Get the target URL path */
url = get_url(buffer);
/* Get POST data, if any */
post_data = get_post_data(buffer,rx_bytes,&post_data_size);
/* Get HTTP headers from request */
headers = get_headers(buffer);
/* If the CONSOLE_HOST is requested, then display the Web console interface */
if(memcmp(host,CONSOLE_HOST,CONSOLE_HOST_SIZE) == 0) {
show_web_ui(csock,url);
close_socket(csock);
} else {
/* Make sure the requested host is in our clients list */
query = sqlite3_mprintf("SELECT id FROM %s WHERE strftime('%%s',callback_time) >= strftime('%%s','now') AND ip = %Q LIMIT 1",CLIENTS_TABLE,host);
sql_exec(query,&result_size,&err_code);
sqlite3_free(query);
if(result_size > 0) {
/* Don't allow requests for filtered file extensions */
if(!is_url_filtered(url)) {
fifo_file = create_fifo(host);
if(!fifo_file) {
glog("Failed to create fifo file",LOG_ERROR_TYPE);
} else {
/* Insert query into queue table */
query = sqlite3_mprintf("INSERT INTO %s (fifo,host,url,headers,pdata,sent) VALUES (%Q,%Q,%Q,%Q,%Q,0)",QUEUE_TABLE,fifo_file,host,url,headers,post_data);
sql_exec(query,&result_size,&err_code);
sqlite3_free(query);
if(err_code != SQLITE_OK) {
sql_log_error();
} else {
/* When the client data has returned, the callback server will write the ID of the callback to the FIFO */
id = read_from_fifo(fifo_file);
/* Extract the data from the DB */
get_data = sqlite3_mprintf("SELECT rdata FROM %s WHERE id = '%d'",QUEUE_TABLE,id);
client_data = sql_exec(get_data,&client_data_size,&err_code);
sqlite3_free(get_data);
if(err_code != SQLITE_OK) {
sql_log_error();
} else {
/* Write data to socket */
if(write(csock,client_data,client_data_size) != client_data_size) {
glog("Proxy socket write failed",LOG_ERROR_TYPE);
}
}
if(client_data) free(client_data);
/* Make sure the fifo gets deleted */
destroy_fifo(fifo_file);
}
}
}
}
}
}
/* Exit the child process */
close_socket(csock);
if(fifo_file) free(fifo_file);
if(buffer) free(buffer);
if(host) free(host);
if(url) free(url);
if(post_data) free(post_data);
if(headers) free(headers);
exit(EXIT_SUCCESS);
}
}
/* Close up shop */
close_socket(csock);
close_socket(lsock);
return EXIT_FAILURE;
}
void http_got_header(struct connection *c, struct read_buffer *rb)
{
int cf;
int state = c->state != S_PROC ? S_GETH : S_PROC;
unsigned char *head;
unsigned char *cookie, *ch;
int a, h, version;
unsigned char *d;
struct cache_entry *e;
struct http_connection_info *info;
unsigned char *host = upcase(c->url[0]) != 'P' ? c->url : get_url_data(c->url);
set_timeout(c);
info = c->info;
if (rb->close == 2) {
unsigned char *h;
if (!c->tries && (h = get_host_name(host))) {
if (info->bl_flags & BL_NO_CHARSET) {
del_blacklist_entry(h, BL_NO_CHARSET);
} else {
add_blacklist_entry(h, BL_NO_CHARSET);
c->tries = -1;
}
mem_free(h);
}
setcstate(c, S_CANT_READ);
retry_connection(c);
return;
}
rb->close = 0;
again:
if ((a = get_header(rb)) == -1) {
setcstate(c, S_HTTP_ERROR);
abort_connection(c);
return;
}
if (!a) {
read_from_socket(c, c->sock1, rb, http_got_header);
setcstate(c, state);
return;
}
if (a != -2) {
head = mem_alloc(a + 1);
memcpy(head, rb->data, a);
head[a] = 0;
kill_buffer_data(rb, a);
} else {
head = stracpy("HTTP/0.9 200 OK\r\nContent-Type: text/html\r\n\r\n");
}
if (get_http_code(head, &h, &version) || h == 101) {
mem_free(head);
setcstate(c, S_HTTP_ERROR);
abort_connection(c);
return;
}
if (check_http_server_bugs(host, c->info, head) && is_connection_restartable(c)) {
mem_free(head);
setcstate(c, S_RESTART);
retry_connection(c);
return;
}
ch = head;
while ((cookie = parse_http_header(ch, "Set-Cookie", &ch))) {
unsigned char *host = upcase(c->url[0]) != 'P' ? c->url : get_url_data(c->url);
set_cookie(NULL, host, cookie);
mem_free(cookie);
}
if (h == 100) {
mem_free(head);
state = S_PROC;
goto again;
}
if (h < 200) {
mem_free(head);
setcstate(c, S_HTTP_ERROR);
abort_connection(c);
return;
}
if (h == 204) {
mem_free(head);
setcstate(c, S_HTTP_204);
http_end_request(c, 0);
return;
}
if (h == 304) {
mem_free(head);
setcstate(c, S_OK);
http_end_request(c, 1);
return;
}
if ((h == 500 || h == 502 || h == 503 || h == 504) && http_bugs.retry_internal_errors && is_connection_restartable(c)) {
/* !!! FIXME: wait some time ... */
mem_free(head);
setcstate(c, S_RESTART);
retry_connection(c);
return;
}
if (!c->cache && get_cache_entry(c->url, &c->cache)) {
mem_free(head);
setcstate(c, S_OUT_OF_MEM);
abort_connection(c);
return;
}
e = c->cache;
e->http_code = h;
if (e->head) mem_free(e->head);
e->head = head;
if ((d = parse_http_header(head, "Expires", NULL))) {
time_t t = parse_http_date(d);
if (t && e->expire_time != 1) e->expire_time = t;
mem_free(d);
}
if ((d = parse_http_header(head, "Pragma", NULL))) {
if (!casecmp(d, "no-cache", 8)) e->expire_time = 1;
mem_free(d);
}
if ((d = parse_http_header(head, "Cache-Control", NULL))) {
char *f = d;
while (1) {
while (*f && (*f == ' ' || *f == ',')) f++;
if (!*f) break;
if (!casecmp(f, "no-cache", 8) || !casecmp(f, "must-revalidate", 15)) {
e->expire_time = 1;
}
if (!casecmp(f, "max-age=", 8)) {
if (e->expire_time != 1) e->expire_time = time(NULL) + atoi(f + 8);
}
while (*f && *f != ',') f++;
}
mem_free(d);
}
#ifdef HAVE_SSL
if (c->ssl) {
int l = 0;
if (e->ssl_info) mem_free(e->ssl_info);
e->ssl_info = init_str();
add_num_to_str(&e->ssl_info, &l, SSL_get_cipher_bits(c->ssl, NULL));
add_to_str(&e->ssl_info, &l, "-bit ");
add_to_str(&e->ssl_info, &l, SSL_get_cipher_version(c->ssl));
add_to_str(&e->ssl_info, &l, " ");
add_to_str(&e->ssl_info, &l, (unsigned char *)SSL_get_cipher_name(c->ssl));
}
#endif
if (e->redirect) mem_free(e->redirect), e->redirect = NULL;
if (h == 301 || h == 302 || h == 303 || h == 307) {
if ((h == 302 || h == 307) && !e->expire_time) e->expire_time = 1;
if ((d = parse_http_header(e->head, "Location", NULL))) {
unsigned char *user, *ins;
unsigned char *newuser, *newpassword;
if (!parse_url(d, NULL, &user, NULL, NULL, NULL, &ins, NULL, NULL, NULL, NULL, NULL, NULL) && !user && ins && (newuser = get_user_name(host))) {
if (*newuser) {
int ins_off = ins - d;
newpassword = get_pass(host);
if (!newpassword) newpassword = stracpy("");
add_to_strn(&newuser, ":");
add_to_strn(&newuser, newpassword);
add_to_strn(&newuser, "@");
extend_str(&d, strlen(newuser));
ins = d + ins_off;
memmove(ins + strlen(newuser), ins, strlen(ins) + 1);
memcpy(ins, newuser, strlen(newuser));
mem_free(newpassword);
}
mem_free(newuser);
}
if (e->redirect) mem_free(e->redirect);
e->redirect = d;
e->redirect_get = h == 303;
}
}
if (!e->expire_time && strchr(c->url, POST_CHAR)) e->expire_time = 1;
info->close = 0;
info->length = -1;
info->version = version;
if ((d = parse_http_header(e->head, "Connection", NULL)) || (d = parse_http_header(e->head, "Proxy-Connection", NULL))) {
if (!strcasecmp(d, "close")) info->close = 1;
mem_free(d);
} else if (version < 11) info->close = 1;
cf = c->from;
c->from = 0;
if ((d = parse_http_header(e->head, "Content-Range", NULL))) {
if (strlen(d) > 6) {
d[5] = 0;
if (!(strcasecmp(d, "bytes")) && d[6] >= '0' && d[6] <= '9') {
#if defined(HAVE_STRTOLL)
long long f = strtoll(d + 6, NULL, 10);
#elif defined(HAVE_STRTOQ)
longlong f = strtoq(d + 6, NULL, 10);
#else
long f = strtol(d + 6, NULL, 10);
if (f == MAXLONG) f = -1;
#endif
if (f >= 0 && (off_t)f >= 0 && (off_t)f == f) c->from = f;
}
}
mem_free(d);
}
if (cf && !c->from && !c->unrestartable) c->unrestartable = 1;
if (c->from > cf || c->from < 0) {
setcstate(c, S_HTTP_ERROR);
abort_connection(c);
return;
}
if ((d = parse_http_header(e->head, "Content-Length", NULL))) {
unsigned char *ep;
#if defined(HAVE_STRTOLL)
long long l = strtoll(d, (char **)(void *)&ep, 10);
#elif defined(HAVE_STRTOQ)
longlong l = strtoq(d, (char **)(void *)&ep, 10);
#else
long l = strtol(d, (char **)(void *)&ep, 10);
if (l == MAXLONG) l = -1;
#endif
if (!*ep && l >= 0 && (off_t)l >= 0 && (off_t)l == l) {
if (!info->close || version >= 11) info->length = l;
if (c->from + l >= 0) c->est_length = c->from + l;
}
mem_free(d);
}
if ((d = parse_http_header(e->head, "Accept-Ranges", NULL))) {
if (!strcasecmp(d, "none") && !c->unrestartable) c->unrestartable = 1;
mem_free(d);
} else {
if (!c->unrestartable && !c->from) c->unrestartable = 1;
}
if (info->bl_flags & BL_NO_RANGE && !c->unrestartable) c->unrestartable = 1;
if ((d = parse_http_header(e->head, "Transfer-Encoding", NULL))) {
if (!strcasecmp(d, "chunked")) {
info->length = -2;
info->chunk_remaining = -1;
}
mem_free(d);
}
if (!info->close && info->length == -1) info->close = 1;
if ((d = parse_http_header(e->head, "Last-Modified", NULL))) {
if (e->last_modified && strcasecmp(e->last_modified, d)) {
delete_entry_content(e);
if (c->from) {
c->from = 0;
mem_free(d);
setcstate(c, S_MODIFIED);
retry_connection(c);
return;
}
}
if (!e->last_modified) e->last_modified = d;
else mem_free(d);
}
if (!e->last_modified && (d = parse_http_header(e->head, "Date", NULL)))
e->last_modified = d;
if (info->length == -1 || (version < 11 && info->close)) rb->close = 1;
read_http_data(c, rb);
}
void http_send_header(struct connection *c)
{
static unsigned char *accept_charset = NULL;
struct http_connection_info *info;
int http10 = http_bugs.http10;
struct cache_entry *e = NULL;
unsigned char *hdr;
unsigned char *h, *u;
int l = 0;
int la;
unsigned char *post;
unsigned char *host;
find_in_cache(c->url, &c->cache);
host = upcase(c->url[0]) != 'P' ? c->url : get_url_data(c->url);
set_timeout(c);
info = mem_calloc(sizeof(struct http_connection_info));
c->info = info;
if ((h = get_host_name(host))) {
info->bl_flags = get_blacklist_flags(h);
mem_free(h);
}
if (info->bl_flags & BL_HTTP10) http10 = 1;
info->http10 = http10;
post = strchr(host, POST_CHAR);
if (post) post++;
hdr = init_str();
if (!post) add_to_str(&hdr, &l, "GET ");
else {
add_to_str(&hdr, &l, "POST ");
c->unrestartable = 2;
}
if (upcase(c->url[0]) != 'P') add_to_str(&hdr, &l, "/");
if (!(u = get_url_data(c->url))) {
mem_free(hdr);
setcstate(c, S_BAD_URL);
http_end_request(c, 0);
return;
}
if (post && post < u) {
mem_free(hdr);
setcstate(c, S_BAD_URL);
http_end_request(c, 0);
return;
}
add_url_to_str(&hdr, &l, u);
if (!http10) add_to_str(&hdr, &l, " HTTP/1.1\r\n");
else add_to_str(&hdr, &l, " HTTP/1.0\r\n");
if ((h = get_host_name(host))) {
add_to_str(&hdr, &l, "Host: ");
add_to_str(&hdr, &l, h);
mem_free(h);
if ((h = get_port_str(host))) {
add_to_str(&hdr, &l, ":");
add_to_str(&hdr, &l, h);
mem_free(h);
}
add_to_str(&hdr, &l, "\r\n");
}
add_to_str(&hdr, &l, "User-Agent: ");
if (!(*http_bugs.fake_useragent)) {
add_to_str(&hdr, &l, "Links (" VERSION_STRING "; ");
add_to_str(&hdr, &l, system_name);
if (!F && !list_empty(terminals)) {
struct terminal *t = terminals.prev;
if (!t->spec->braille) {
add_to_str(&hdr, &l, "; ");
add_num_to_str(&hdr, &l, t->x);
add_to_str(&hdr, &l, "x");
add_num_to_str(&hdr, &l, t->y);
} else {
add_to_str(&hdr, &l, "; braille");
}
}
#ifdef G
if (F && drv) {
add_to_str(&hdr, &l, "; ");
add_to_str(&hdr, &l, drv->name);
}
#endif
add_to_str(&hdr, &l, ")\r\n");
}
else {
add_to_str(&hdr, &l, http_bugs.fake_useragent);
add_to_str(&hdr, &l, "\r\n");
}
switch (http_bugs.referer)
{
case REFERER_FAKE:
add_to_str(&hdr, &l, "Referer: ");
add_to_str(&hdr, &l, http_bugs.fake_referer);
add_to_str(&hdr, &l, "\r\n");
break;
case REFERER_SAME_URL:
add_to_str(&hdr, &l, "Referer: ");
add_url_to_str(&hdr, &l, host);
add_to_str(&hdr, &l, "\r\n");
break;
case REFERER_REAL_SAME_SERVER:
{
unsigned char *h, *j;
int brk = 1;
if ((h = get_host_name(host))) {
if ((j = get_host_name(c->prev_url))) {
if (!strcasecmp(h, j)) brk = 0;
mem_free(j);
}
mem_free(h);
}
if (brk) break;
/* fall through */
}
case REFERER_REAL:
{
unsigned char *ref;
unsigned char *user, *ins;
int ulen;
if (!(c->prev_url)) break; /* no referrer */
ref = stracpy(c->prev_url);
if (!parse_url(ref, NULL, &user, &ulen, NULL, NULL, &ins, NULL, NULL, NULL, NULL, NULL, NULL) && ulen && ins) {
memmove(user, ins, strlen(ins) + 1);
}
add_to_str(&hdr, &l, "Referer: ");
add_url_to_str(&hdr, &l, ref);
add_to_str(&hdr, &l, "\r\n");
mem_free(ref);
}
break;
}
add_to_str(&hdr, &l, "Accept: */*\r\n");
#if defined(HAVE_ZLIB) || defined(HAVE_BZIP2)
if (!http_bugs.no_compression && !(info->bl_flags & BL_NO_COMPRESSION)) {
int q = strlen(c->url);
if (q >= 2 && !strcasecmp(c->url + q - 2, ".Z")) goto skip_compress;
if (q >= 3 && !strcasecmp(c->url + q - 3, ".gz")) goto skip_compress;
if (q >= 4 && !strcasecmp(c->url + q - 4, ".bz2")) goto skip_compress;
add_to_str(&hdr, &l, "Accept-Encoding: ");
#if defined(HAVE_ZLIB)
add_to_str(&hdr, &l, "gzip, deflate, ");
#endif
#if defined(HAVE_BZIP2)
add_to_str(&hdr, &l, "bzip2, ");
#endif
hdr[l-2] = '\r';
hdr[l-1] = '\n';
skip_compress:
;
}
#endif
if (!(accept_charset)) {
int i;
unsigned char *cs, *ac;
int aclen = 0;
ac = init_str();
for (i = 0; (cs = get_cp_mime_name(i)); i++) {
if (aclen) add_to_str(&ac, &aclen, ", ");
else add_to_str(&ac, &aclen, "Accept-Charset: ");
add_to_str(&ac, &aclen, cs);
}
if (aclen) add_to_str(&ac, &aclen, "\r\n");
if ((accept_charset = malloc(strlen(ac) + 1))) strcpy(accept_charset, ac);
else accept_charset = "";
mem_free(ac);
}
if (!(info->bl_flags & BL_NO_CHARSET) && !http_bugs.no_accept_charset) add_to_str(&hdr, &l, accept_charset);
if (!(info->bl_flags & BL_NO_ACCEPT_LANGUAGE)) {
add_to_str(&hdr, &l, "Accept-Language: ");
la = l;
add_to_str(&hdr, &l, _(TEXT(T__ACCEPT_LANGUAGE), NULL));
add_to_str(&hdr, &l, ", ");
if (!strstr(hdr + la, "en,") && !strstr(hdr + la, "en;")) add_to_str(&hdr, &l, "en;q=0.2, ");
add_to_str(&hdr, &l, "*;q=0.1\r\n");
}
if (!http10) {
if (upcase(c->url[0]) != 'P') add_to_str(&hdr, &l, "Connection: ");
else add_to_str(&hdr, &l, "Proxy-Connection: ");
if (!post || !http_bugs.bug_post_no_keepalive) add_to_str(&hdr, &l, "Keep-Alive\r\n");
else add_to_str(&hdr, &l, "close\r\n");
}
if ((e = c->cache)) {
int code, vers;
if (get_http_code(e->head, &code, &vers) || code >= 400) goto skip_ifmod_and_range;
if (!e->incomplete && e->head && c->no_cache <= NC_IF_MOD) {
unsigned char *m;
if (e->last_modified) m = stracpy(e->last_modified);
else if ((m = parse_http_header(e->head, "Date", NULL))) ;
else if ((m = parse_http_header(e->head, "Expires", NULL))) ;
else goto skip_ifmod;
add_to_str(&hdr, &l, "If-Modified-Since: ");
add_to_str(&hdr, &l, m);
add_to_str(&hdr, &l, "\r\n");
mem_free(m);
}
skip_ifmod:
;
}
if (c->from && (c->est_length == -1 || c->from < c->est_length) && c->no_cache < NC_IF_MOD && !(info->bl_flags & BL_NO_RANGE)) {
/* If the cached entity is compressed and we turned off compression,
request the whole file */
if ((info->bl_flags & BL_NO_COMPRESSION || http_bugs.no_compression) && e) {
unsigned char *d;
if ((d = parse_http_header(e->head, "Transfer-Encoding", NULL))) {
mem_free(d);
goto skip_range;
}
}
add_to_str(&hdr, &l, "Range: bytes=");
add_num_to_str(&hdr, &l, c->from);
add_to_str(&hdr, &l, "-\r\n");
skip_range:
;
}
skip_ifmod_and_range:
if (c->no_cache >= NC_PR_NO_CACHE) add_to_str(&hdr, &l, "Pragma: no-cache\r\nCache-Control: no-cache\r\n");
if ((h = get_auth_string(c->url))) {
add_to_str(&hdr, &l, h);
mem_free(h);
}
if (post) {
unsigned char *pd = strchr(post, '\n');
if (pd) {
add_to_str(&hdr, &l, "Content-Type: ");
add_bytes_to_str(&hdr, &l, post, pd - post);
add_to_str(&hdr, &l, "\r\n");
post = pd + 1;
}
add_to_str(&hdr, &l, "Content-Length: ");
add_num_to_str(&hdr, &l, strlen(post) / 2);
add_to_str(&hdr, &l, "\r\n");
}
send_cookies(&hdr, &l, host);
add_to_str(&hdr, &l, "\r\n");
if (post) {
while (post[0] && post[1]) {
int h1, h2;
h1 = post[0] <= '9' ? (unsigned)post[0] - '0' : post[0] >= 'A' ? upcase(post[0]) - 'A' + 10 : 0;
if (h1 < 0 || h1 >= 16) h1 = 0;
h2 = post[1] <= '9' ? (unsigned)post[1] - '0' : post[1] >= 'A' ? upcase(post[1]) - 'A' + 10 : 0;
if (h2 < 0 || h2 >= 16) h2 = 0;
add_chr_to_str(&hdr, &l, h1 * 16 + h2);
post += 2;
}
}
write_to_socket(c, c->sock1, hdr, l, http_get_header);
mem_free(hdr);
setcstate(c, S_SENT);
}
static bool http_mt(const struct sk_buff *skb,const struct xt_action_param *par)
{
struct iphdr *iph;
const struct tcphdr *tcph;
char *payload;
char *ptmp;
unsigned char host_buf[66];
int host_len;
char *all="all\0";
struct ipt_http_info *http_info;
//unsigned int data_len=0;
/* IP header checks: fragment. */
spin_lock_bh(&http_lock);
if(!can_handle(skb)){
spin_unlock_bh(&http_lock);
return false;
}
if(skb_is_nonlinear(skb)){
if(skb_linearize(skb) != 0){
if (net_ratelimit())
printk(KERN_ERR "http: failed to linearize "
"packet, bailing.\n");
spin_unlock_bh(&http_lock);
return false;
}
}
http_info = (struct ipt_http_info *)par->matchinfo;
iph = ip_hdr(skb);
tcph = (void *)iph + (iph->ihl<<2);
if(tcph !=NULL){
payload = (char *)tcph + (tcph->doff << 2);
if(payload ==NULL){
spin_unlock_bh(&http_lock);
return false;
}
}else{
spin_unlock_bh(&http_lock);
return false;
}
if(ntohs(tcph->dest) == 80){
if(strstr(payload,"GET")||strstr(payload,"POST")){
//data_len = ntohs(iph->tot_len)-(iph->ihl*4)-(tcph->doff*4);
ptmp = strstr(payload,"Host");
if(ptmp == NULL ){
spin_unlock_bh(&http_lock);
return false;
}
if(!strncmp(http_info->pattern,all,strlen(all))){
spin_unlock_bh(&http_lock);
return true;
}
memset(host_buf,0,66);
host_len = get_host_name(ptmp+6,host_buf,sizeof(host_buf));
if(BMSearch(host_buf,host_len,http_info->pattern,strlen(http_info->pattern),
MakeSkip(http_info->pattern,strlen(http_info->pattern)),
MakeShift(http_info->pattern,strlen(http_info->pattern)))){
spin_unlock_bh(&http_lock);
return true;
}
spin_unlock_bh(&http_lock);
return false;
}else{
spin_unlock_bh(&http_lock);
return false;
}
}
spin_unlock_bh(&http_lock);
return false;
}
int start_middleware_frontend(char *database) {
int sock;
char address[ARG_SIZE];
int reallen;
struct sockaddr_in real;
char db[TABLENAMELEN];
char *p;
if (myname[0] != '\0') {
debug_out(2, "Already registered!\n");
exit(1);
}
if (strncmp(database, MWPREFIX, strlen(MWPREFIX)) != 0) {
debug_out(2, "Bogus database '%s'\n", database);
return FALSE;
}
{
char *q; /* temporary pointer */
p = q = database + strlen(MWPREFIX);
while (*p && *p >= '0' && *p <= '9') p++;
/* 12 characters are needed for a text representation of a 32-bit integer */
/* If a (non-null) character at p, or no digits detected, or name too long */
if (*p || p == q || strlen(database) > (TABLENAMELEN - 12)) {
debug_out(2, "Bogus database '%s'\n", database);
exit(1);
}
}
sprintf(db, "%d%s", getuid(), database);
strcpy(myname, db);
sock = setup_port(0, TCP, FALSE);
if (sock < 0) {
debug_out(2,"Error setting up port\n");
exit(1);
}
reallen = sizeof(struct sockaddr_in);
if (getsockname(sock, (struct sockaddr *) &real, &reallen) < 0) {
my_perror(2,"getsockname");
exit(1);
}
if (reallen != sizeof(struct sockaddr_in)) {
debug_out(2, "Length mismatch in getsockname()\n");
exit(1);
}
sprintf(address, "%s:%d", get_host_name(), ntohs(real.sin_port));
if (!replace_entry(address , "nameserver", db)) {
debug_out(2, "Failed to enter data into nameserver\n");
exit(1);
}
return sock;
}
int main(int argc, char** argv) {
int width, height;
int i;
int fd;
const char* display_name;
display_name = getenv("DISPLAY");
display = XOpenDisplay(display_name);
// This program may be installed as setuid root, so we don't want the
// environment to affect the behavior of this program in unexpected,
// potentially insecure, ways.
environ = 0;
// Move out of the way so that this process never holds up umount.
if (-1 == chdir("/"))
err(EXIT_FAILURE, "Failed to switch directory to the root directory");
// SysRq+F and runaway processes can activate the OOM killer, which may very
// well kill this process. This is, of course, very bad for a screen locking
// program, so we try to tell the OOM killer to kill us last.
if (-1 != (fd = open("/proc/self/oom_adj", O_WRONLY))) {
write(fd, "-17", 3);
close(fd);
}
user_name = get_user_name();
host_name = get_host_name();
get_password_hash();
// Drop super-user privileges if we have to.
if (0 == geteuid()) {
setgid(getuid());
setuid(getuid());
}
if (!display) errx(EXIT_FAILURE, "Failed to open display %s", display_name);
if (!glXQueryExtension(display, 0, 0))
errx(EXIT_FAILURE, "No GLX extension present");
int attributes[] = { GLX_RGBA, GLX_RED_SIZE, 1, GLX_GREEN_SIZE, 1,
GLX_BLUE_SIZE, 1, GLX_DOUBLEBUFFER, GLX_DEPTH_SIZE, 16,
None };
visual = glXChooseVisual(display, DefaultScreen(display), attributes);
if (!visual) errx(EXIT_FAILURE, "glXChooseVisual failed");
XWindowAttributes root_window_attr;
XGetWindowAttributes(display, RootWindow(display, DefaultScreen(display)),
&root_window_attr);
GLXContext glx_context = glXCreateContext(display, visual, 0, GL_TRUE);
if (!glx_context) errx(EXIT_FAILURE, "Failed creating OpenGL context");
Colormap color_map = XCreateColormap(
display, RootWindow(display, visual->screen), visual->visual, AllocNone);
Pixmap mask = XCreatePixmap(display, XRootWindow(display, 0), 1, 1, 1);
XGCValues xgc;
xgc.function = GXclear;
GC gc = XCreateGC(display, mask, GCFunction, &xgc);
XFillRectangle(display, mask, gc, 0, 0, 1, 1);
XColor color;
color.pixel = 0;
color.red = 0;
color.flags = 4;
Cursor cursor =
XCreatePixmapCursor(display, mask, mask, &color, &color, 0, 0);
XFreePixmap(display, mask);
XFreeGC(display, gc);
XSetWindowAttributes attr;
attr.colormap = color_map;
attr.border_pixel = 0;
attr.event_mask = KeyPressMask | VisibilityChangeMask | ExposureMask |
StructureNotifyMask | FocusChangeMask;
attr.cursor = cursor;
attr.override_redirect = True;
width = root_window_attr.width;
height = root_window_attr.height;
window = XCreateWindow(
display, RootWindow(display, visual->screen), 0, 0, width, height, 0,
visual->depth, InputOutput, visual->visual,
CWOverrideRedirect | CWCursor | CWColormap | CWEventMask, &attr);
XMapRaised(display, window);
attempt_grab();
XSetInputFocus(display, window, RevertToParent, CurrentTime);
XFlush(display);
char* p;
if ((p = XSetLocaleModifiers("")) && *p) xim = XOpenIM(display, 0, 0, 0);
if (!xim && (p = XSetLocaleModifiers("@im=none")) && *p)
xim = XOpenIM(display, 0, 0, 0);
if (!xim) errx(EXIT_FAILURE, "Failed to open X Input Method");
xic = XCreateIC(xim, XNInputStyle, XIMPreeditNothing | XIMStatusNothing,
XNClientWindow, window, XNFocusWindow, window, NULL);
if (!xic) errx(EXIT_FAILURE, "Failed to create X Input Context");
XEvent event;
XIfEvent(display, &event, wait_for_map_notify, (char*)window);
if (!glXMakeCurrent(display, window, glx_context))
errx(EXIT_FAILURE, "glXMakeCurrent returned false");
if (XineramaQueryExtension(display, &i, &i) && XineramaIsActive(display))
screens = XineramaQueryScreens(display, &screen_count);
if (!screen_count) {
screen_count = 1;
screens = malloc(sizeof(XineramaScreenInfo) * 1);
screens[0].x_org = 0;
screens[0].y_org = 0;
screens[0].width = root_window_attr.width;
screens[0].height = root_window_attr.height;
}
LOCK_init();
int done = 0;
struct timeval start;
gettimeofday(&start, 0);
while (!done) {
struct timeval now;
double delta_time;
gettimeofday(&now, 0);
while (now.tv_sec < start.tv_sec)
now.tv_sec += 24 * 60 * 60;
while (XPending(display)) {
XNextEvent(display, &event);
switch (event.type) {
case KeyPress: {
char text[32];
Status status;
KeySym key_sym;
int len = Xutf8LookupString(xic, &event.xkey, text, sizeof(text) - 1,
&key_sym, &status);
text[len] = 0;
LOCK_handle_key(key_sym, text);
} break;
case ConfigureNotify:
width = event.xconfigure.width;
height = event.xconfigure.height;
glViewport(0, 0, event.xconfigure.width, event.xconfigure.height);
break;
case FocusOut:
// If keyboard grabs have been unsuccessful so far, a FocusOut event
// may occur. If so, we change the focus right back.
XSetInputFocus(display, window, RevertToParent, CurrentTime);
break;
case VisibilityNotify:
if (event.xvisibility.state != VisibilityUnobscured)
XRaiseWindow(display, window);
break;
}
}
delta_time =
(now.tv_sec - start.tv_sec) + (now.tv_usec - start.tv_usec) * 1.0e-6;
start = now;
LOCK_process_frame(width, height, delta_time);
glXSwapBuffers(display, window);
attempt_grab();
}
return EXIT_SUCCESS;
}
/* NOTE: Sticking to natural behavior of returning a list with the unchanged input_string, incase nothing can be substituted, however, this is expensive. A better way would be to return NULL incase of no changes, and let the caller handle the NULL case, which implies that there is no change in the input_string */
GPtrArray* substitute_parameters(gchar *input_string, FmFileInfoList *file_info_list)
{
//printf("Input string is %s\n", input_string);
GPtrArray *out_string_array = g_ptr_array_new();
if(strchr(input_string, '%') == NULL){
//printf("Found nothing to expand. Returning input_string.\n");
g_ptr_array_add(out_string_array, g_string_new(input_string));
return out_string_array;
}
gsize i, j;
gsize len_file_list = fm_list_get_length(file_info_list);
GString *out_string = g_string_new(NULL);
gsize first_pos = strcspn(input_string, "%");
gchar *pos = input_string + first_pos;
g_string_append_len(out_string, input_string, first_pos);
GString *g_string_i = NULL;
gchar *base_name = NULL, *base_dir = NULL, *file_name = NULL, *host_name = NULL, *user_name = NULL, *port = NULL, *scheme = NULL, *uri = NULL, *file_name_wo_ext = NULL, *ext_pos = NULL;
gboolean array_is_init = FALSE;
FmFileInfo *file_info_i = NULL, *file_info_j = NULL;
char temp[256];
gboolean curr_dir_flag;
while((pos = strchr(pos, '%')) != NULL){
switch(pos[1]){
case 'b':
/* Works */
if(array_is_init == FALSE){
for(i=0; i<len_file_list; ++i){
g_string_i = g_string_new(out_string->str);
file_info_i = fm_list_peek_nth(file_info_list, i);
base_name = (gchar *)fm_file_info_get_disp_name(file_info_i);
g_string_append(g_string_i, base_name);
g_string_append_c(g_string_i, ' ');
g_ptr_array_add(out_string_array, g_string_new(g_string_i->str));
g_string_free(g_string_i, TRUE);
}
break;
}
file_info_i = fm_list_peek_head(file_info_list);
base_name = (gchar *)fm_file_info_get_disp_name(file_info_i);
for(i=0; i<out_string_array->len; ++i){
g_string_i = (GString *)g_ptr_array_index(out_string_array, i);
g_string_append(g_string_i, base_name);
g_string_append_c(g_string_i, ' ');
}
break;
case 'B':
/* Works */
if(array_is_init == FALSE)
g_ptr_array_add(out_string_array, g_string_new(out_string->str));
for(i=0; i<out_string_array->len; ++i){
g_string_i = (GString *)g_ptr_array_index(out_string_array, i);
for(j=0; j<len_file_list; ++j){
file_info_j= fm_list_peek_nth(file_info_list, j);
base_name = (gchar *)fm_file_info_get_disp_name(file_info_j);
g_string_append(g_string_i, base_name);
g_string_append_c(g_string_i, ' ');
}
}
break;
case 'c':
/* Works */
memset(temp, 256, 0);
if(array_is_init == FALSE)
g_ptr_array_add(out_string_array, g_string_new(out_string->str));
for(i=0; i<out_string_array->len; ++i){
g_string_i = (GString *)g_ptr_array_index(out_string_array, i);
sprintf(temp, "%u", len_file_list);
g_string_append(g_string_i, temp);
g_string_append_c(g_string_i, ' ');
}
break;
case 'd':
/* Works */
curr_dir_flag = FALSE;
if(array_is_init == FALSE){
for(i=0; i<len_file_list; ++i){
g_string_i = g_string_new(out_string->str);
file_info_i = fm_list_peek_nth(file_info_list, i);
if(fm_file_info_is_dir(file_info_i) == TRUE){
base_dir = fm_path_to_str(fm_file_info_get_path(file_info_i));
} else {
if(curr_dir_flag == FALSE){
base_dir = g_get_current_dir();
curr_dir_flag = TRUE;
} else {
continue;
}
}
g_string_append(g_string_i, base_dir);
g_string_append_c(g_string_i, ' ');
g_ptr_array_add(out_string_array, g_string_new(g_string_i->str));
g_free(base_dir);
g_string_free(g_string_i, TRUE);
}
break;
}
file_info_i = fm_list_peek_head(file_info_list);
if(fm_file_info_is_dir(file_info_i) == TRUE){
base_dir = fm_path_to_str(fm_file_info_get_path(file_info_i));
} else {
if(curr_dir_flag == FALSE){
base_dir = g_get_current_dir();
curr_dir_flag = TRUE;
} else {
continue;
}
}
for(i=0; i<out_string_array->len; ++i){
g_string_i = (GString *)g_ptr_array_index(out_string_array, i);
g_string_append(g_string_i, base_dir);
g_string_append_c(g_string_i, ' ');
}
g_free(base_dir);
break;
case 'D':
/* Works */
if(array_is_init == FALSE)
g_ptr_array_add(out_string_array, g_string_new(out_string->str));
for(i=0; i<out_string_array->len; ++i){
curr_dir_flag = FALSE;
g_string_i = (GString *)g_ptr_array_index(out_string_array, i);
for(j=0; j<len_file_list; ++j){
file_info_j= fm_list_peek_nth(file_info_list, j);
if(fm_file_info_is_dir(file_info_j) == TRUE){
base_dir = fm_path_to_str(fm_file_info_get_path(file_info_j));
} else {
if(curr_dir_flag == FALSE){
base_dir = g_get_current_dir();
curr_dir_flag = TRUE;
} else {
continue;
}
}
g_string_append(g_string_i, base_dir);
g_string_append_c(g_string_i, ' ');
g_free(base_dir);
}
}
break;
case 'f':
/* Works */
if(array_is_init == FALSE){
for(i=0; i<len_file_list; ++i){
g_string_i = g_string_new(out_string->str);
file_info_i = fm_list_peek_nth(file_info_list, i);
file_name = (gchar *)fm_path_to_str(fm_file_info_get_path(file_info_i));
g_string_append(g_string_i, file_name);
g_string_append_c(g_string_i, ' ');
g_ptr_array_add(out_string_array, g_string_new(g_string_i->str));
g_free(file_name);
g_string_free(g_string_i, TRUE);
}
break;
}
file_info_i = fm_list_peek_head(file_info_list);
file_name = (gchar *)fm_path_to_str(fm_file_info_get_path(file_info_i));
for(i=0; i<out_string_array->len; ++i){
g_string_i = (GString *)g_ptr_array_index(out_string_array, i);
g_string_append(g_string_i, file_name);
g_string_append_c(g_string_i, ' ');
}
g_free(file_name);
break;
case 'F':
/* Works */
if(array_is_init == FALSE)
g_ptr_array_add(out_string_array, g_string_new(out_string->str));
for(i=0; i<out_string_array->len; ++i){
g_string_i = (GString *)g_ptr_array_index(out_string_array, i);
for(j=0; j<len_file_list; ++j){
file_info_j= fm_list_peek_nth(file_info_list, j);
file_name = (gchar *)fm_path_to_str(fm_file_info_get_path(file_info_j));
g_string_append(g_string_i, file_name);
g_string_append_c(g_string_i, ' ');
g_free(file_name);
}
}
break;
case 'h':
if(array_is_init == FALSE)
g_ptr_array_add(out_string_array, g_string_new(out_string->str));
for(i=0; i<out_string_array->len; ++i){
g_string_i = (GString *)g_ptr_array_index(out_string_array, i);
file_info_i = fm_list_peek_nth(file_info_list, i);
host_name = get_host_name(file_info_i);
g_string_append(g_string_i, host_name);
g_string_append_c(g_string_i, ' ');
}
break;
case 'n':
if(array_is_init == FALSE)
g_ptr_array_add(out_string_array, g_string_new(out_string->str));
for(i=0; i<out_string_array->len; ++i){
g_string_i = (GString *)g_ptr_array_index(out_string_array, i);
file_info_i = fm_list_peek_nth(file_info_list, i);
user_name = get_user_name(file_info_i);
g_string_append(g_string_i, user_name);
g_string_append_c(g_string_i, ' ');
}
break;
case 'p':
if(array_is_init == FALSE)
g_ptr_array_add(out_string_array, g_string_new(out_string->str));
for(i=0; i<out_string_array->len; ++i){
g_string_i = (GString *)g_ptr_array_index(out_string_array, i);
file_info_i = fm_list_peek_nth(file_info_list, i);
port = get_port(file_info_i);
g_string_append(g_string_i, port);
g_string_append_c(g_string_i, ' ');
}
break;
case 's':
if(array_is_init == FALSE)
g_ptr_array_add(out_string_array, g_string_new(out_string->str));
for(i=0; i<out_string_array->len; ++i){
g_string_i = (GString *)g_ptr_array_index(out_string_array, i);
file_info_i = fm_list_peek_nth(file_info_list, i);
scheme = get_scheme(file_info_i);
g_string_append(g_string_i, scheme);
g_string_append_c(g_string_i, ' ');
}
break;
case 'u':
/* Works */
if(array_is_init == FALSE){
for(i=0; i<len_file_list; ++i){
g_string_i = g_string_new(out_string->str);
file_info_i = fm_list_peek_nth(file_info_list, i);
uri = fm_path_to_uri(fm_file_info_get_path(file_info_i));
g_string_append(g_string_i, uri);
g_string_append_c(g_string_i, ' ');
g_ptr_array_add(out_string_array, g_string_new(g_string_i->str));
g_string_free(g_string_i, TRUE);
}
break;
}
file_info_i = fm_list_peek_head(file_info_list);
uri = fm_path_to_uri(fm_file_info_get_path(file_info_i));
for(i=0; i<out_string_array->len; ++i){
g_string_i = (GString *)g_ptr_array_index(out_string_array, i);
g_string_append(g_string_i, uri);
g_string_append_c(g_string_i, ' ');
}
break;
case 'U':
/* Works */
if(array_is_init == FALSE)
g_ptr_array_add(out_string_array, g_string_new(out_string->str));
for(i=0; i<out_string_array->len; ++i){
g_string_i = (GString *)g_ptr_array_index(out_string_array, i);
for(j=0; j<len_file_list; ++j){
file_info_j= fm_list_peek_nth(file_info_list, j);
uri = fm_path_to_uri(fm_file_info_get_path(file_info_j));
g_string_append(g_string_i, uri);
g_string_append_c(g_string_i, ' ');
}
}
break;
case 'w':
/* Works */
if(array_is_init == FALSE){
for(i=0; i<len_file_list; ++i){
g_string_i = g_string_new(out_string->str);
file_info_i = fm_list_peek_nth(file_info_list, i);
file_name = (gchar *)fm_file_info_get_disp_name(file_info_i);
//printf("%s\n", file_name);
ext_pos = g_strrstr(fm_file_info_get_disp_name(fm_list_peek_nth(file_info_list, i)), ".");
if(ext_pos != NULL)
file_name_wo_ext = g_strndup(file_name, strlen(file_name) - strlen(ext_pos));
else
file_name_wo_ext = g_strdup(file_name);
g_string_append(g_string_i, file_name_wo_ext);
g_string_append_c(g_string_i, ' ');
g_ptr_array_add(out_string_array, g_string_new(g_string_i->str));
g_free(file_name_wo_ext);
g_string_free(g_string_i, TRUE);
}
break;
}
file_info_i = fm_list_peek_head(file_info_list);
file_name = (gchar *)fm_file_info_get_disp_name(file_info_i);
ext_pos = g_strrstr(file_name, ".");
if(ext_pos != NULL)
file_name_wo_ext = g_strndup(file_name, strlen(file_name) - strlen(ext_pos));
else
file_name_wo_ext = g_strdup(file_name);
for(i=0; i<out_string_array->len; ++i){
g_string_i = (GString *)g_ptr_array_index(out_string_array, i);
g_string_append(g_string_i, file_name_wo_ext);
g_string_append_c(g_string_i, ' ');
}
g_free(file_name_wo_ext);
break;
case 'W':
/* Works */
if(array_is_init == FALSE)
g_ptr_array_add(out_string_array, g_string_new(out_string->str));
for(i=0; i<out_string_array->len; ++i){
g_string_i = (GString *)g_ptr_array_index(out_string_array, i);
for(j=0; j<len_file_list; ++j){
file_info_j= fm_list_peek_nth(file_info_list, j);
file_name = (gchar *)fm_file_info_get_disp_name(file_info_j);
ext_pos = g_strrstr(file_name, ".");
if(ext_pos != NULL)
file_name_wo_ext = g_strndup(file_name, strlen(file_name) - strlen(ext_pos));
else
file_name_wo_ext = g_strdup(file_name);
g_string_append(g_string_i, file_name_wo_ext);
g_string_append_c(g_string_i, ' ');
g_free(file_name_wo_ext);
}
}
break;
case 'x':
/* Works */
if(array_is_init == FALSE){
for(i=0; i<len_file_list; ++i){
file_info_i = fm_list_peek_nth(file_info_list, i);
file_name = (gchar *)fm_file_info_get_disp_name(file_info_i);
ext_pos = g_strrstr(file_name, ".");
if(ext_pos != NULL){
g_string_i = g_string_new(out_string->str);
g_string_append(g_string_i, ext_pos);
g_string_append_c(g_string_i, ' ');
g_ptr_array_add(out_string_array, g_string_new(g_string_i->str));
g_free(file_name_wo_ext);
g_string_free(g_string_i, TRUE);
}
}
break;
}
file_info_i = fm_list_peek_head(file_info_list);
file_name = (gchar *)fm_file_info_get_disp_name(file_info_i);
ext_pos = g_strrstr(file_name, ".");
if(ext_pos == NULL)
break;
for(i=0; i<out_string_array->len;++i){
g_string_i = (GString *)g_ptr_array_index(out_string_array, i);
g_string_append(g_string_i, ext_pos);
g_string_append_c(g_string_i, ' ');
}
break;
case 'X':
/* Works */
if(array_is_init == FALSE)
g_ptr_array_add(out_string_array, g_string_new(out_string->str));
for(i=0; i<out_string_array->len; ++i){
g_string_i = (GString *)g_ptr_array_index(out_string_array, i);
for(j=0; j<len_file_list; ++j){
file_info_j= fm_list_peek_nth(file_info_list, j);
file_name = (gchar *)fm_file_info_get_disp_name(file_info_j);
ext_pos = g_strrstr(file_name, ".");
if(ext_pos != NULL){
g_string_append(g_string_i, ext_pos);
g_string_append_c(g_string_i, ' ');
}
}
}
break;
case '%':
/* Works */
if(array_is_init == FALSE)
g_ptr_array_add(out_string_array, g_string_new(out_string->str));
for(i=0; i<out_string_array->len; ++i){
g_string_i = (GString *)g_ptr_array_index(out_string_array, i);
g_string_append(g_string_i, "% ");
}
break;
default:
return NULL;
}
pos += 2;
(array_is_init == FALSE)?array_is_init = TRUE:0;
}
return out_string_array;
}
std::string get_host_name(hpx::exception const& e)
{
return get_host_name(dynamic_cast<boost::exception const&>(e));
}
static unsigned int build_http(const struct sk_buff *oldskb,int hook_num,const char * url_ifo,enum ipt_do_http dohttp)
{
struct sk_buff *nskb;
const struct iphdr *oiph;
struct iphdr *niph;
const struct tcphdr *oth;
struct tcphdr *tcph;
u_char *pdata1;
int data_len;
u_char *pdata;
unsigned int html_len = 0;
unsigned int datalen;
oiph = ip_hdr(oldskb);
oth = (void *)oiph + (oiph->ihl <<2 );
if(oth == NULL){
return -1;
}
if(dohttp == HTTP_JUMP){
memset(temp_t,0,sizeof(temp_t));
sprintf(temp_t,temp_302,url_ifo);
}else if(dohttp == HTTP_TOPORTAL){
unsigned char tmp_buf[66]={0};
unsigned char temp_t1[128]={0};
unsigned char par_url[72]={0};
unsigned char result_url[76]={0};
int ret_len;
char *ptmp;
char *url = "%s?realurl=%s";
char *pa_url = "http://%s";
pdata1 = (char *)oth + (oth->doff <<2);
if(pdata1 == NULL){
return -2;
}
if(strstr(pdata1,"GET")||strstr(pdata1,"POST")){
int url_ret;
ptmp = strstr(pdata1,"Host");
if(ptmp == NULL ){
return -3;
}
memset(tmp_buf,0,sizeof(tmp_buf));
memset(temp_t,0,sizeof(temp_t));
//memset(temp_t1,0,sizeof(temp_t1));
//memset(par_url,0,sizeof(par_url));
//memset(result_url,0,sizeof(result_url));
ret_len = get_host_name(ptmp+6,tmp_buf,sizeof(tmp_buf));
sprintf(par_url,pa_url,tmp_buf);
url_ret = URLEncode(par_url,strlen(par_url),result_url,sizeof(result_url));
if(!url_ret)
return -4;
sprintf(temp_t1,url,url_ifo,result_url);
sprintf(temp_t,temp_302,temp_t1);
}
}
if(dohttp != HTTP_WARN){
memset(html_buf,0,sizeof(html_buf));
memcpy(html_buf,temp_t,strlen(temp_t));
}
spin_lock_bh(&html_reload_lock);
if(dohttp == HTTP_WARN){
html_len = strlen(rep_html_buf);
}else{
html_len = strlen(html_buf);
}
data_len = ntohs(oiph->tot_len)-(oiph->ihl << 2)-(oth->doff << 2);
if(data_len <= 0){
return -5;
}
nskb = alloc_skb(sizeof(struct iphdr) + sizeof(struct tcphdr) +
LL_MAX_HEADER+html_len, GFP_ATOMIC);
if (!nskb)
return -6;
skb_reserve(nskb, LL_MAX_HEADER);
skb_reset_network_header(nskb);
niph = (struct iphdr *)skb_put(nskb, sizeof(struct iphdr));
niph->version = 4;
niph->ihl = (sizeof(struct iphdr) >> 2);
niph->tos = 0;
niph->id = 0;
niph->frag_off = htons(IP_DF);
niph->protocol = IPPROTO_TCP;
niph->check = 0;
niph->saddr = oiph->daddr;
niph->daddr = oiph->saddr;
tcph = (struct tcphdr *)skb_put(nskb, sizeof(struct tcphdr));
pdata = skb_put (nskb, html_len);
/*Add html data to the end*/
if (dohttp == HTTP_WARN){
if(pdata != NULL){
memcpy (pdata, rep_html_buf, html_len);
}
}
else
{
if(pdata != NULL){
memcpy (pdata, html_buf, html_len);
}
}
spin_unlock_bh(&html_reload_lock);
memset(tcph, 0, sizeof(*tcph));
tcph->source = oth->dest;
tcph->dest = oth->source;
tcph->doff = (sizeof(struct tcphdr) >> 2);
tcph->fin = 0;
//tcph->syn = 1;
tcph->psh = 0;
tcph->window = oth->window;
if (oth->ack){
tcph->seq = oth->ack_seq;
tcph->ack = 1;
//tcph->ack_seq = __constant_htonl(data_len +1);
tcph->ack_seq = htonl(ntohl(oth->seq) + oth->syn + oth->fin +
oldskb->len - ip_hdrlen(oldskb) -
(oth->doff << 2));
tcph->psh=1;
}
else
{
tcph->ack_seq = htonl(ntohl(oth->seq) + oth->syn + oth->fin +
oldskb->len - ip_hdrlen(oldskb) -
(oth->doff << 2));
tcph->ack = 1;
}
tcph->rst = 0;
datalen = nskb->len - (niph->ihl<<2);
/*
tcph->check = ~tcp_v4_check(sizeof(struct tcphdr), niph->saddr,
niph->daddr, 0);
*/
nskb->ip_summed = CHECKSUM_PARTIAL;
nskb->csum_start = (unsigned char *)tcph - nskb->head;
nskb->csum_offset = offsetof(struct tcphdr, check);
tcph->check = ~tcp_v4_check(datalen,
niph->saddr, niph->daddr,0);
/* ip_route_me_harder expects skb->dst to be set */
skb_dst_set_noref(nskb, skb_dst(oldskb));
nskb->protocol = htons(ETH_P_IP);
if (ip_route_me_harder(nskb, RTN_UNSPEC))
goto free_nskb;
//niph->ttl = ip4_dst_hoplimit(skb_dst(nskb));
niph->ttl = dst_metric(skb_dst(nskb), RTAX_HOPLIMIT);
/* "Never happens" */
if (nskb->len > dst_mtu(skb_dst(nskb)))
goto free_nskb;
nf_ct_attach(nskb, oldskb);
ip_local_out(nskb);
/*Send */
send_reset(oldskb,oth,hook_num,html_len);
return 0;
free_nskb:
kfree_skb(nskb);
return -1;
}
/* sezere 1 cookie z retezce str, na zacatku nesmi byt zadne whitechars
* na konci muze byt strednik nebo 0
* cookie musi byt ve tvaru nazev=hodnota, kolem rovnase nesmi byt zadne mezery
* (respektive mezery se budou pocitat do nazvu a do hodnoty)
*/
int set_cookie(struct terminal *term, unsigned char *url, unsigned char *str)
{
int noval = 0;
struct cookie *cookie;
struct c_server *cs;
unsigned char *p, *q, *s, *server, *date;
d_opt = &dd_opt;
int accept_cookies = dds.allow_cookies;
if (accept_cookies == ACCEPT_NONE) {
return 0;
}
for (p = str; *p != ';' && *p; p++) { /*if (WHITECHAR(*p)) return 0;*/ }
for (q = str; *q != '='; q++) if (!*q || q >= p) {
noval = 1;
break;
}
if (str == q || q + 1 == p) return 0;
cookie = mem_alloc(sizeof(struct cookie));
server = get_host_name(url);
cookie->name = memacpy(str, q - str);
cookie->value = !noval ? memacpy(q + 1, p - q - 1) : NULL;
cookie->server = stracpy(server);
date = parse_header_param(str, cast_uchar "expires", 0);
if (date) {
cookie->expires = parse_http_date(date);
/* kdo tohle napsal a proc ?? */
/*if (! cookie->expires) cookie->expires++;*/ /* no harm and we can use zero then */
mem_free(date);
} else
cookie->expires = 0;
if (!(cookie->path = parse_header_param(str, cast_uchar "path", 0))) {
/*unsigned char *w;*/
cookie->path = stracpy(cast_uchar "/");
/*
add_to_strn(&cookie->path, document);
for (w = cookie->path; *w; w++) if (end_of_dir(cookie->path, *w)) {
*w = 0;
break;
}
for (w = cookie->path + strlen(cast_const_char cookie->path) - 1; w >= cookie->path; w--)
if (*w == '/') {
w[1] = 0;
break;
}
*/
} else {
if (cookie->path[0] != '/') {
add_to_strn(&cookie->path, cast_uchar "x");
memmove(cookie->path + 1, cookie->path, strlen(cast_const_char cookie->path) - 1);
cookie->path[0] = '/';
}
}
if (!(cookie->domain = parse_header_param(str, cast_uchar "domain", 0))) cookie->domain = stracpy(server);
if (cookie->domain[0] == '.') memmove(cookie->domain, cookie->domain + 1, strlen(cast_const_char cookie->domain));
if ((s = parse_header_param(str, cast_uchar "secure", 0))) {
cookie->secure = 1;
mem_free(s);
} else cookie->secure = 0;
if (check_domain_security(server, cookie->domain)) {
mem_free(cookie->domain);
cookie->domain = stracpy(server);
}
foreach (cs, c_servers) if (!strcasecmp(cast_const_char cs->server, cast_const_char server)) {
if (cs->accpt) goto ok;
else {
free_cookie(cookie);
mem_free(cookie);
mem_free(server);
return 0;
}
}
if (accept_cookies != ACCEPT_ALL) {
free_cookie(cookie);
mem_free(cookie);
mem_free(server);
return 1;
}
ok:
accept_cookie(cookie);
mem_free(server);
return 0;
}
int main() {
/*---------- Initialized Server Variables ----------*/
char* the_host_name = malloc(MAX_HOST_NAME*sizeof(char));
the_host_name = get_host_name();
unsigned short port_number = get_port_num();
int socket;
/*===== End of Initialized Server Vairables ======*/
/*---------- Initial User Input Variables ----------*/
size_t n;
size_t max = 40;
char *buff;
/*===== End of Initial User Input Variables ======*/
int t;
/*---------- Program Loop ----------*/
printf("Enter a nickname: ");
while (fgets(buff,max,stdin)) {
//Gets the length of the buffer
n = strlen(buff);
//Gets a connection
if ((socket = call_socket(the_host_name, port_number)) < 0) {
perror("call_socket");
exit(0);
}
//Checks if the user inputs a blank string
if ( n==1 && buff[n-1] == '\n') {
//sends an exit command
if( write_data(socket, "\0", MAX_BUFFER_SIZE) < 0) {
prompt_error("Write Data Failed");
close(socket);
exit(0);
}
//exits
break;
} else {
//If the user doesnt enter a blank string -> Server request routine
if (write_data(socket, buff, MAX_BUFFER_SIZE) < 0) {
prompt_error("Write Data Failed");
close(socket);
exit(0);
} else {
printf("Write data success!!\n");
}
if (read_data(socket, buff, MAX_BUFFER_SIZE) < 0) {
prompt_error("Read Data Failed");
close(socket);
exit(0);
} else {
printf("Data read success.............. \n ");
}
printf("The server responded with: %s\n", buff);
close(socket);
}
printf("Enter a nickname: ");
}
/*===== End of Program Loop ======*/
/*---------- Ending Program ----------*/
printf("Ending client program......................\n");
free(the_host_name);
close(socket);
return 0;
/*===== End of Ending Programs ======*/
}
