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);
}
void cleanup_cookies(void)
{
struct cookie *c;
free_list(c_domains);
/* !!! FIXME: save cookies */
foreach (c, all_cookies) free_cookie(c);
free_list(all_cookies);
}
static void accept_cookie(struct cookie *c)
{
struct c_domain *cd;
struct cookie *d, *e;
foreach(d, all_cookies) if (!strcasecmp(cast_const_char d->name, cast_const_char c->name) && !strcasecmp(cast_const_char d->domain, cast_const_char c->domain)) {
e = d;
d = d->prev;
del_from_list(e);
free_cookie(e);
mem_free(e);
}
if (c->value && !strcasecmp(cast_const_char c->value, "deleted")) {
free_cookie(c);
mem_free(c);
return;
}
add_to_list(all_cookies, c);
foreach(cd, c_domains) if (!strcasecmp(cast_const_char cd->domain, cast_const_char c->domain)) return;
cd = mem_alloc(sizeof(struct c_domain) + strlen(cast_const_char c->domain) + 1);
strcpy(cast_char cd->domain, cast_const_char c->domain);
add_to_list(c_domains, cd);
}
/* 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 MPID_nem_tcp_module_lmt_start_recv (MPIDI_VC_t *vc, MPID_Request *req)
{
int mpi_errno = MPI_SUCCESS;
int ret;
MPIDI_msg_sz_t data_sz;
int dt_contig;
MPI_Aint dt_true_lb;
MPID_Datatype * dt_ptr;
MPIDI_msg_sz_t last;
int nb;
int r_len;
MPIDI_CH3I_VC *vc_ch = (MPIDI_CH3I_VC *)vc->channel_private;
MPIDI_STATE_DECL(MPID_STATE_MPID_NEM_TCP_MODULE_LMT_START_RECV);
MPIDI_FUNC_ENTER(MPID_STATE_MPID_NEM_TCP_MODULE_LMT_START_RECV);
free_cookie (vc_ch->net.tcp.lmt_cookie);
if (!vc_ch->net.tcp.lmt_connected)
{
int len;
struct sockaddr_in saddr;
int connfd;
len = sizeof (saddr);
connfd = accept (vc_ch->net.tcp.lmt_desc, (struct sockaddr *)&saddr, &len);
MPIU_ERR_CHKANDJUMP2 (connfd == -1, mpi_errno, MPI_ERR_OTHER, "**sock|poll|accept", "**sock|poll|accept %d %s", errno, strerror (errno));
/* close listen fd */
do
ret = close (vc_ch->net.tcp.lmt_desc);
while (ret == -1 && errno == EINTR);
MPIU_ERR_CHKANDJUMP2 (ret == -1, mpi_errno, MPI_ERR_OTHER, "**closesocket", "**closesocket %s %d", strerror (errno), errno);
/* set lmt_desc to new connected fd */
vc_ch->net.tcp.lmt_desc = connfd;
vc_ch->net.tcp.lmt_connected = 1;
// ret = fcntl (vc_ch->net.tcp.lmt_desc, F_SETFL, O_NONBLOCK);
// MPIU_ERR_CHKANDJUMP2 (ret == -1, mpi_errno, MPI_ERR_OTHER, "**fail", "**fail %s %d", strerror (errno), errno);
}
MPIDI_Datatype_get_info (req->dev.user_count, req->dev.datatype, dt_contig, data_sz, dt_ptr, dt_true_lb);
if (data_sz > vc_ch->net.tcp.lmt_s_len)
{
data_sz = vc_ch->net.tcp.lmt_s_len;
}
else if (data_sz < vc_ch->net.tcp.lmt_s_len)
{
/* message will be truncated */
r_len = data_sz;
req->status.MPI_ERROR = MPIU_ERR_SET2 (mpi_errno, MPI_ERR_TRUNCATE, "**truncate", "**truncate %d %d", vc_ch->net.tcp.lmt_s_len, r_len);
}
MPID_Segment_init (req->dev.user_buf, req->dev.user_count, req->dev.datatype, &req->dev.segment, 0);
req->dev.segment_first = 0;
req->dev.segment_size = data_sz;
req->dev.iov_count = MPID_IOV_LIMIT;
req->dev.iov_offset = 0;
last = data_sz;
do
{
int iov_offset;
int left_to_recv;
MPID_Segment_unpack_vector (&req->dev.segment, req->dev.segment_first, &last, req->dev.iov, &req->dev.iov_count);
left_to_recv = last - req->dev.segment_first;
iov_offset = 0;
#ifdef TESTING_CHUNKING
{
char *buf = req->dev.iov[0].MPID_IOV_BUF;
int l;
while (left_to_recv)
{
if (left_to_recv > CHUNK)
l = CHUNK;
else
l = left_to_recv;
do
nb = read (vc_ch->net.tcp.lmt_desc, buf, l);
while (nb == -1 && errno == EINTR);
MPIU_ERR_CHKANDJUMP (nb == -1, mpi_errno, MPI_ERR_OTHER, "**sock_writev");
left_to_recv -= nb;
buf += nb;
}
MPIDI_CH3U_Request_complete (req);
goto fn_exit;
}
#endif
do
nb = readv (vc_ch->net.tcp.lmt_desc, &req->dev.iov[iov_offset], req->dev.iov_count - iov_offset);
while (nb == -1 && errno == EINTR);
MPIU_ERR_CHKANDJUMP2 (nb == -1, mpi_errno, MPI_ERR_OTHER, "**fail", "**fail %s %d", strerror (errno), errno);
MPIU_ERR_CHKANDJUMP (nb == 0, mpi_errno, MPI_ERR_OTHER, "**fail");
left_to_recv -= nb;
while (left_to_recv)
{ /* recv rest of iov */
while (nb >= req->dev.iov[iov_offset].MPID_IOV_LEN)
{ /* update iov to reflect sent bytes */
nb -= req->dev.iov[iov_offset].MPID_IOV_LEN;
++iov_offset;
}
req->dev.iov[iov_offset].MPID_IOV_BUF = (char *)req->dev.iov[iov_offset].MPID_IOV_BUF + nb;
req->dev.iov[iov_offset].MPID_IOV_LEN -= nb;
do
nb = readv (vc_ch->net.tcp.lmt_desc, &req->dev.iov[iov_offset], req->dev.iov_count - iov_offset);
while (nb == -1 && errno == EINTR);
MPIU_ERR_CHKANDJUMP2 (nb == -1, mpi_errno, MPI_ERR_OTHER, "**fail", "**fail %s %d", strerror (errno), errno);
MPIU_ERR_CHKANDJUMP (nb == 0, mpi_errno, MPI_ERR_OTHER, "**fail");
left_to_recv -= nb;
}
}
while (last < data_sz);
MPIDI_CH3U_Request_complete (req);
fn_exit:
MPIDI_FUNC_EXIT(MPID_STATE_MPID_NEM_TCP_MODULE_LMT_START_RECV);
return mpi_errno;
fn_fail:
goto fn_exit;
}
int MPID_nem_tcp_module_lmt_start_send (MPIDI_VC_t *vc, MPID_Request *req, MPID_IOV r_cookie)
{
int mpi_errno = MPI_SUCCESS;
int ret;
MPIDI_msg_sz_t data_sz;
int dt_contig;
MPI_Aint dt_true_lb;
MPID_Datatype * dt_ptr;
MPIDI_msg_sz_t last;
int nb;
int s_len = 0;
int r_len;
int r_port;
char *r_hostname;
MPIDI_CH3I_VC *vc_ch = (MPIDI_CH3I_VC *)vc->channel_private;
MPIDI_STATE_DECL(MPID_STATE_MPID_NEM_TCP_MODULE_LMT_START_SEND);
MPIDI_FUNC_ENTER(MPID_STATE_MPID_NEM_TCP_MODULE_LMT_START_SEND);
mpi_errno = read_r_cookie (r_cookie, &r_hostname, &r_port, &r_len);
if (mpi_errno) MPIU_ERR_POP (mpi_errno);
free_cookie (vc_ch->net.tcp.lmt_cookie);
if (!vc_ch->net.tcp.lmt_connected)
{
struct sockaddr_in saddr;
struct hostent *hp;
vc_ch->net.tcp.lmt_desc = socket (AF_INET, SOCK_STREAM, 0);
MPIU_ERR_CHKANDJUMP2 (vc_ch->net.tcp.lmt_desc == -1, mpi_errno, MPI_ERR_OTHER, "**sock_create", "**sock_create %s %d", strerror (errno), errno);
// ret = fcntl (vc_ch->net.tcp.lmt_desc, F_SETFL, O_NONBLOCK);
// MPIU_ERR_CHKANDJUMP2 (ret == -1, mpi_errno, MPI_ERR_OTHER, "**fail", "**fail %s %d", strerror (errno), errno);
hp = gethostbyname (r_hostname);
MPIU_ERR_CHKANDJUMP2 (hp == NULL, mpi_errno, MPI_ERR_OTHER, "**gethostbyname", "**gethostbyname %s %d", hstrerror (h_errno), h_errno);
memset (&saddr, sizeof(saddr), 0);
saddr.sin_family = AF_INET;
saddr.sin_port = htons (r_port);
MPIU_Memcpy (&saddr.sin_addr, hp->h_addr, hp->h_length);
set_sockopts (vc_ch->net.tcp.lmt_desc);
ret = connect (vc_ch->net.tcp.lmt_desc, (struct sockaddr *)&saddr, sizeof(saddr));
MPIU_ERR_CHKANDJUMP2 (ret == -1, mpi_errno, MPI_ERR_OTHER, "**fail", "**fail %s %d", strerror (errno), errno);
vc_ch->net.tcp.lmt_connected = 1;
}
MPIDI_Datatype_get_info (req->dev.user_count, req->dev.datatype, dt_contig, data_sz, dt_ptr, dt_true_lb);
if (r_len < data_sz)
{
/* message will be truncated */
s_len = data_sz;
data_sz = r_len;
req->status.MPI_ERROR = MPIU_ERR_SET2 (mpi_errno, MPI_ERR_TRUNCATE, "**truncate", "**truncate %d %d", s_len, r_len);
}
MPID_Segment_init (req->dev.user_buf, req->dev.user_count, req->dev.datatype, &req->dev.segment, 0);
req->dev.segment_first = 0;
req->dev.segment_size = data_sz;
req->dev.iov_count = MPID_IOV_LIMIT;
req->dev.iov_offset = 0;
last = data_sz;
do
{
int iov_offset;
int left_to_send;
MPID_Segment_pack_vector (&req->dev.segment, req->dev.segment_first, &last, req->dev.iov, &req->dev.iov_count);
left_to_send = last - req->dev.segment_first;
iov_offset = 0;
#ifdef TESTING_CHUNKING
{
char *buf = req->dev.iov[0].MPID_IOV_BUF;
int l;
while (left_to_send)
{
if (left_to_send > CHUNK)
l = CHUNK;
else
l = left_to_send;
do
nb = write (vc_ch->net.tcp.lmt_desc, buf, l);
while (nb == -1 && errno == EINTR);
MPIU_ERR_CHKANDJUMP (nb == -1, mpi_errno, MPI_ERR_OTHER, "**sock_writev");
left_to_send -= nb;
buf += nb;
}
MPIDI_CH3U_Request_complete (req);
goto fn_exit;
}
#endif
do
nb = writev (vc_ch->net.tcp.lmt_desc, &req->dev.iov[iov_offset], req->dev.iov_count - iov_offset);
while (nb == -1 && errno == EINTR);
MPIU_ERR_CHKANDJUMP (nb == -1, mpi_errno, MPI_ERR_OTHER, "**sock_writev");
left_to_send -= nb;
while (left_to_send)
{ /* send rest of iov */
while (nb >= req->dev.iov[iov_offset].MPID_IOV_LEN)
{ /* update iov to reflect sent bytes */
nb -= req->dev.iov[iov_offset].MPID_IOV_LEN;
++iov_offset;
}
req->dev.iov[iov_offset].MPID_IOV_BUF = (char *)req->dev.iov[iov_offset].MPID_IOV_BUF + nb;
req->dev.iov[iov_offset].MPID_IOV_LEN -= nb;
do
nb = writev (vc_ch->net.tcp.lmt_desc, &req->dev.iov[iov_offset], req->dev.iov_count - iov_offset);
while (nb == -1 && errno == EINTR);
MPIU_ERR_CHKANDJUMP (nb == -1, mpi_errno, MPI_ERR_OTHER, "**sock_writev");
left_to_send -= nb;
}
}
while (last < data_sz);
MPIDI_CH3U_Request_complete (req);
fn_exit:
MPIDI_FUNC_EXIT(MPID_STATE_MPID_NEM_TCP_MODULE_LMT_START_SEND);
return mpi_errno;
fn_fail:
goto fn_exit;
}
