void free_query_str(query_str_t *qs) {
qs_missing_block_t *mb;
qs_missing_block_t *next_mb;
qs_missing_symbol_t *ms;
qs_missing_symbol_t *next_ms;
if(qs->fileURI != NULL) {
free_uri(qs->fileURI);
}
if(qs->block_list != NULL) {
next_mb = qs->block_list;
while(next_mb != NULL) {
mb = next_mb;
next_ms = mb->es_list;
while(next_ms != NULL) {
ms = next_ms;
next_ms = ms->next;
free(ms);
}
next_mb = mb->next;
free(mb);
}
}
if(qs != NULL) {
free(qs);
}
}
int
parse_uri(regex_t * preg, char * full_uri, struct URI ** uri)
{
int ret;
char *colon;
long long port;
size_t nmatch = 10;
regmatch_t pmatch[10];
if (0 != (ret = regexec(preg, full_uri, nmatch, pmatch, 0)))
return ret;
*uri = au_malloc(sizeof(struct URI));
if(NULL == *uri)
return -200;
(*uri)->full_uri = strdup(full_uri);
asprintf(&((*uri)->scheme), "%.*s",pmatch[2].rm_eo - pmatch[2].rm_so, &full_uri[pmatch[2].rm_so]);
asprintf(&((*uri)->host_and_port), "%.*s",pmatch[4].rm_eo - pmatch[4].rm_so, &full_uri[pmatch[4].rm_so]);
asprintf(&((*uri)->path), "%.*s",pmatch[5].rm_eo - pmatch[5].rm_so, &full_uri[pmatch[5].rm_so]);
asprintf(&((*uri)->path_and_more), "%.*s",pmatch[9].rm_eo - pmatch[5].rm_so, &full_uri[pmatch[5].rm_so]);
asprintf(&((*uri)->query), "%.*s",pmatch[7].rm_eo - pmatch[7].rm_so, &full_uri[pmatch[7].rm_so]);
asprintf(&((*uri)->fragment), "%.*s",pmatch[9].rm_eo - pmatch[9].rm_so, &full_uri[pmatch[9].rm_so]);
colon = strrchr((*uri)->host_and_port, ':');
if(NULL == colon)
{
(*uri)->host = strdup((*uri)->host_and_port);
/*if(0 == strcasecmp("http", uri->scheme))
{
uri->port = 80;
asprintf(&(uri->host_and_port_for_connecting), "%s:80", uri->host_and_port);
}
else if(0 == strcasecmp("https", uri->scheme))
{
uri->port = 443;
asprintf(&(uri->host_and_port_for_connecting), "%s:443", uri->host_and_port);
}
else
{
PRINT_INFO("no standard scheme!");
*/(*uri)->port = 0;
/*uri->host_and_port_for_connecting = strdup(uri->host_and_port);
}*/
return 0;
}
port = atoi(colon + 1);
if(port<1 || port >= 256 * 256)
{
free_uri(*uri);
return -100;
}
(*uri)->port = port;
asprintf(&((*uri)->host), "%.*s", (int)(colon - (*uri)->host_and_port), (*uri)->host_and_port);
return 0;
}
void
free_proxy(struct Proxy *proxy)
{
//PRINT_INFO("free proxy called");
free(proxy->http_body);
free_uri(proxy->uri);
free(proxy->url);
free(proxy->http_uri);
free(proxy);
}
int main(int argc, char **argv)
{
char *str, *ostr;
int ret;
uri *parsed_uri;
/* initialize the URI structure - this needs pointers set to NULL to
be correct! */
parsed_uri = malloc(sizeof(uri));
if(parsed_uri == NULL) {
fprintf(stderr, "Unable to allocate space on the heap for a URI\n");
}
parsed_uri->host_is_ip = 0;
parsed_uri->port = -1;
parsed_uri->scheme = NULL;
parsed_uri->userinfo = NULL;
parsed_uri->host = NULL;
parsed_uri->path = NULL;
parsed_uri->query = NULL;
parsed_uri->fragment = NULL;
/* read a string from the user */
str = ostr = calloc(MAX_INPUT+1, 1);
if(str == NULL) {
printf("Unable to allocate string storage space.\n");
return 1;
}
printf("Please enter a URI:\n");
fgets(str, MAX_INPUT, stdin);
printf("Processing %d byte string...\n", (int)strlen(str));
ret = run_fsm(uri_reference_fsm, &str, (void**)&parsed_uri, duplicate_uri, free_uri);
if(ret < 0) {
printf("Unable to execute FSM on string: %s\n", str);
} else {
printf("URI scheme: %s\n", parsed_uri->scheme);
printf("URI userinfo: %s\n", parsed_uri->userinfo);
printf("URI host: %s\n", parsed_uri->host);
printf(" Is host an IP address?: %s\n", (parsed_uri->host_is_ip) ? "yes" : "no");
printf("URI port: %d\n", parsed_uri->port);
printf("URI path: %s\n", parsed_uri->path);
printf("URI query: %s\n", parsed_uri->query);
printf("URI fragment: %s\n", parsed_uri->fragment);
printf("\nFSM Done - processed %d characters: \"%.*s\".\n", ret, ret, ostr);
}
free_uri(parsed_uri);
free(ostr);
return 0;
}
// We should only have entries on the writeq if we're tearing down the session
// following an error. Prior to calling prep_icap_state(), everything should be
// zeroed out, just as it is immediately following the initial Malloc(),
// UNLESS prep_icap_state() explicitly sets it (in which case it's a dontcare).
int reset_icap_state(icap_state *is){
int ret = 0;
if(is){
if(is->method != ICAP_METHOD_COUNT){
bitch("incomplete process for %s\n",name_icap_method(is->method));
inc_method_inc(&is->method);
}
free_uri(&is->icapuri);
free_icap_reqheaders(&is->headers);
ret |= freegzip_state(is);
ret |= free_icap_encapsulates(&is->encaps);
Free(is->respheaders);
is->respheaders = NULL;
reset_writeq(&is->wq);
is->status = 0;
is->statevec = 0;
ret |= prep_icap_state(is);
}
return ret;
}
static int
parse_icap_startline(char *line,struct pollfd_state *pfd,icap_status *istat){
icap_state *is = get_pfd_icap(pfd);
const char *method;
is->method = parse_method(&line);
if(is->method == ICAP_METHOD_COUNT){
*istat = ICAPSTATUS_METHOD_NOT_IMPLEMENTED;
return -1;
}
if((method = name_icap_method(is->method)) == NULL){
bitch("Couldn't stringize method %d\n",is->method);
*istat = ICAPSTATUS_INTERNAL_ERROR;
return -1;
}
// nag("Valid method: %s\n",method);
inc_method_begun(is->method);
if((is->icapuri = extract_uri(ICAP_URI_SCHEME,&line)) == NULL){
*istat = ICAPSTATUS_BAD_REQUEST;
return -1;
}
if(verify_icap_uri(is->icapuri,is)){
bitch("Bad URI for %s\n",method);
free_uri(&is->icapuri);
*istat = ICAPSTATUS_METHOD_BAD_SERVICE;
return -1;
}
if(parse_icap_version(&line)){
*istat = ICAPSTATUS_VERSION_NOT_SUPPORTED;
return -1;
}
if(strcmp(line,CRLF)){
bitch("Excess data after ICAP version (%zu/%zu)\n",
strlen(line),__builtin_strlen(CRLF));
*istat = ICAPSTATUS_BAD_REQUEST;
return -1;
}
return 0;
}
int new_ciodev( char* uri_str , ciostrm_req* properties, struct ciodev_s** ciodev_o )
{
uri* uri_parsed;
int result = parse_uri(uri_str, &uri_parsed);
if(result){
return result;
}
//For the moment, require all URIs to have a valid scheme and hierarchical part
//TODO: infer the scheme from the hierarchical part eg -> example.ring where possible
if( !uri_parsed->scheme_name_len || !uri_parsed->hierarchical_len){
return CIO_EBADURI;
}
//Find the channel that has the same scheme name
cio_channel_entry* entry = cio_channel_registry;
for(; entry->scheme; ++entry){
if(strncmp(entry->scheme, uri_parsed->scheme_name, uri_parsed->scheme_name_len) == 0){
break;
}
}
//Could not find the channel name type
if(!entry->scheme){
return CIO_ENOCHANNEL;
}
result = entry->strm_new_ciodev(uri_parsed, ciodev_o, &entry->global_data);
//TODO XXX: Check properties here
(void)properties;
free_uri(&uri_parsed);
return result;
}
int modify_url_cookie_for_safe_search(char **url, const char *cookie, char **new_cookie,
const SiteInfoType *si) {
uri *u;
char *urls, *urls2;
int is_google = 0, is_yahoo = 0, is_msn = 0, is_alltheweb = 0, is_altavista = 0, is_a9 = 0, is_bing = 0, is_known = 0;
int url_modified = 0;
ustring us = USTRING_INITIALIZER;
if(cookie) {
if(!new_cookie) {
bitch("Passed cookie but no pointer for rewritten cookie\n");
return 0;
}
*new_cookie = 0;
}
urls = urls2 = Strdup(*url);
u = extract_uri(0, &urls);
Free(urls2);
if(!u) {
nag("URI extraction failed\n");
return 0;
}
if(u->host) {
if(strcasestr(u->host, "google.") && !strcasestr(u->host, "maps.google.")) {
is_google = is_known = 1;
} else if(strcasestr(u->host, "yahoo.")) {
is_yahoo = is_known = 1;
} else if(strcasestr(u->host, ".msn.") || strcasestr(u->host, "search.live.")) {
is_msn = is_known = 1;
} else if(strcasestr(u->host, "alltheweb.")) {
is_alltheweb = is_known = 1;
} else if(strcasestr(u->host, "altavista.")) {
is_altavista = is_known = 1;
} else if(strcasestr(u->host, "a9.")) {
is_a9 = is_known = 1;
} else if(strcasestr(u->host, ".bing.com")) {
is_bing = is_known = 1;
}
// xxx WW uses some additional heuristics here based on category information and the presence of certain strings in the cookie
if(!is_known) {
size_t i;
int is_ip = 1;
for(i = 0; i < strlen(u->host); i++) {
if(isalpha(((const unsigned char *)u->host)[i])) {
is_ip = 0;
break;
}
}
if(is_ip && u->query && is_search_engine(si)) {
if(strncmp(u->query, "q=", 2) == 0 || strstr(u->query, "&q=")) {
is_google = is_known = 1;
} else if(strncmp(u->query, "p=", 2) == 0 || strstr(u->query, "&p=")) {
is_yahoo = is_known = 1;
}
}
}
}
if(is_google && u->query) {
url_modified = process_google_query(&(u->query));
} else if(is_yahoo && u->query) {
url_modified = process_yahoo_query(&(u->query), u->path);
} else if(is_msn && cookie) {
process_msn_cookie(cookie, new_cookie);
} else if(is_alltheweb && cookie) {
process_alltheweb_cookie(cookie, new_cookie);
if(new_cookie) {
url_modified = process_alltheweb_query(&(u->query));
}
} else if(is_altavista && cookie) {
process_altavista_cookie(cookie, new_cookie);
if(new_cookie) {
url_modified = process_altavista_query(&(u->query));
}
} else if(is_bing && u->query) {
url_modified = process_bing_query(&(u->query));
}
if(url_modified) {
char *newurl;
if(stringize_uri(&us,u) < 0) {
nag("Error stringizing uri\n");
free_uri(&u);
return 0;
}
newurl = Strdup(us.string);
reset_ustring(&us);
if(!newurl) {
free_uri(&u);
return 0;
}
Free(*url);
*url = newurl;
nag("modified URL\n");
}
free_uri(&u);
return url_modified;
}
int encode_file(char *file, char *base_dir, FILE *fp, int *s_id) {
char fullname[MAX_PATH_LENGTH];
char fullpath[MAX_PATH_LENGTH];
#ifdef _MSC_VER
struct __stat64 file_stats;
#else
struct stat64 file_stats;
#endif
int i;
uri_t *uri = NULL;
char *hostname = NULL;
alc_session_t *s = get_alc_session(*s_id);
char *user = NULL;
char *uri_str = NULL;
#ifdef USE_ZLIB
int retcode;
char enc_fullpath[MAX_PATH_LENGTH];
#ifdef _MSC_VER
struct __stat64 enc_file_stats;
#else
struct stat64 enc_file_stats;
#endif
#endif
#ifdef USE_OPENSSL
char *md5 = NULL;
#endif
#ifdef FDT_INST_FEC_OTI_FILE
div_t div_max_n;
int max_n;
div_max_n = div((s->def_max_sblen * (100 + s->def_fec_ratio)), 100);
max_n = div_max_n.quot;
#endif
unsigned long long padding_length;
#ifdef _MSC_VER
user = getenv("USERNAME");
#else
user = getenv("USER");
#endif
memset(fullpath, 0, MAX_PATH_LENGTH);
if(!(strcmp(base_dir, "") == 0)) {
strcpy(fullpath, base_dir);
#ifdef _MSC_VER
strcat(fullpath, "\\");
#else
strcat(fullpath, "/");
#endif
}
strcat(fullpath, file);
#ifdef _MSC_VER
if(_stat64(fullpath, &file_stats) == -1) {
#else
if(stat64(fullpath, &file_stats) == -1) {
#endif
printf("Error: %s is not valid file name\n", fullpath);
fflush(stdout);
return -1;
}
if(file_stats.st_size == 0) {
printf("Error: file %s size = 0\n", fullpath);
fflush(stdout);
return -1;
}
hostname = getdnsname();
memset(fullname, 0, MAX_PATH_LENGTH);
strcpy(fullname, file);
for(i = 0; i < (int)strlen(fullname); i++) {
if(fullname[i] == '\\') {
fullname[i] = '/';
}
}
uri = alloc_uri_struct();
set_uri_scheme(uri, "file");
if(user != NULL) {
set_uri_user(uri, user);
}
#ifdef HOSTNAME_TO_FDT
if(hostname != NULL) {
set_uri_host(uri, hostname);
}
#endif
set_uri_path(uri, fullname);
#ifdef _MSC_VER
fprintf(fp, "\t<File TOI=\"%I64u\"", toi);
#else
fprintf(fp, "\t<File TOI=\"%llu\"", toi);
#endif
uri_str = uri_string(uri);
fprintf(fp, "\n\t\t");
fprintf(fp, "Content-Location=\"%s\"", uri_str);
free(uri_str);
fprintf(fp, "\n\t\t");
fprintf(fp, "Content-Length=\"%llu\"", file_stats.st_size);
if(s->encode_content == 0 || s->encode_content == ZLIB_FDT) {
if(is_enough_source_block_numbers(s->def_max_sblen, s->def_eslen, file_stats.st_size,
s->def_fec_enc_id, s->def_fec_inst_id) < 0) {
printf("Maximum source block length %i too small for the file: %s\n", s->def_max_sblen, file);
fflush(stdout);
if(hostname != NULL) {
free(hostname);
}
free_uri(uri);
return -1;
}
}
if(s->encode_content == PAD_FILES) {
padding_length = compute_padding_length(file_stats.st_size, s->def_max_sblen, s->def_eslen);
if(padding_length) {
fprintf(fp, "\n\t\t");
fprintf(fp, "Content-Encoding=\"%s\"", "pad");
fprintf(fp, "\n\t\t");
fprintf(fp, "Transfer-Length=\"%llu\"", (file_stats.st_size + padding_length));
}
if(is_enough_source_block_numbers(s->def_max_sblen, s->def_eslen, (file_stats.st_size + padding_length),
s->def_fec_enc_id, s->def_fec_inst_id) < 0) {
printf("Maximum source block length %i too small for the file: %s\n", s->def_max_sblen, file);
fflush(stdout);
if(hostname != NULL) {
free(hostname);
}
free_uri(uri);
return -1;
}
}
#ifdef USE_ZLIB
else if(s->encode_content == ZLIB_FDT_AND_GZIP_FILES) {
retcode = file_gzip_compress(fullpath, "wb");
if(retcode == 0) {
fprintf(fp, "\n\t\t");
fprintf(fp, "Content-Encoding=\"%s\"", "gzip");
memset(enc_fullpath, 0 , MAX_PATH_LENGTH);
strcpy(enc_fullpath, fullpath);
strcat(enc_fullpath, GZ_SUFFIX);
#ifdef _MSC_VER
if(_stat64(enc_fullpath, &enc_file_stats) == -1) {
#else
if(stat64(enc_fullpath, &enc_file_stats) == -1) {
#endif
printf("Error: %s is not valid file name\n", enc_fullpath);
fflush(stdout);
if(hostname != NULL) {
free(hostname);
}
free_uri(uri);
return -1;
}
#ifdef USE_OPENSSL
if(s->calculate_session_size == FALSE) {
md5 = file_md5(enc_fullpath);
if(md5 == NULL) {
if(hostname != NULL) {
free(hostname);
}
free_uri(uri);
return -1;
}
fprintf(fp, "\n\t\t");
fprintf(fp, "Content-MD5=\"%s\"", md5);
}
#endif
fprintf(fp, "\n\t\t");
fprintf(fp, "Transfer-Length=\"%llu\"", enc_file_stats.st_size);
if(is_enough_source_block_numbers(s->def_max_sblen, s->def_eslen, enc_file_stats.st_size,
s->def_fec_enc_id, s->def_fec_inst_id) < 0) {
printf("Maximum source block length %i too small for the file: %s\n", s->def_max_sblen, file);
fflush(stdout);
if(hostname != NULL) {
free(hostname);
}
free_uri(uri);
return -1;
}
}
}
#endif
else {
#ifdef USE_OPENSSL
if(s->calculate_session_size == FALSE) {
md5 = file_md5(fullpath);
if(md5 == NULL) {
if(hostname != NULL) {
free(hostname);
}
free_uri(uri);
return -1;
}
fprintf(fp, "\n\t\t");
fprintf(fp, "Content-MD5=\"%s\"", md5);
}
#endif
}
#ifdef FDT_INST_FEC_OTI_FILE
if(!s->use_fec_oti_ext_hdr) {
fprintf(fp, "\n\t\t");
fprintf(fp, "FEC-OTI-FEC-Encoding-ID=\"%u\"", s->def_fec_enc_id);
if(s->def_fec_enc_id >= 128) {
fprintf(fp, "\n\t\t");
fprintf(fp, "FEC-OTI-FEC-Instance-ID=\"%u\"", s->def_fec_inst_id);
}
if(s->def_fec_enc_id == RS_FEC_ENC_ID) {
fprintf(fp, "\n\t");
fprintf(fp, "FEC-OTI-Finite-Field-Parameter=\"%u\"", GF_BITS);
fprintf(fp, "\n\t");
fprintf(fp, "FEC-OTI-Number-of-Encoding-Symbols-per-Group=\"%u\"", 1);
}
fprintf(fp, "\n\t\t");
fprintf(fp, "FEC-OTI-Maximum-Source-Block-Length=\"%u\"", s->def_max_sblen);
fprintf(fp, "\n\t\t");
fprintf(fp, "FEC-OTI-Encoding-Symbol-Length=\"%u\"", s->def_eslen);
if(s->def_fec_enc_id == SB_SYS_FEC_ENC_ID) {
fprintf(fp, "\n\t\t");
fprintf(fp, "FEC-OTI-Max-Number-of-Encoding-Symbols=\"%u\"", max_n);
}
}
#endif
fprintf(fp, "/>\n");
toi++;
free_uri(uri);
#ifdef USE_OPENSSL
if(s->calculate_session_size == FALSE) {
free(md5);
}
#endif
if(hostname != NULL) {
free(hostname);
}
return 0;
}
/**
* This is a private function which parses directory to the FDT.
*
* @param directory directory to be parsed
* @param base_dir base directory for file to be parsed to the FDT
* @param fp file pointer to the generated FDT
* @param s_id session identifier
*
* @return 0 in success, -1 otherwise
*
*/
int encode_directory(char *directory, char *base_dir, FILE *fp, int *s_id) {
int result;
char fullname[MAX_PATH_LENGTH];
char fullpath[MAX_PATH_LENGTH];
#ifdef _MSC_VER
struct __stat64 file_stats;
#else
struct stat64 file_stats;
#endif
uri_t *uri = NULL;
char *hostname = NULL;
alc_session_t *s = NULL;
char *user = NULL;
#ifdef USE_ZLIB
int retcode;
char enc_fullpath[MAX_PATH_LENGTH];
#ifdef _MSC_VER
struct __stat64 enc_file_stats;
#else
struct stat64 enc_file_stats;
#endif
#endif
#ifdef USE_OPENSSL
char *md5 = NULL;
#endif
#ifdef _MSC_VER
int i;
char findfile[MAX_PATH_LENGTH + 3];
HANDLE dirptr = NULL;
WIN32_FIND_DATA entry;
#else
struct dirent *entry;
DIR *dirptr = NULL;
char findfile[MAX_PATH_LENGTH];
#endif
#ifdef FDT_INST_FEC_OTI_FILE
div_t div_max_n;
int max_n;
#endif
char *uri_str = NULL;
hostname = getdnsname();
s = get_alc_session(*s_id);
#ifdef FDT_INST_FEC_OTI_FILE
div_max_n = div((s->def_max_sblen * (100 + s->def_fec_ratio)), 100);
max_n = div_max_n.quot;
#endif
#ifdef _MSC_VER
user = getenv("USERNAME");
memset(findfile, 0, (MAX_PATH_LENGTH + 3));
if(!(strcmp(base_dir, "") == 0)) {
strcpy(findfile, base_dir);
strcat(findfile, "\\");
}
strcat(findfile, directory);
strcat(findfile, "\\*");
dirptr = FindFirstFile(findfile, &entry);
if(dirptr == INVALID_HANDLE_VALUE) {
printf("Error: %s is not valid directory name\n", directory);
fflush(stdout);
free(hostname);
return -1;
}
if(!checkpath(entry.cFileName)) {
memset(fullname, 0 , MAX_PATH_LENGTH);
strcpy(fullname, directory);
if(fullname[strlen(fullname) - 1] != '\\') {
strcat(fullname, "\\");
}
strcat(fullname, entry.cFileName);
for(i = 0; i < (int)strlen(fullname); i++) {
if(fullname[i] == '\\') {
fullname[i] = '/';
}
}
if(entry.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
result = encode_directory(fullname, base_dir, fp, s_id);
if(result < 0) {
free(hostname);
return -1;
}
}
else {
memset(fullpath, 0, MAX_PATH_LENGTH);
if(!(strcmp(base_dir, "") == 0)) {
strcpy(fullpath, base_dir);
strcat(fullpath, "\\");
}
strcat(fullpath, fullname);
#ifdef _MSC_VER
if(_stat64(fullpath, &file_stats) == -1) {
#else
if(stat64(fullpath, &file_stats) == -1) {
#endif
printf("Error: %s is not valid file name\n", fullpath);
fflush(stdout);
free(hostname);
return -1;
}
if(file_stats.st_size == 0) {
printf("Error: file %s size = 0\n", fullpath);
fflush(stdout);
free(hostname);
return -1;
}
uri = alloc_uri_struct();
set_uri_scheme(uri, "file");
if(user != NULL) {
set_uri_user(uri, user);
}
#ifdef HOSTNAME_TO_FDT
if(hostname != NULL) {
set_uri_host(uri, hostname);
}
#endif
set_uri_path(uri, fullname);
fprintf(fp, "\t<File TOI=\"%I64u\"", toi);
uri_str = uri_string(uri);
fprintf(fp, "\n\t\t");
fprintf(fp, "Content-Location=\"%s\"", uri_str);
free(uri_str);
uri_str = NULL;
fprintf(fp, "\n\t\t");
fprintf(fp, "Content-Length=\"%llu\"", file_stats.st_size);
if(s->encode_content == PAD_FILES) {
if(compute_padding_length(file_stats.st_size, s->def_max_sblen, s->def_eslen)) {
fprintf(fp, "\n\t\t");
fprintf(fp, "Content-Encoding=\"%s\"", "pad");
fprintf(fp, "\n\t\t");
fprintf(fp, "Transfer-Length=\"%llu\"", compute_padding_length(file_stats.st_size, s->def_max_sblen, s->def_eslen) + file_stats.st_size);
}
/* Not possible to use, because padded file is not in the hard disk in the sender side
#ifdef USE_OPENSSL
if(s->calculate_session_size == FALSE) {
md5 = file_md5(fullpath);
if(md5 == NULL) {
free(hostname);
free_uri(uri);
return -1;
}
fprintf(fp, "\n\t\t");
fprintf(fp, "Content-MD5=\"%s\"", md5);
}
#endif
*/
}
#ifdef USE_ZLIB
else if(s->encode_content == ZLIB_FDT_AND_GZIP_FILES) {
retcode = file_gzip_compress(fullpath, "wb");
if(retcode == 0) {
memset(enc_fullpath, 0 , MAX_PATH_LENGTH);
strcpy(enc_fullpath, fullpath);
strcat(enc_fullpath, GZ_SUFFIX);
#ifdef _MSC_VER
if(_stat64(enc_fullpath, &enc_file_stats) == -1) {
#else
if(stat64(enc_fullpath, &enc_file_stats) == -1) {
#endif
printf("Error: %s is not valid file name\n", enc_fullpath);
fflush(stdout);
free(hostname);
free_uri(uri);
return -1;
}
fprintf(fp, "\n\t\t");
fprintf(fp, "Content-Encoding=\"%s\"", "gzip");
#ifdef USE_OPENSSL
if(s->calculate_session_size == FALSE) {
md5 = file_md5(enc_fullpath);
if(md5 == NULL) {
free(hostname);
free_uri(uri);
return -1;
}
fprintf(fp, "\n\t\t");
fprintf(fp, "Content-MD5=\"%s\"", md5);
}
#endif
fprintf(fp, "\n\t\t");
fprintf(fp, "Transfer-Length=\"%llu\"", enc_file_stats.st_size);
}
}
#endif
else {
#ifdef USE_OPENSSL
if(s->calculate_session_size == FALSE) {
md5 = file_md5(fullpath);
if(md5 == NULL) {
free(hostname);
free_uri(uri);
return -1;
}
fprintf(fp, "\n\t\t");
fprintf(fp, "Content-MD5=\"%s\"", md5);
}
#endif
}
#ifdef FDT_INST_FEC_OTI_FILE
if(!s->use_fec_oti_ext_hdr) {
fprintf(fp, "\n\t\t");
fprintf(fp, "FEC-OTI-FEC-Encoding-ID=\"%u\"", s->def_fec_enc_id);
if(s->def_fec_enc_id >= 128) {
fprintf(fp, "\n\t\t");
fprintf(fp, "FEC-OTI-FEC-Instance-ID=\"%u\"", s->def_fec_inst_id);
}
if(s->def_fec_enc_id == RS_FEC_ENC_ID) {
fprintf(fp, "\n\t");
fprintf(fp, "FEC-OTI-Finite-Field-Parameter=\"%u\"", GF_BITS);
fprintf(fp, "\n\t");
fprintf(fp, "FEC-OTI-Number-of-Encoding-Symbols-per-Group=\"%u\"", 1);
}
fprintf(fp, "\n\t\t");
fprintf(fp, "FEC-OTI-Maximum-Source-Block-Length=\"%u\"", s->def_max_sblen);
fprintf(fp, "\n\t\t");
fprintf(fp, "FEC-OTI-Encoding-Symbol-Length=\"%u\"", s->def_eslen);
if(s->def_fec_enc_id == RS_FEC_ENC_ID || s->def_fec_enc_id == SB_SYS_FEC_ENC_ID) {
fprintf(fp, "\n\t\t");
fprintf(fp, "FEC-OTI-Max-Number-of-Encoding-Symbols=\"%u\"", max_n);
}
}
#endif
fprintf(fp, "/>\n");
toi++;
free_uri(uri);
#ifdef USE_OPENSSL
free(md5);
md5 = NULL;
#endif
}
}
while(FindNextFile(dirptr, &entry)) {
if(checkpath(entry.cFileName)) {
continue;
}
memset(fullname, 0 , MAX_PATH_LENGTH);
strcpy(fullname, directory);
if(fullname[strlen(fullname) - 1] != '\\') {
strcat(fullname, "\\");
}
strcat(fullname, entry.cFileName);
for(i = 0; i < (int)strlen(fullname); i++) {
if(fullname[i] == '\\') {
fullname[i] = '/';
}
}
if(entry.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
result = encode_directory(fullname, base_dir, fp, s_id);
if(result < 0) {
continue;
}
}
else {
memset(fullpath, 0, MAX_PATH_LENGTH);
if(!(strcmp(base_dir, "") == 0)) {
strcpy(fullpath, base_dir);
strcat(fullpath, "\\");
}
strcat(fullpath, fullname);
#ifdef _MSC_VER
if(_stat64(fullpath, &file_stats) == -1) {
#else
if(stat64(fullpath, &file_stats) == -1) {
#endif
printf("Error: %s is not valid file name\n", fullpath);
fflush(stdout);
continue;
}
if(file_stats.st_size == 0) {
printf("Error: file %s size = 0\n", fullpath);
fflush(stdout);
continue;
}
uri = alloc_uri_struct();
set_uri_scheme(uri, "file");
if(user != NULL) {
set_uri_user(uri, user);
}
#ifdef HOSTNAME_TO_FDT
if(hostname != NULL) {
set_uri_host(uri, hostname);
}
#endif
set_uri_path(uri, fullname);
fprintf(fp, "\t<File TOI=\"%I64u\"", toi);
uri_str = uri_string(uri);
fprintf(fp, "\n\t\t");
fprintf(fp, "Content-Location=\"%s\"", uri_str);
free(uri_str);
uri_str = NULL;
fprintf(fp, "\n\t\t");
fprintf(fp, "Content-Length=\"%llu\"", file_stats.st_size);
if(s->encode_content == PAD_FILES) {
if(compute_padding_length(file_stats.st_size, s->def_max_sblen, s->def_eslen)) {
fprintf(fp, "\n\t\t");
fprintf(fp, "Content-Encoding=\"%s\"", "pad");
fprintf(fp, "\n\t\t");
fprintf(fp, "Transfer-Length=\"%llu\"", compute_padding_length(file_stats.st_size, s->def_max_sblen, s->def_eslen) + file_stats.st_size);
}
}
#ifdef USE_ZLIB
else if(s->encode_content == ZLIB_FDT_AND_GZIP_FILES) {
retcode = file_gzip_compress(fullpath, "wb");
if(retcode == 0) {
memset(enc_fullpath, 0 , MAX_PATH_LENGTH);
strcpy(enc_fullpath, fullpath);
strcat(enc_fullpath, GZ_SUFFIX);
#ifdef _MSC_VER
if(_stat64(enc_fullpath, &enc_file_stats) == -1) {
#else
if(stat64(enc_fullpath, &enc_file_stats) == -1) {
#endif
printf("Error: %s is not valid file name\n", enc_fullpath);
fflush(stdout);
free_uri(uri);
continue;
}
fprintf(fp, "\n\t\t");
fprintf(fp, "Content-Encoding=\"%s\"", "gzip");
#ifdef USE_OPENSSL
if(s->calculate_session_size == FALSE) {
md5 = file_md5(enc_fullpath);
if(md5 == NULL) {
free(hostname);
free_uri(uri);
continue;
}
fprintf(fp, "\n\t\t");
fprintf(fp, "Content-MD5=\"%s\"", md5);
}
#endif
fprintf(fp, "\n\t\t");
fprintf(fp, "Transfer-Length=\"%llu\"", enc_file_stats.st_size);
}
}
#endif
else {
#ifdef USE_OPENSSL
if(s->calculate_session_size == FALSE) {
md5 = file_md5(fullpath);
if(md5 == NULL) {
free(hostname);
free_uri(uri);
continue;
}
fprintf(fp, "\n\t\t");
fprintf(fp, "Content-MD5=\"%s\"", md5);
}
#endif
}
#ifdef FDT_INST_FEC_OTI_FILE
if(!s->use_fec_oti_ext_hdr) {
fprintf(fp, "\n\t\t");
fprintf(fp, "FEC-OTI-FEC-Encoding-ID=\"%u\"", s->def_fec_enc_id);
if(s->def_fec_enc_id >= 128) {
fprintf(fp, "\n\t\t");
fprintf(fp, "FEC-OTI-FEC-Instance-ID=\"%u\"", s->def_fec_inst_id);
}
if(s->def_fec_enc_id == RS_FEC_ENC_ID) {
fprintf(fp, "\n\t");
fprintf(fp, "FEC-OTI-Finite-Field-Parameter=\"%u\"", GF_BITS);
fprintf(fp, "\n\t");
fprintf(fp, "FEC-OTI-Number-of-Encoding-Symbols-per-Group=\"%u\"", 1);
}
fprintf(fp, "\n\t\t");
fprintf(fp, "FEC-OTI-Maximum-Source-Block-Length=\"%u\"", s->def_max_sblen);
fprintf(fp, "\n\t\t");
fprintf(fp, "FEC-OTI-Encoding-Symbol-Length=\"%u\"", s->def_eslen);
if(s->def_fec_enc_id == RS_FEC_ENC_ID || s->def_fec_enc_id == SB_SYS_FEC_ENC_ID) {
fprintf(fp, "\n\t\t");
fprintf(fp, "FEC-OTI-Max-Number-of-Encoding-Symbols=\"%u\"", max_n);
}
}
#endif
fprintf(fp, "/>\n");
toi++;
free_uri(uri);
#ifdef USE_OPENSSL
if(s->calculate_session_size == FALSE) {
free(md5);
md5 = NULL;
}
#endif
}
}
FindClose(dirptr);
#else
user = getenv("USER");
memset(findfile, 0, MAX_PATH_LENGTH);
if(!(strcmp(base_dir, "") == 0)) {
strcpy(findfile, base_dir);
strcat(findfile, "/");
}
strcat(findfile, directory);
dirptr = opendir(findfile);
if(dirptr == NULL) {
printf("%s is not valid directory name\n", findfile);
fflush(stdout);
free(hostname);
return -1;
}
entry = readdir(dirptr);
while(entry != NULL) {
if(checkpath(entry->d_name)) {
entry = readdir(dirptr);
continue;
}
memset(fullname, 0 , MAX_PATH_LENGTH);
strcpy(fullname, directory);
if(fullname[strlen(fullname) - 1] != '/') {
strcat(fullname, "/");
}
strcat(fullname, entry->d_name);
memset(fullpath, 0, MAX_PATH_LENGTH);
if(!(strcmp(base_dir, "") == 0)) {
strcpy(fullpath, base_dir);
strcat(fullpath, "/");
}
strcat(fullpath, fullname);
if(stat64(fullpath, &file_stats) == -1) {
printf("Error: %s is not valid file name\n", fullpath);
fflush(stdout);
entry = readdir(dirptr);
continue;
}
if(S_ISDIR(file_stats.st_mode)) {
result = encode_directory(fullname, base_dir, fp, s_id);
if(result < 0) {
entry = readdir(dirptr);
continue;
}
}
else {
if(file_stats.st_size == 0) {
printf("Error: file %s size = 0\n", fullpath);
fflush(stdout);
entry = readdir(dirptr);
continue;
}
uri = alloc_uri_struct();
set_uri_scheme(uri, "file");
if(user != NULL) {
set_uri_user(uri, user);
}
#ifdef HOSTNAME_TO_FDT
if(hostname != NULL) {
set_uri_host(uri, hostname);
}
#endif
set_uri_path(uri, fullname);
fprintf(fp, "\t<File TOI=\"%llu\"", toi);
uri_str = uri_string(uri);
fprintf(fp, "\n\t\t");
fprintf(fp, "Content-Location=\"%s\"", uri_str);
free(uri_str);
uri_str = NULL;
fprintf(fp, "\n\t\t");
fprintf(fp, "Content-Length=\"%llu\"", file_stats.st_size);
if(s->encode_content == PAD_FILES) {
if(compute_padding_length(file_stats.st_size, s->def_max_sblen, s->def_eslen)) {
fprintf(fp, "\n\t\t");
fprintf(fp, "Content-Encoding=\"%s\"", "pad");
fprintf(fp, "\n\t\t");
fprintf(fp, "Transfer-Length=\"%llu\"", compute_padding_length(file_stats.st_size, s->def_max_sblen, s->def_eslen) + file_stats.st_size);
}
}
#ifdef USE_ZLIB
else if(s->encode_content == ZLIB_FDT_AND_GZIP_FILES) {
retcode = file_gzip_compress(fullpath, "wb");
if(retcode == 0) {
memset(enc_fullpath, 0 , MAX_PATH_LENGTH);
strcpy(enc_fullpath, fullpath);
strcat(enc_fullpath, GZ_SUFFIX);
if(stat64(enc_fullpath, &enc_file_stats) == -1) {
printf("Error: %s is not valid file name\n", enc_fullpath);
fflush(stdout);
entry = readdir(dirptr);
free_uri(uri);
continue;
}
fprintf(fp, "\n\t\t");
fprintf(fp, "Content-Encoding=\"%s\"", "gzip");
#ifdef USE_OPENSSL
if(s->calculate_session_size == FALSE) {
md5 = file_md5(enc_fullpath);
if(md5 == NULL) {
free_uri(uri);
continue;
}
fprintf(fp, "\n\t\t");
fprintf(fp, "Content-MD5=\"%s\"", md5);
}
#endif
fprintf(fp, "\n\t\t");
fprintf(fp, "Transfer-Length=\"%llu\"", enc_file_stats.st_size);
}
}
#endif
else {
#ifdef USE_OPENSSL
if(s->calculate_session_size == FALSE) {
md5 = file_md5(fullpath);
if(md5 == NULL) {
free_uri(uri);
continue;
}
fprintf(fp, "\n\t\t");
fprintf(fp, "Content-MD5=\"%s\"", md5);
}
#endif
}
#ifdef FDT_INST_FEC_OTI_FILE
if(!s->use_fec_oti_ext_hdr) {
fprintf(fp, "\n\t\t");
fprintf(fp, "FEC-OTI-FEC-Encoding-ID=\"%u\"", s->def_fec_enc_id);
if(s->def_fec_enc_id >= 128) {
fprintf(fp, "\n\t\t");
fprintf(fp, "FEC-OTI-FEC-Instance-ID=\"%u\"", s->def_fec_inst_id);
}
if(s->def_fec_enc_id == RS_FEC_ENC_ID) {
fprintf(fp, "\n\t");
fprintf(fp, "FEC-OTI-Finite-Field-Parameter=\"%u\"", GF_BITS);
fprintf(fp, "\n\t");
fprintf(fp, "FEC-OTI-Number-of-Encoding-Symbols-per-Group=\"%u\"", 1);
}
fprintf(fp, "\n\t\t");
fprintf(fp, "FEC-OTI-Maximum-Source-Block-Length=\"%u\"", s->def_max_sblen);
fprintf(fp, "\n\t\t");
fprintf(fp, "FEC-OTI-Encoding-Symbol-Length=\"%u\"", s->def_eslen);
if(s->def_fec_enc_id == RS_FEC_ENC_ID || s->def_fec_enc_id == SB_SYS_FEC_ENC_ID) {
fprintf(fp, "\n\t\t");
fprintf(fp, "FEC-OTI-Max-Number-of-Encoding-Symbols=\"%u\"", max_n);
}
}
#endif
fprintf(fp, "/>\n");
toi++;
free_uri(uri);
#ifdef USE_OPENSSL
if(s->calculate_session_size == FALSE) {
free(md5);
md5 = NULL;
}
#endif
}
entry = readdir(dirptr);
}
closedir(dirptr);
#endif
if(hostname != NULL) {
free(hostname);
}
if(toi == 1) {
return -1;
}
return 0;
}
int generate_fdt(char *file_token, char *base_dir, int *s_id, char *fdt_file_name,
int complete_fdt, int verbosity) {
int result;
FILE *fp;
#ifdef _MSC_VER
struct __stat64 file_stats;
#else
struct stat64 file_stats;
#endif
alc_session_t *s = NULL;
char fullpath[MAX_PATH_LENGTH];
#ifdef FDT_INST_FEC_OTI_COMMON
div_t div_max_n;
int max_n;
#endif
char *token;
if((fp = fopen(fdt_file_name, "wb")) == NULL) {
printf("Error: unable to create fdtfile %s\n", fdt_file_name);
fflush(stdout);
return -1;
}
s = get_alc_session(*s_id);
#ifdef FDT_INST_FEC_OTI_COMMON
div_max_n = div((s->def_max_sblen * (100 + s->def_fec_ratio)), 100);
max_n = div_max_n.quot;
#endif
toi = 1;
fprintf(fp, "<?xml version=\"1.0\" encoding=\"iso-8859-1\"?>\n");
fprintf(fp, "<FDT-Instance ");
#ifdef _MSC_VER
if(s->stoptime == 0) {
/* session is not bounded, set 64bits max value */
fprintf(fp, "Expires=\"%I64u\"", (unsigned long long)0xFFFFFFFFFFFFFFFF);
}
else {
fprintf(fp, "Expires=\"%I64u\"", s->stoptime);
}
#else
if(s->stoptime == 0) {
/* session is not bounded, set 64bits max value */
fprintf(fp, "Expires=\"%llu\"", 0xFFFFFFFFFFFFFFFFULL);
}
else {
fprintf(fp, "Expires=\"%llu\"", s->stoptime);
}
#endif
if(complete_fdt > 0) {
fprintf(fp, "\n\t");
fprintf(fp, "Complete=\"true\"");
}
#ifdef FDT_INST_FEC_OTI_COMMON
if(!s->use_fec_oti_ext_hdr) {
fprintf(fp, "\n\t");
fprintf(fp, "FEC-OTI-FEC-Encoding-ID=\"%u\"", s->def_fec_enc_id);
if(s->def_fec_enc_id >= 128) {
fprintf(fp, "\n\t");
fprintf(fp, "FEC-OTI-FEC-Instance-ID=\"%u\"", s->def_fec_inst_id);
}
if(s->def_fec_enc_id == RS_FEC_ENC_ID) {
fprintf(fp, "\n\t");
fprintf(fp, "FEC-OTI-Finite-Field-Parameter=\"%u\"", GF_BITS);
fprintf(fp, "\n\t");
fprintf(fp, "FEC-OTI-Number-of-Encoding-Symbols-per-Group=\"%u\"", 1);
}
fprintf(fp, "\n\t");
fprintf(fp, "FEC-OTI-Maximum-Source-Block-Length=\"%u\"", s->def_max_sblen);
fprintf(fp, "\n\t");
fprintf(fp, "FEC-OTI-Encoding-Symbol-Length=\"%u\"", s->def_eslen);
if(s->def_fec_enc_id == RS_FEC_ENC_ID || s->def_fec_enc_id == SB_SYS_FEC_ENC_ID) {
fprintf(fp, "\n\t");
fprintf(fp, "FEC-OTI-Max-Number-of-Encoding-Symbols=\"%u\"", max_n);
}
}
#endif
fprintf(fp, ">\n");
token = strtok(file_token, ",");
while(token != NULL) {
memset(fullpath, 0, (MAX_PATH_LENGTH));
if(!(strcmp(base_dir, "") == 0)) {
strcpy(fullpath, base_dir);
#ifdef _MSC_VER
strcat(fullpath, "\\");
#else
strcat(fullpath, "/");
#endif
}
strcat(fullpath, token);
#ifdef _MSC_VER
if(_stat64(fullpath, &file_stats) == -1) {
#else
if(stat64(fullpath, &file_stats) == -1) {
#endif
printf("Error: %s is not valid file name\n", fullpath);
fflush(stdout);
return -1;
}
if(file_stats.st_mode & S_IFDIR) {
result = encode_directory(token, base_dir, fp, s_id);
}
else {
result = encode_file(token, base_dir, fp, s_id);
}
if(result < 0) {
fclose(fp);
remove(fdt_file_name);
return -1;
}
token = strtok(NULL, ",");
}
fprintf(fp, "</FDT-Instance>\n");
if(verbosity == 4) {
printf("File: %s created\n", fdt_file_name);
}
fclose(fp);
return 0;
}
static void
standard_request_handler(void *cls,
struct SPDY_Request * request,
uint8_t priority,
const char *method,
const char *path,
const char *version,
const char *host,
const char *scheme,
struct SPDY_NameValue * headers)
{
(void)cls;
(void)priority;
(void)host;
(void)scheme;
struct Proxy *proxy;
int ret;
struct URI *uri;
struct SPDY_Session *session;
PRINT_VERBOSE2("received request for '%s %s %s'\n", method, path, version);
if(NULL == (proxy = malloc(sizeof(struct Proxy))))
DIE("No memory");
memset(proxy, 0, sizeof(struct Proxy));
session = SPDY_get_session_for_request(request);
assert(NULL != session);
proxy->session_alive = SPDY_get_cls_from_session(session);
assert(NULL != proxy->session_alive);
proxy->request = request;
if(NULL == (proxy->headers = SPDY_name_value_create()))
DIE("No memory");
if(glob_opt.transparent)
{
if(NULL != glob_opt.http_backend) //use always same host
ret = asprintf(&(proxy->url),"%s://%s%s", scheme, glob_opt.http_backend, path);
else //use host header
ret = asprintf(&(proxy->url),"%s://%s%s", scheme, host, path);
if(-1 == ret)
DIE("No memory");
ret = parse_uri(&uri_preg, proxy->url, &uri);
if(ret != 0)
DIE("parsing built uri failed");
}
else
{
ret = parse_uri(&uri_preg, path, &uri);
PRINT_INFO2("path %s '%s' '%s'", path, uri->scheme, uri->host);
if(ret != 0 || !strlen(uri->scheme) || !strlen(uri->host))
DIE("parsing received uri failed");
if(NULL != glob_opt.http_backend) //use backend host
{
ret = asprintf(&(proxy->url),"%s://%s%s", uri->scheme, glob_opt.http_backend, uri->path_and_more);
if(-1 == ret)
DIE("No memory");
}
else //use request path
if(NULL == (proxy->url = strdup(path)))
DIE("No memory");
}
free_uri(uri);
PRINT_VERBOSE2("curl will request '%s'", proxy->url);
SPDY_name_value_iterate(headers, &iterate_cb, proxy);
if(NULL == (proxy->curl_handle = curl_easy_init()))
{
PRINT_INFO("curl_easy_init failed");
abort();
}
if(glob_opt.curl_verbose)
CURL_SETOPT(proxy->curl_handle, CURLOPT_VERBOSE, 1);
CURL_SETOPT(proxy->curl_handle, CURLOPT_URL, proxy->url);
if(glob_opt.http10)
CURL_SETOPT(proxy->curl_handle, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_0);
CURL_SETOPT(proxy->curl_handle, CURLOPT_WRITEFUNCTION, curl_write_cb);
CURL_SETOPT(proxy->curl_handle, CURLOPT_WRITEDATA, proxy);
CURL_SETOPT(proxy->curl_handle, CURLOPT_HEADERFUNCTION, curl_header_cb);
CURL_SETOPT(proxy->curl_handle, CURLOPT_HEADERDATA, proxy);
CURL_SETOPT(proxy->curl_handle, CURLOPT_PRIVATE, proxy);
CURL_SETOPT(proxy->curl_handle, CURLOPT_HTTPHEADER, proxy->curl_headers);
CURL_SETOPT(proxy->curl_handle, CURLOPT_SSL_VERIFYPEER, 0L);
CURL_SETOPT(proxy->curl_handle, CURLOPT_SSL_VERIFYHOST, 0L);
if(glob_opt.ipv4 && !glob_opt.ipv6)
CURL_SETOPT(proxy->curl_handle, CURLOPT_IPRESOLVE, CURL_IPRESOLVE_V4);
else if(glob_opt.ipv6 && !glob_opt.ipv4)
CURL_SETOPT(proxy->curl_handle, CURLOPT_IPRESOLVE, CURL_IPRESOLVE_V6);
if(CURLM_OK != (ret = curl_multi_add_handle(multi_handle, proxy->curl_handle)))
{
PRINT_INFO2("curl_multi_add_handle failed (%i)", ret);
abort();
}
//~5ms additional latency for calling this
if(CURLM_OK != (ret = curl_multi_perform(multi_handle, &still_running))
&& CURLM_CALL_MULTI_PERFORM != ret)
{
PRINT_INFO2("curl_multi_perform failed (%i)", ret);
abort();
}
call_curl_run = true;
}
