"Fossies" - the Fresh Open Source Software Archive  

Source code changes of the file "sched.c" between
links-1.03.tar.gz and links-1.04.tar.gz

About: Links is a Lynx-like text WWW browser (table support and pop-up dialog boxes).

sched.c  (links-1.03):sched.c  (links-1.04)
#include "links.h" #include "links.h"
tcount connection_count = 0; tcount connection_count = 0;
int active_connections = 0; int active_connections = 0;
tcount netcfg_stamp = 0;
struct list_head queue = {&queue, &queue}; struct list_head queue = {&queue, &queue};
struct h_conn { struct h_conn {
struct h_conn *next; struct h_conn *next;
struct h_conn *prev; struct h_conn *prev;
unsigned char *host; unsigned char *host;
int conn; int conn;
}; };
struct list_head h_conns = {&h_conns, &h_conns}; struct list_head h_conns = {&h_conns, &h_conns};
struct list_head keepalive_connections = {&keepalive_connections, &keepalive_con nections}; struct list_head keepalive_connections = {&keepalive_connections, &keepalive_con nections};
long connect_info(int type) void check_keepalive_connections();
unsigned long connect_info(int type)
{ {
int i = 0; int i = 0;
struct connection *ce; struct connection *ce;
struct k_conn *cee; struct k_conn *cee;
switch (type) { switch (type) {
case CI_FILES: case CI_FILES:
foreach(ce, queue) i++; foreach(ce, queue) i++;
return i; return i;
case CI_CONNECTING: case CI_CONNECTING:
foreach(ce, queue) i += ce->state > S_WAIT && ce->state < S_TRANS; foreach(ce, queue) i += ce->state > S_WAIT && ce->state < S_TRANS;
return i; return i;
case CI_TRANSFER: case CI_TRANSFER:
foreach(ce, queue) i += ce->state == S_TRANS; foreach(ce, queue) i += ce->state == S_TRANS;
return i; return i;
case CI_KEEP: case CI_KEEP:
check_keepalive_connections();
foreach(cee, keepalive_connections) i++; foreach(cee, keepalive_connections) i++;
return i; return i;
case CI_LIST: case CI_LIST:
return (long) &queue; return (long) &queue;
default: default:
internal("cache_info: bad request"); internal("connect_info: bad request");
} }
return 0; return 0;
} }
int connection_disappeared(struct connection *c, tcount count) int connection_disappeared(struct connection *c, tcount count)
{ {
struct connection *d; struct connection *d;
foreach(d, queue) if (c == d && count == d->count) return 0; foreach(d, queue) if (c == d && count == d->count) return 0;
return 1; return 1;
} }
skipping to change at line 76 skipping to change at line 81
int st_r = 0; int st_r = 0;
void stat_timer(struct connection *c) void stat_timer(struct connection *c)
{ {
ttime a; ttime a;
struct remaining_info *r = &c->prg; struct remaining_info *r = &c->prg;
if (getpri(c) == PRI_CANCEL && (c->est_length > (longlong)memory_cache_si ze * MAX_CACHED_OBJECT || c->from > (longlong)memory_cache_size * MAX_CACHED_OBJ ECT)) register_bottom_half(check_queue, NULL); if (getpri(c) == PRI_CANCEL && (c->est_length > (longlong)memory_cache_si ze * MAX_CACHED_OBJECT || c->from > (longlong)memory_cache_size * MAX_CACHED_OBJ ECT)) register_bottom_half(check_queue, NULL);
r->loaded = c->received; r->loaded = c->received;
if ((r->size = c->est_length) < (r->pos = c->from) && r->size != -1) if ((r->size = c->est_length) < (r->pos = c->from) && r->size != -1)
r->size = c->from; r->size = c->from;
r->dis_b += a = get_time() - r->last_time; a = (uttime)get_time() - (uttime)r->last_time;
r->dis_b += (uttime)a;
while (r->dis_b >= SPD_DISP_TIME * CURRENT_SPD_SEC) { while (r->dis_b >= SPD_DISP_TIME * CURRENT_SPD_SEC) {
r->cur_loaded -= r->data_in_secs[0]; r->cur_loaded -= r->data_in_secs[0];
memmove(r->data_in_secs, r->data_in_secs + 1, sizeof(int) * (CURR ENT_SPD_SEC - 1)); memmove(r->data_in_secs, r->data_in_secs + 1, sizeof(off_t) * (CU RRENT_SPD_SEC - 1));
r->data_in_secs[CURRENT_SPD_SEC - 1] = 0; r->data_in_secs[CURRENT_SPD_SEC - 1] = 0;
r->dis_b -= SPD_DISP_TIME; r->dis_b -= (uttime)SPD_DISP_TIME;
} }
r->data_in_secs[CURRENT_SPD_SEC - 1] += r->loaded - r->last_loaded; r->data_in_secs[CURRENT_SPD_SEC - 1] += r->loaded - r->last_loaded;
r->cur_loaded += r->loaded - r->last_loaded; r->cur_loaded += (uttime)r->loaded - (uttime)r->last_loaded;
r->last_loaded = r->loaded; r->last_loaded = (uttime)r->loaded;
r->last_time += a; r->last_time += (uttime)a;
r->elapsed += a; r->elapsed += (uttime)a;
r->timer = install_timer(SPD_DISP_TIME, (void (*)(void *))stat_timer, c); r->timer = install_timer(SPD_DISP_TIME, (void (*)(void *))stat_timer, c);
if (!st_r) send_connection_info(c); if (!st_r) send_connection_info(c);
} }
void setcstate(struct connection *c, int state) void setcstate(struct connection *c, int state)
{ {
struct status *stat; struct status *stat;
if (c->state < 0 && state >= 0) c->prev_error = c->state; if (c->state < 0 && state >= 0) c->prev_error = c->state;
if ((c->state = state) == S_TRANS) { if ((c->state = state) == S_TRANS) {
struct remaining_info *r = &c->prg; struct remaining_info *r = &c->prg;
skipping to change at line 140 skipping to change at line 146
if (!(ho = get_host_and_pass(c->url))) return NULL; if (!(ho = get_host_and_pass(c->url))) return NULL;
foreach(h, keepalive_connections) foreach(h, keepalive_connections)
if (h->protocol == ph && h->port == po && !strcmp(h->host, ho)) { if (h->protocol == ph && h->port == po && !strcmp(h->host, ho)) {
mem_free(ho); mem_free(ho);
return h; return h;
} }
mem_free(ho); mem_free(ho);
return NULL; return NULL;
} }
int get_keepalive_socket(struct connection *c) int get_keepalive_socket(struct connection *c, int *protocol_data)
{ {
struct k_conn *k; struct k_conn *k;
int cc; int cc;
if (!(k = is_host_on_keepalive_list(c))) return -1; if (!(k = is_host_on_keepalive_list(c))) return -1;
cc = k->conn; cc = k->conn;
if (protocol_data) *protocol_data = k->protocol_data;
del_from_list(k); del_from_list(k);
mem_free(k->host); mem_free(k->host);
mem_free(k); mem_free(k);
c->sock1 = cc; c->sock1 = cc;
return 0; return 0;
} }
void check_keepalive_connections();
void abort_all_keepalive_connections() void abort_all_keepalive_connections()
{ {
struct k_conn *k; struct k_conn *k;
foreach(k, keepalive_connections) mem_free(k->host), close(k->conn); int rs;
foreach(k, keepalive_connections) {
mem_free(k->host);
EINTRLOOP(rs, close(k->conn));
}
free_list(keepalive_connections); free_list(keepalive_connections);
check_keepalive_connections(); check_keepalive_connections();
} }
void free_connection_data(struct connection *c) void free_connection_data(struct connection *c)
{ {
struct h_conn *h; struct h_conn *h;
int rs;
if (c->sock1 != -1) set_handlers(c->sock1, NULL, NULL, NULL, NULL); if (c->sock1 != -1) set_handlers(c->sock1, NULL, NULL, NULL, NULL);
if (c->sock2 != -1) set_handlers(c->sock2, NULL, NULL, NULL, NULL); if (c->sock2 != -1) set_handlers(c->sock2, NULL, NULL, NULL, NULL);
close_socket(&c->sock2); close_socket(&c->sock2);
if (c->pid) { if (c->pid) {
kill(c->pid, SIGINT); EINTRLOOP(rs, kill(c->pid, SIGINT));
kill(c->pid, SIGTERM); EINTRLOOP(rs, kill(c->pid, SIGTERM));
kill(c->pid, SIGKILL); EINTRLOOP(rs, kill(c->pid, SIGKILL));
c->pid = 0; c->pid = 0;
} }
if (!c->running) { if (!c->running) {
internal("connection already suspended"); internal("connection already suspended");
} }
c->running = 0; c->running = 0;
if (c->dnsquery) kill_dns_request(&c->dnsquery); if (c->dnsquery) kill_dns_request(&c->dnsquery);
if (c->buffer) { if (c->buffer) {
mem_free(c->buffer); mem_free(c->buffer);
c->buffer = NULL; c->buffer = NULL;
skipping to change at line 225 skipping to change at line 235
stat = stat->next; stat = stat->next;
if (stat->prev->end) stat->prev->end(stat->prev, stat->prev->data ); if (stat->prev->end) stat->prev->end(stat->prev, stat->prev->data );
if (st >= 0 && connection_disappeared(c, count)) return; if (st >= 0 && connection_disappeared(c, count)) return;
} }
} }
void del_connection(struct connection *c) void del_connection(struct connection *c)
{ {
del_from_list(c); del_from_list(c);
send_connection_info(c); send_connection_info(c);
if (c->detached) {
struct cache_entry *ce = c->cache;
if (ce && !ce->url[0] && !is_entry_used(ce) && !ce->refcount)
delete_cache_entry(ce);
}
mem_free(c->url); mem_free(c->url);
mem_free(c); mem_free(c);
} }
#ifdef DEBUG #ifdef DEBUG
void check_queue_bugs(); void check_queue_bugs();
#endif #endif
void add_keepalive_socket(struct connection *c, ttime timeout) void add_keepalive_socket(struct connection *c, ttime timeout, int protocol_data )
{ {
struct k_conn *k; struct k_conn *k;
int rs;
free_connection_data(c); free_connection_data(c);
if (c->sock1 == -1) { if (c->sock1 == -1) {
internal("keepalive connection not connected"); internal("keepalive connection not connected");
goto del; goto del;
} }
k = mem_alloc(sizeof(struct k_conn)); k = mem_alloc(sizeof(struct k_conn));
if ((k->port = get_port(c->url)) == -1 || !(k->protocol = get_protocol_ha if (c->netcfg_stamp != netcfg_stamp ||
ndle(c->url)) || !(k->host = get_host_and_pass(c->url))) { (k->port = get_port(c->url)) == -1 ||
!(k->protocol = get_protocol_handle(c->url)) ||
!(k->host = get_host_and_pass(c->url))) {
mem_free(k); mem_free(k);
del_connection(c); del_connection(c);
goto close; goto close;
} }
k->conn = c->sock1; k->conn = c->sock1;
k->timeout = timeout; k->timeout = timeout;
k->add_time = get_time(); k->add_time = get_time();
k->protocol_data = protocol_data;
add_to_list(keepalive_connections, k); add_to_list(keepalive_connections, k);
del: del:
del_connection(c); del_connection(c);
#ifdef DEBUG #ifdef DEBUG
check_queue_bugs(); check_queue_bugs();
#endif #endif
register_bottom_half(check_queue, NULL); register_bottom_half(check_queue, NULL);
return; return;
close: close:
close(c->sock1); EINTRLOOP(rs, close(c->sock1));
#ifdef DEBUG #ifdef DEBUG
check_queue_bugs(); check_queue_bugs();
#endif #endif
register_bottom_half(check_queue, NULL); register_bottom_half(check_queue, NULL);
} }
void del_keepalive_socket(struct k_conn *kc) void del_keepalive_socket(struct k_conn *kc)
{ {
int rs;
del_from_list(kc); del_from_list(kc);
close(kc->conn); EINTRLOOP(rs, close(kc->conn));
mem_free(kc->host); mem_free(kc->host);
mem_free(kc); mem_free(kc);
} }
int keepalive_timeout = -1; int keepalive_timeout = -1;
void check_keepalive_connections();
void keepalive_timer(void *x) void keepalive_timer(void *x)
{ {
keepalive_timeout = -1; keepalive_timeout = -1;
check_keepalive_connections(); check_keepalive_connections();
} }
void check_keepalive_connections() void check_keepalive_connections()
{ {
struct k_conn *kc; struct k_conn *kc;
ttime ct = get_time(); ttime ct = get_time();
int p = 0; int p = 0;
if (keepalive_timeout != -1) kill_timer(keepalive_timeout), keepalive_tim eout = -1; if (keepalive_timeout != -1) kill_timer(keepalive_timeout), keepalive_tim eout = -1;
foreach(kc, keepalive_connections) if (can_read(kc->conn) || ct - kc->add _time > kc->timeout) { foreach(kc, keepalive_connections) if (can_read(kc->conn) || (uttime)ct - (uttime)kc->add_time > (uttime)kc->timeout) {
kc = kc->prev; kc = kc->prev;
del_keepalive_socket(kc->next); del_keepalive_socket(kc->next);
} else p++; } else p++;
for (; p > MAX_KEEPALIVE_CONNECTIONS; p--) for (; p > MAX_KEEPALIVE_CONNECTIONS; p--)
if (!list_empty(keepalive_connections)) if (!list_empty(keepalive_connections))
del_keepalive_socket(keepalive_connections.prev); del_keepalive_socket(keepalive_connections.prev);
else internal("keepalive list empty"); else internal("keepalive list empty");
if (!list_empty(keepalive_connections)) keepalive_timeout = install_timer (KEEPALIVE_CHECK_TIME, keepalive_timer, NULL); if (!list_empty(keepalive_connections)) keepalive_timeout = install_timer (KEEPALIVE_CHECK_TIME, keepalive_timer, NULL);
} }
skipping to change at line 329 skipping to change at line 348
add_at_pos(n, c); add_at_pos(n, c);
swp = 1; swp = 1;
} }
} }
} while (swp); } while (swp);
} }
void interrupt_connection(struct connection *c) void interrupt_connection(struct connection *c)
{ {
#ifdef HAVE_SSL #ifdef HAVE_SSL
if (c->ssl == (void *)-1) c->ssl = 0; if (c->ssl == (void *)-1) c->ssl = NULL;
if(c->ssl) { if (c->ssl) {
SSL_free(c->ssl); SSL_free(c->ssl);
c->ssl=NULL; c->ssl = NULL;
} }
#endif #endif
if (c->sock1 != -1) set_handlers(c->sock1, NULL, NULL, NULL, NULL);
close_socket(&c->sock1); close_socket(&c->sock1);
free_connection_data(c); free_connection_data(c);
} }
void suspend_connection(struct connection *c) void suspend_connection(struct connection *c)
{ {
interrupt_connection(c); interrupt_connection(c);
setcstate(c, S_WAIT); setcstate(c, S_WAIT);
} }
skipping to change at line 463 skipping to change at line 483
void check_queue_bugs() void check_queue_bugs()
{ {
struct connection *d; struct connection *d;
int p = 0, ps = 0; int p = 0, ps = 0;
int cc; int cc;
again: again:
cc = 0; cc = 0;
foreach(d, queue) { foreach(d, queue) {
int q = getpri(d); int q = getpri(d);
cc += d->running; cc += d->running;
if (q < p) if (!ps) { if (q < p) {
internal("queue is not sorted"); if (!ps) {
sort_queue(); internal("queue is not sorted");
ps = 1; sort_queue();
goto again; ps = 1;
} else { goto again;
internal("queue is not sorted even after sort_queue!"); } else {
break; internal("queue is not sorted even after sort_que
ue!");
break;
}
} else p = q; } else p = q;
if (d->state < 0) { if (d->state < 0) {
internal("interrupted connection on queue (conn %s, state %d)", d->url, d->state); internal("interrupted connection on queue (conn %s, state %d)", d->url, d->state);
d = d->prev; d = d->prev;
abort_connection(d->next); abort_connection(d->next);
} }
} }
if (cc != active_connections) { if (cc != active_connections) {
internal("bad number of active connections (counted %d, stored %d )", cc, active_connections); internal("bad number of active connections (counted %d, stored %d )", cc, active_connections);
active_connections = cc; active_connections = cc;
skipping to change at line 570 skipping to change at line 592
} }
#endif #endif
if (stat) stat->state = S_OUT_OF_MEM, stat->prev_error = 0; if (stat) stat->state = S_OUT_OF_MEM, stat->prev_error = 0;
if (no_cache <= NC_CACHE && !find_in_cache(url, &e)) { if (no_cache <= NC_CACHE && !find_in_cache(url, &e)) {
if (e->incomplete) { if (e->incomplete) {
e->refcount--; e->refcount--;
goto skip_cache; goto skip_cache;
} }
if (stat) { if (stat) {
stat->ce = e; stat->ce = e;
stat->state = S_OK; stat->state = S__OK;
if (stat->end) stat->end(stat, stat->data); if (stat->end) stat->end(stat, stat->data);
} }
e->refcount--; e->refcount--;
return 0; return 0;
} }
skip_cache: skip_cache:
if (!casecmp(url, "proxy://", 8)) { if (!casecmp(url, "proxy://", 8)) {
if (stat) { if (stat) {
stat->state = S_BAD_URL; stat->state = S_BAD_URL;
if (stat->end) stat->end(stat, stat->data); if (stat->end) stat->end(stat, stat->data);
skipping to change at line 614 skipping to change at line 636
check_queue_bugs(); check_queue_bugs();
#endif #endif
return 0; return 0;
} }
c = mem_alloc(sizeof(struct connection)); c = mem_alloc(sizeof(struct connection));
memset(c, 0, sizeof(struct connection)); memset(c, 0, sizeof(struct connection));
c->count = connection_count++; c->count = connection_count++;
c->url = u; c->url = u;
c->running = 0; c->running = 0;
c->prev_error = 0; c->prev_error = 0;
c->from = no_cache >= NC_IF_MOD || !e || e->frag.next == &e->frag || ((st if (no_cache >= NC_IF_MOD || !e) {
ruct fragment *)e->frag.next)->offset ? 0 : ((struct fragment *)e->frag.next)->l c->from = 0;
ength; } else {
struct fragment *frag;
c->from = 0;
foreach(frag, e->frag) {
if (frag->offset != c->from)
break;
c->from += frag->length;
}
}
memset(c->pri, 0, sizeof c->pri); memset(c->pri, 0, sizeof c->pri);
c->pri[pri] = 1; c->pri[pri] = 1;
c->no_cache = no_cache; c->no_cache = no_cache;
c->sock1 = c->sock2 = -1; c->sock1 = c->sock2 = -1;
c->dnsquery = NULL; c->dnsquery = NULL;
c->info = NULL; c->info = NULL;
c->buffer = NULL; c->buffer = NULL;
c->newconn = NULL; c->newconn = NULL;
c->cache = NULL; c->cache = NULL;
c->tries = 0; c->tries = 0;
c->netcfg_stamp = netcfg_stamp;
init_list(c->statuss); init_list(c->statuss);
c->est_length = -1; c->est_length = -1;
c->unrestartable = 0; c->unrestartable = 0;
c->prg.timer = -1; c->prg.timer = -1;
c->timer = -1; c->timer = -1;
if (stat) { if (stat) {
stat->prg = &c->prg; stat->prg = &c->prg;
stat->c = c; stat->c = c;
stat->ce = NULL; stat->ce = NULL;
add_to_list(c->statuss, stat); add_to_list(c->statuss, stat);
skipping to change at line 701 skipping to change at line 735
register_bottom_half(check_queue, NULL); register_bottom_half(check_queue, NULL);
} }
void detach_connection(struct status *stat, off_t pos) void detach_connection(struct status *stat, off_t pos)
{ {
struct connection *c; struct connection *c;
int i; int i;
off_t l; off_t l;
if (stat->state < 0) return; if (stat->state < 0) return;
c = stat->c; c = stat->c;
if (c->detached) goto detach_done;
if (!c->cache) return; if (!c->cache) return;
if (c->detached) goto detach_done;
if (c->est_length == -1) l = c->from; if (c->est_length == -1) l = c->from;
else l = c->est_length; else l = c->est_length;
if (l < (longlong)memory_cache_size * MAX_CACHED_OBJECT) return; if (l < (longlong)memory_cache_size * MAX_CACHED_OBJECT) return;
l = 0; l = 0;
for (i = 0; i < PRI_CANCEL; i++) l += c->pri[i]; for (i = 0; i < PRI_CANCEL; i++) l += c->pri[i];
if (!l) internal("detaching free connection"); if (!l) internal("detaching free connection");
delete_unused_format_cache_entries(); delete_unused_format_cache_entries();
if (l != 1 || c->cache->refcount) return; if (l != 1 || c->cache->refcount) return;
c->cache->url[0] = 0; c->cache->url[0] = 0;
c->detached = 1; c->detached = 1;
detach_done: detach_done:
free_entry_to(c->cache, pos); free_entry_to(c->cache, pos);
} }
void connection_timeout(struct connection *c) void connection_timeout(struct connection *c)
{ {
c->timer = -1; c->timer = -1;
setcstate(c, S_TIMEOUT); setcstate(c, S_TIMEOUT);
if (c->dnsquery) abort_connection(c); retry_connection(c);
else retry_connection(c);
} }
void connection_timeout_1(struct connection *c) void connection_timeout_1(struct connection *c)
{ {
c->timer = install_timer((c->unrestartable ? unrestartable_receive_timeou t : receive_timeout) * 500, (void (*)(void *))connection_timeout, c); c->timer = install_timer((c->unrestartable ? unrestartable_receive_timeou t : receive_timeout) * 500, (void (*)(void *))connection_timeout, c);
} }
void set_timeout(struct connection *c) void set_timeout(struct connection *c)
{ {
if (c->timer != -1) kill_timer(c->timer); if (c->timer != -1) kill_timer(c->timer);
skipping to change at line 831 skipping to change at line 864
{ S_WAIT, TEXT_(T_WAITING_IN_QUEUE) }, { S_WAIT, TEXT_(T_WAITING_IN_QUEUE) },
{ S_DNS, TEXT_(T_LOOKING_UP_HOST) }, { S_DNS, TEXT_(T_LOOKING_UP_HOST) },
{ S_CONN, TEXT_(T_MAKING_CONNECTION) }, { S_CONN, TEXT_(T_MAKING_CONNECTION) },
{ S_SSL_NEG, TEXT_(T_SSL_NEGOTIATION) }, { S_SSL_NEG, TEXT_(T_SSL_NEGOTIATION) },
{ S_SENT, TEXT_(T_REQUEST_SENT) }, { S_SENT, TEXT_(T_REQUEST_SENT) },
{ S_LOGIN, TEXT_(T_LOGGING_IN) }, { S_LOGIN, TEXT_(T_LOGGING_IN) },
{ S_GETH, TEXT_(T_GETTING_HEADERS) }, { S_GETH, TEXT_(T_GETTING_HEADERS) },
{ S_PROC, TEXT_(T_SERVER_IS_PROCESSING_REQUEST) }, { S_PROC, TEXT_(T_SERVER_IS_PROCESSING_REQUEST) },
{ S_TRANS, TEXT_(T_TRANSFERRING) }, { S_TRANS, TEXT_(T_TRANSFERRING) },
{ S_OK, TEXT_(T_OK) }, { S__OK, TEXT_(T_OK) },
{ S_INTERRUPTED, TEXT_(T_INTERRUPTED) }, { S_INTERRUPTED, TEXT_(T_INTERRUPTED) },
{ S_EXCEPT, TEXT_(T_SOCKET_EXCEPTION) }, { S_EXCEPT, TEXT_(T_SOCKET_EXCEPTION) },
{ S_INTERNAL, TEXT_(T_INTERNAL_ERROR) }, { S_INTERNAL, TEXT_(T_INTERNAL_ERROR) },
{ S_OUT_OF_MEM, TEXT_(T_OUT_OF_MEMORY) }, { S_OUT_OF_MEM, TEXT_(T_OUT_OF_MEMORY) },
{ S_NO_DNS, TEXT_(T_HOST_NOT_FOUND) }, { S_NO_DNS, TEXT_(T_HOST_NOT_FOUND) },
{ S_CANT_WRITE, TEXT_(T_ERROR_WRITING_TO_SOCKET) }, { S_CANT_WRITE, TEXT_(T_ERROR_WRITING_TO_SOCKET) },
{ S_CANT_READ, TEXT_(T_ERROR_READING_FROM_SOCKET) }, { S_CANT_READ, TEXT_(T_ERROR_READING_FROM_SOCKET) },
{ S_MODIFIED, TEXT_(T_DATA_MODIFIED) }, { S_MODIFIED, TEXT_(T_DATA_MODIFIED) },
{ S_BAD_URL, TEXT_(T_BAD_URL_SYNTAX) }, { S_BAD_URL, TEXT_(T_BAD_URL_SYNTAX) },
{ S_TIMEOUT, TEXT_(T_RECEIVE_TIMEOUT) }, { S_TIMEOUT, TEXT_(T_RECEIVE_TIMEOUT) },
 End of changes. 35 change blocks. 
43 lines changed or deleted 74 lines changed or added

Home  |  About  |  Features  |  All  |  Newest  |  Dox  |  Diffs  |  RSS Feeds  |  Screenshots  |  Comments  |  Imprint  |  Privacy  |  HTTP(S)