QNetworkReply* UpyunClientPrivate::downloadFile(const QString &remote_path) {
QString path_url = "/" + _bucket + "/" + remote_path;
QString now_time = rfc1123_datetime(time(NULL)).c_str();
QString auth = get_auth_string(_usr,
get_sign("GET", path_url, now_time, "0", _pwd));
// QUrl url = upyun_api_host + path_url;
QUrl url = QUrl::fromEncoded((g_upyun_api_host + path_url).toLocal8Bit());
QNetworkRequest request(url);
request.setRawHeader("Authorization", auth.toLatin1());
request.setRawHeader("Date", now_time.toLatin1());
QNetworkReply *reply = _qnam.get(request);
return reply;
}
QNetworkReply *UpyunClientPrivate::makeDir(const QString &remote_path) {
QString path_url = "/" + _bucket + "/" + remote_path;
QString now_time = rfc1123_datetime(time(NULL)).c_str();
QString auth = get_auth_string(_usr,
get_sign("POST", path_url, now_time, "0", _pwd));
// QUrl url = upyun_api_host + path_url;
QUrl url = QUrl::fromEncoded((g_upyun_api_host + path_url).toLocal8Bit());
QNetworkRequest request(url);
request.setRawHeader("Authorization", auth.toLatin1());
request.setRawHeader("Content-Length", "0");
request.setRawHeader("Content-Type", "text/html");
request.setRawHeader("Date", now_time.toLatin1());
request.setRawHeader("folder", "create");
request.setRawHeader("mkdir", "true");
QNetworkReply *reply = _qnam.post(request, "");
return reply;
}
QNetworkReply* UpyunClientPrivate::uploadFile(const QByteArray &filedata,
const QString &remote_path) {
QString content_len = QString::number(filedata.length());
QString path_url = "/" + _bucket + "/" + remote_path;
QString now_time = rfc1123_datetime(time(NULL)).c_str();
QString auth = get_auth_string(_usr,
get_sign("PUT", path_url, now_time, content_len, _pwd));
// QUrl url = upyun_api_host + path_url;
QUrl url = QUrl::fromEncoded((g_upyun_api_host + path_url).toLocal8Bit());
QNetworkRequest request(url);
request.setRawHeader("Authorization", auth.toLatin1());
request.setRawHeader("Content-Length", content_len.toLatin1());
request.setRawHeader("Date", now_time.toLatin1());
request.setRawHeader("mkdir", "true");
QNetworkReply *reply = _qnam.put(request, filedata);
return reply;
}
static void send_notifies(db1_res_t *result, int did_col, int resource_uri_col, int auth_state_col, int reason_col,
int pres_state_col, int content_type_col)
{
int i;
char* prev_did= NULL, * curr_did= NULL;
db_row_t *row;
db_val_t *row_vals;
char* resource_uri;
str pres_state = {0, 0};
xmlDocPtr rlmi_doc= NULL;
xmlNodePtr list_node= NULL, instance_node= NULL, resource_node;
unsigned int hash_code= 0;
int size= BUF_REALLOC_SIZE, buf_len= 0;
char* buf= NULL, *auth_state= NULL, *boundary_string= NULL;
str cid = {0,0};
str content_type= {0, 0};
int auth_state_flag;
int chunk_len=0;
str bstr= {0, 0};
subs_t* dialog= NULL;
int len_est = 0;
int resource_added = 0; /* Flag to indicate that we have added at least one resource */
/* generate the boundary string */
boundary_string= generate_string(BOUNDARY_STRING_LEN);
bstr.len= strlen(boundary_string);
bstr.s= (char*)pkg_malloc((bstr.len+ 1)* sizeof(char));
if(bstr.s== NULL)
{
ERR_MEM(PKG_MEM_STR);
}
memcpy(bstr.s, boundary_string, bstr.len);
bstr.s[bstr.len]= '\0';
/* Allocate an initial buffer for the multipart body.
* This buffer will be reallocated if neccessary */
buf= pkg_malloc(size* sizeof(char));
if(buf== NULL)
{
ERR_MEM(PKG_MEM_STR);
}
LM_DBG("found %d records with updated state\n", result->n);
for(i= 0; i< result->n; i++)
{
row = &result->rows[i];
row_vals = ROW_VALUES(row);
curr_did= (char*)row_vals[did_col].val.string_val;
resource_uri= (char*)row_vals[resource_uri_col].val.string_val;
auth_state_flag= row_vals[auth_state_col].val.int_val;
pres_state.s= (char*)row_vals[pres_state_col].val.string_val;
pres_state.len = strlen(pres_state.s);
trim(&pres_state);
/* If we have moved onto a new resource list Subscribe dialog indentifier,
send a NOTIFY for the previous ID and then drop the existing documents. */
if(prev_did!= NULL && strcmp(prev_did, curr_did))
{
if (send_notify(&rlmi_doc, buf, buf_len, bstr, dialog, hash_code))
{
LM_ERR("in send_notify\n");
goto error;
}
len_est = 0;
pkg_free(dialog);
dialog= NULL;
}
/*if first or different*/
if(prev_did==NULL || strcmp(prev_did, curr_did)!=0)
{
/* Work out a subscription from the did. */
get_dialog_from_did(curr_did, &dialog, &hash_code);
if(dialog== NULL)
{
prev_did = NULL;
LM_INFO("Dialog is NULL\n");
continue;
}
len_est = create_empty_rlmi_doc(&rlmi_doc, &list_node, &dialog->pres_uri, dialog->version, 0);
len_est += 2*strlen(boundary_string)+4+102+2+50+strlen(resource_uri)+20;
buf_len= 0;
resource_added = 0;
/* !!!! for now I will include the auth state without checking if
* it has changed - > in future chech if it works */
}
/* add a node in rlmi_doc and if any presence state registered add
* it in the buffer */
resource_node= xmlNewChild(list_node,NULL,BAD_CAST "resource", NULL);
if(resource_node== NULL)
{
LM_ERR("when adding resource child\n");
goto done;
}
xmlNewProp(resource_node, BAD_CAST "uri", BAD_CAST resource_uri);
len_est += strlen (resource_uri) + 35; /* <resource uri="[uri]"></resource>/r/n */
resource_added = 1;
/* there might be more records with the same uri- more instances-
* search and add them all */
while(1)
{
cid.s= NULL;
cid.len= 0;
auth_state= get_auth_string(auth_state_flag);
if(auth_state== NULL)
{
LM_ERR("bad authorization status flag\n");
goto error;
}
len_est += strlen(auth_state) + 38; /* <instance id="12345678" state="[auth_state]" />r/n */
if(auth_state_flag & ACTIVE_STATE)
{
cid.s= generate_cid(resource_uri, strlen(resource_uri));
cid.len = strlen(cid.s);
len_est += cid.len + 8; /* cid="[cid]" */
content_type.s = (char*)row_vals[content_type_col].val.string_val;
content_type.len = strlen(content_type.s);
chunk_len = 4 + bstr.len
+ 35
+ 16 + cid.len
+ 18 + content_type.len
+ 4 + pres_state.len + 8;
len_est += chunk_len;
}
else
if(auth_state_flag & TERMINATED_STATE)
{
len_est += strlen(row_vals[resource_uri_col].val.string_val) + 10; /* reason="[resaon]" */
}
if (rls_max_notify_body_len > 0 && len_est > rls_max_notify_body_len)
{
/* We have a limit on body length set, and we were about to exceed it */
if (resource_added == 1)
{
/* We added at least one resource. */
LM_DBG("timer_send_notify hit the size limit. len_est = %d\n", len_est);
if (send_notify(&rlmi_doc, buf, buf_len, bstr, dialog, hash_code))
{
LM_ERR("in send_notify\n");
goto error;
}
i --;
}
else
{
LM_DBG("timer_send_notify hit the size limit. NO RESOURCE ADDED len_est = %d\n", len_est);
}
len_est = 0;
pkg_free(dialog);
dialog= NULL;
curr_did=NULL;
break;
}
/* OK, we are happy this will fit */
instance_node= xmlNewChild(resource_node, NULL, BAD_CAST "instance", NULL);
if(instance_node== NULL)
{
LM_ERR("while adding instance child\n");
goto error;
}
/* Instance ID should be unique for each instance node
within a resource node. The same instance ID can be
used in different resource nodes. Instance ID needs
to remain the same for each resource instance in
future updates. We can just use a common string
here because you will only get multiple instances
for a resource when the back-end SUBSCRIBE is forked
and pua does not support this. If/when pua supports
forking of the SUBSCRIBEs it sends this will need to
be fixed properly. */
xmlNewProp(instance_node, BAD_CAST "id",
BAD_CAST instance_id);
if(auth_state_flag & ACTIVE_STATE)
{
xmlNewProp(instance_node, BAD_CAST "state", BAD_CAST auth_state);
}
else
if(auth_state_flag & TERMINATED_STATE)
{
xmlNewProp(instance_node, BAD_CAST "reason",
BAD_CAST row_vals[resource_uri_col].val.string_val);
}
xmlNewProp(instance_node, BAD_CAST "cid", BAD_CAST cid.s);
/* add in the multipart buffer */
if(cid.s)
{
while(buf_len + chunk_len >= size)
{
REALLOC_BUF
}
buf_len+= sprintf(buf+ buf_len, "--%.*s\r\n", bstr.len,
bstr.s);
buf_len+= sprintf(buf+ buf_len,
"Content-Transfer-Encoding: binary\r\n");
buf_len+= sprintf(buf+ buf_len, "Content-ID: <%.*s>\r\n",
cid.len, cid.s);
buf_len+= sprintf(buf+ buf_len, "Content-Type: %.*s\r\n\r\n",
content_type.len, content_type.s);
buf_len+= sprintf(buf+buf_len,"%.*s\r\n\r\n", pres_state.len,
pres_state.s);
}
i++;
if(i== result->n)
{
i--;
break;
}
row = &result->rows[i];
row_vals = ROW_VALUES(row);
if(strncmp(resource_uri, row_vals[resource_uri_col].val.string_val,
strlen(resource_uri))
|| strncmp(curr_did, row_vals[did_col].val.string_val,
strlen(curr_did)))
{
i--;
break;
}
resource_uri= (char*)row_vals[resource_uri_col].val.string_val;
auth_state_flag= row_vals[auth_state_col].val.int_val;
pres_state.s= (char*)row_vals[pres_state_col].val.string_val;
pres_state.len= strlen(pres_state.s);
trim(&pres_state);
}
prev_did= curr_did;
}
if(rlmi_doc)
{
LM_DBG("timer_send_notify at end len_est = %d resource_added = %d\n", len_est, resource_added);
if (resource_added == 1)
{
send_notify(&rlmi_doc, buf, buf_len, bstr, dialog, hash_code);
}
if(dialog)
{
pkg_free(dialog);
}
dialog= NULL;
}
error:
done:
if(bstr.s)
pkg_free(bstr.s);
if(buf)
pkg_free(buf);
if(dialog)
pkg_free(dialog);
return;
}
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);
}
void timer_send_notify(unsigned int ticks,void *param)
{
db_key_t query_cols[2], update_cols[1], result_cols[7];
db_val_t query_vals[2], update_vals[1];
int did_col, resource_uri_col, auth_state_col, reason_col,
body_col, ctype_col;
int n_result_cols= 0, i;
db_res_t *result= NULL;
char* prev_did= NULL, * curr_did= NULL;
db_row_t *row;
db_val_t *row_vals;
char* resource_uri;
str body;
str callid, to_tag, from_tag;
xmlDocPtr rlmi_doc= NULL;
xmlNodePtr list_node= NULL, instance_node= NULL, resource_node;
unsigned int hash_code= 0;
int len;
int size= BUF_REALLOC_SIZE, buf_len= 0;
char* buf= NULL, *auth_state= NULL;
int contor= 0, auth_state_flag;
str bstr= {0, 0};
str rlmi_cont= {0, 0}, multi_cont;
subs_t* s, *dialog= NULL;
char* rl_uri= NULL;
char* str_aux = NULL;
str ctype, cid;
int add_len;
query_cols[0]= &str_updated_col;
query_vals[0].type = DB_INT;
query_vals[0].nul = 0;
query_vals[0].val.int_val= UPDATED_TYPE;
result_cols[did_col= n_result_cols++]= &str_rlsubs_did_col;
result_cols[resource_uri_col= n_result_cols++]= &str_resource_uri_col;
result_cols[auth_state_col= n_result_cols++]= &str_auth_state_col;
result_cols[ctype_col= n_result_cols++]= &str_content_type_col;
result_cols[reason_col= n_result_cols++]= &str_reason_col;
result_cols[body_col= n_result_cols++]= &str_presence_state_col;
/* query in alfabetical order after rlsusbs_did
* (resource list Subscribe dialog indentifier)*/
if (rls_dbf.use_table(rls_db, &rlpres_table) < 0)
{
LM_ERR("in use_table\n");
goto done;
}
if(rls_dbf.query(rls_db, query_cols, 0, query_vals, result_cols,
1, n_result_cols, &str_rlsubs_did_col, &result)< 0)
{
LM_ERR("in sql query\n");
goto done;
}
if(result== NULL || result->n<= 0)
goto done;
/* update the rlpres table */
update_cols[0]= &str_updated_col;
update_vals[0].type = DB_INT;
update_vals[0].nul = 0;
update_vals[0].val.int_val= NO_UPDATE_TYPE;
if (rls_dbf.use_table(rls_db, &rlpres_table) < 0)
{
LM_ERR("in use_table\n");
goto error;
}
if(rls_dbf.update(rls_db, query_cols, 0, query_vals, update_cols,
update_vals, 1, 1)< 0)
{
LM_ERR("in sql update\n");
goto error;
}
/* generate the boundary string */
bstr.s= generate_string((int)time(NULL), BOUNDARY_STRING_LEN);
if(bstr.s == NULL)
{
LM_ERR("failed to generate random string\n");
goto error;
}
bstr.len= strlen(bstr.s);
/* for the multipart body , use here also an initial allocated
* and reallocated on need buffer */
buf= pkg_malloc(size);
if(buf== NULL)
{
ERR_MEM(PKG_MEM_STR);
}
LM_DBG("found %d records with updated state\n", result->n);
for(i= 0; i< result->n; i++)
{
row = &result->rows[i];
row_vals = ROW_VALUES(row);
curr_did= (char*)row_vals[did_col].val.string_val;
resource_uri= (char*)row_vals[resource_uri_col].val.string_val;
auth_state_flag= row_vals[auth_state_col].val.int_val;
body.s= (char*)row_vals[body_col].val.string_val;
body.len= strlen(body.s);
ctype.s = (char*)row_vals[ctype_col].val.string_val;
ctype.len = strlen(ctype.s);
/* if all the info for one dialog have been collected -> send notify */
/* the 'dialog' variable must be filled with the dialog info */
/* 'buf' must contain the body */
if(prev_did!= NULL && strcmp(prev_did, curr_did))
{
xmlDocDumpMemory(rlmi_doc,(xmlChar**)(void*)&rlmi_cont.s,
&rlmi_cont.len);
multi_cont.s= buf;
multi_cont.len= buf_len;
if(agg_body_sendn_update(&dialog->pres_uri, bstr, &rlmi_cont,
(buf_len==0)?NULL:&multi_cont, dialog, hash_code)<0)
{
LM_ERR("in function agg_body_sendn_update\n");
goto error;
}
xmlFree(rlmi_cont.s);
xmlFreeDoc(rlmi_doc);
rlmi_doc= NULL;
pkg_free(rl_uri);
rl_uri= NULL;
pkg_free(dialog);
dialog= NULL;
}
/* for the new dialog -> search the dialog info and
* fill the dialog structure and start a new rlmi document */
if(prev_did== NULL || strcmp(prev_did, curr_did))
{
/* search the subscription in rlsubs_table*/
if( parse_rlsubs_did(curr_did, &callid, &from_tag, &to_tag)< 0)
{
LM_ERR("bad format for "
"resource list Subscribe dialog indentifier(rlsubs did)\n");
prev_did = NULL;
continue;
}
hash_code= core_hash(&callid, &to_tag, hash_size);
lock_get(&rls_table[hash_code].lock);
s= pres_search_shtable(rls_table,callid,to_tag,from_tag,hash_code);
if(s== NULL)
{
LM_DBG("record not found in hash_table [rlsubs_did]= %s\n",
curr_did);
LM_DBG("callid= %.*s\tfrom_tag= %.*s\tto_tag= %.*s\n",
callid.len, callid.s,from_tag.len,from_tag.s,
to_tag.len,to_tag.s);
lock_release(&rls_table[hash_code].lock);
prev_did = NULL;
continue;
}
LM_DBG("Found rl-subs record in hash table\n");
/* save dialog info and rl_uri*/
dialog= pres_copy_subs(s, PKG_MEM_TYPE);
if(dialog== NULL)
{
LM_ERR("while copying subs_t structure\n");
lock_release(&rls_table[hash_code].lock);
goto done;
}
dialog->expires-= (int)time(NULL);
lock_release(&rls_table[hash_code].lock);
/* make new rlmi and multipart documents */
rlmi_doc= xmlNewDoc(BAD_CAST "1.0");
if(rlmi_doc== NULL)
{
LM_ERR("when creating new xml doc\n");
goto done;
}
list_node= xmlNewNode(NULL, BAD_CAST "list");
if(list_node== NULL)
{
LM_ERR("while creating new xml node\n");
goto done;
}
rl_uri= (char*)pkg_malloc((dialog->pres_uri.len+ 1)* sizeof(char));
if(rl_uri== NULL)
{
ERR_MEM(PKG_MEM_STR);
}
memcpy(rl_uri, dialog->pres_uri.s, dialog->pres_uri.len);
rl_uri[dialog->pres_uri.len]= '\0';
xmlNewProp(list_node, BAD_CAST "uri", BAD_CAST rl_uri);
xmlNewProp(list_node, BAD_CAST "xmlns", BAD_CAST "urn:ietf:params:xml:ns:rlmi");
xmlNewProp(list_node, BAD_CAST "version", BAD_CAST int2str(dialog->version, &len));
xmlNewProp(list_node, BAD_CAST "fullState", BAD_CAST "false");
xmlDocSetRootElement(rlmi_doc, list_node);
buf_len= 0;
/* !!!! for now I will include the auth state without checking if
* it has changed - > in future chech if it works */
}
/* add a node in rlmi_doc and if any presence state registered add
* it in the buffer */
resource_node= xmlNewChild(list_node,NULL,BAD_CAST "resource", NULL);
if(resource_node== NULL)
{
LM_ERR("when adding resource child\n");
goto done;
}
xmlNewProp(resource_node, BAD_CAST "uri", BAD_CAST resource_uri);
/* there might be more records with the same uri- more instances-
* search and add them all */
contor= 0;
while(1)
{
contor++;
cid.s= NULL;
instance_node= xmlNewChild(resource_node, NULL,
BAD_CAST "instance", NULL);
if(instance_node== NULL)
{
LM_ERR("while adding instance child\n");
goto error;
}
str_aux = generate_string(contor, 8);
if(str_aux == NULL)
{
LM_ERR("failed to create random string\n");
goto error;
}
xmlNewProp(instance_node, BAD_CAST "id",
BAD_CAST str_aux);
pkg_free(str_aux);
auth_state= get_auth_string(auth_state_flag);
if(auth_state== NULL)
{
LM_ERR("bad authorization status flag\n");
goto error;
}
xmlNewProp(instance_node, BAD_CAST "state", BAD_CAST auth_state);
if(auth_state_flag & ACTIVE_STATE)
{
cid.s= generate_cid(resource_uri, strlen(resource_uri));
cid.len = strlen(cid.s);
xmlNewProp(instance_node, BAD_CAST "cid", BAD_CAST cid.s);
}
else
if(auth_state_flag & TERMINATED_STATE)
{
xmlNewProp(instance_node, BAD_CAST "reason",
BAD_CAST row_vals[resource_uri_col].val.string_val);
}
/* add in the multipart buffer */
if(cid.s)
{
APPEND_MULTIPART_BODY();
pkg_free(cid.s);
cid.s = NULL;
}
i++;
if(i== result->n)
{
i--;
break;
}
row = &result->rows[i];
row_vals = ROW_VALUES(row);
if(strncmp(row_vals[resource_uri_col].val.string_val,resource_uri,
strlen(resource_uri)) || strncmp(curr_did,
row_vals[did_col].val.string_val, strlen(curr_did)))
{
i--;
break;
}
resource_uri= (char*)row_vals[resource_uri_col].val.string_val;
auth_state_flag= row_vals[auth_state_col].val.int_val;
body.s= (char*)row_vals[body_col].val.string_val;
body.len = strlen(body.s);
}
prev_did= curr_did;
}
if(rlmi_doc)
{
xmlDocDumpMemory( rlmi_doc,(xmlChar**)(void*)&rlmi_cont.s,
&rlmi_cont.len);
multi_cont.s= buf;
multi_cont.len= buf_len;
if(agg_body_sendn_update(&dialog->pres_uri, bstr, &rlmi_cont,
(buf_len==0)?NULL:&multi_cont, dialog, hash_code)<0)
{
LM_ERR("in function agg_body_sendn_update\n");
goto error;
}
xmlFree(rlmi_cont.s);
pkg_free(rl_uri);
rl_uri= NULL;
pkg_free(dialog);
dialog= NULL;
}
error:
done:
if(result)
rls_dbf.free_result(rls_db, result);
if(rlmi_doc)
xmlFreeDoc(rlmi_doc);
if(rl_uri)
pkg_free(rl_uri);
if(bstr.s)
pkg_free(bstr.s);
if(buf)
pkg_free(buf);
if(dialog)
pkg_free(dialog);
return;
}
