void Opal::Presentity::edit_presentity () { boost::shared_ptr<Ekiga::FormRequestSimple> request = boost::shared_ptr<Ekiga::FormRequestSimple> (new Ekiga::FormRequestSimple (boost::bind (&Opal::Presentity::edit_presentity_form_submitted, this, _1, _2, _3))); /* Translators: This is Edit name of the contact * e.g. Editing Contact Claire Fleury. */ char *title = g_strdup_printf (_("Editing Contact %s"), get_name ().c_str ()); request->title (title); g_free (title); request->action (_("Done")); request->text ("name", _("Name"), get_name (), _("John Doe"), Ekiga::FormVisitor::STANDARD, false, false); request->text ("uri", _("URI"), get_uri (), _("sip:[email protected]"), Ekiga::FormVisitor::URI, false, false); request->editable_list ("groups", _("Groups"), get_groups (), existing_groups ()); questions (request); }
static HRESULT WINAPI HTMLLocation_get_port(IHTMLLocation *iface, BSTR *p) { HTMLLocation *This = impl_from_IHTMLLocation(iface); DWORD port; IUri *uri; HRESULT hres; TRACE("(%p)->(%p)\n", This, p); if(!p) return E_POINTER; if(!(uri = get_uri(This))) { FIXME("No current URI\n"); return E_NOTIMPL; } hres = IUri_GetPort(uri, &port); if(FAILED(hres)) return hres; if(hres == S_OK) { static const WCHAR formatW[] = {'%','u',0}; WCHAR buf[12]; sprintfW(buf, formatW, port); *p = SysAllocString(buf); }else { *p = SysAllocStringLen(NULL, 0); } if(!*p) return E_OUTOFMEMORY; return S_OK; }
void location_goto(struct document_view *doc_view, unsigned char *url) { unsigned char *new_abs_url; struct uri *new_uri; struct delayed_goto *deg; /* Workaround for bug 611. Does not crash, but may lead to infinite loop.*/ if (!doc_view) return; new_abs_url = join_urls(doc_view->document->uri, trim_chars(url, ' ', 0)); if (!new_abs_url) return; new_uri = get_uri(new_abs_url, 0); mem_free(new_abs_url); if (!new_uri) return; deg = mem_calloc(1, sizeof(*deg)); if (!deg) { done_uri(new_uri); return; } assert(doc_view->vs); deg->vs = doc_view->vs; deg->uri = new_uri; /* It does not seem to be very safe inside of frames to * call goto_uri() right away. */ register_bottom_half(delayed_goto, deg); }
static HRESULT WINAPI HTMLLocation_get_hash(IHTMLLocation *iface, BSTR *p) { HTMLLocation *This = impl_from_IHTMLLocation(iface); BSTR hash; IUri *uri; HRESULT hres; TRACE("(%p)->(%p)\n", This, p); if(!p) return E_POINTER; if(!(uri = get_uri(This))) { FIXME("No current URI\n"); return E_NOTIMPL; } hres = IUri_GetFragment(uri, &hash); if(hres == S_OK) { *p = hash; }else if(hres == S_FALSE) { SysFreeString(hash); *p = NULL; }else { return hres; } return S_OK; }
static struct uri * proxy_uri(struct uri *uri, unsigned char *proxy, struct connection_state *error_state) { struct string string; if (init_string(&string) && string_concat(&string, "proxy://", proxy, "/", (unsigned char *) NULL) && add_uri_to_string(&string, uri, URI_BASE)) { /* There is no need to use URI_BASE when calling get_uri() * because URI_BASE should not add any fragments in the first * place. */ uri = get_uri(string.source, 0); /* XXX: Assume the problem is due to @proxy having bad format. * This is a lot faster easier than checking the format. */ if (!uri) *error_state = connection_state(S_PROXY_ERROR); } else { uri = NULL; *error_state = connection_state(S_OUT_OF_MEM); } done_string(&string); return uri; }
void Local::Presentity::edit_presentity () { ClusterPtr cluster = local_cluster.lock (); if (!cluster) return; boost::shared_ptr<Ekiga::FormRequestSimple> request = boost::shared_ptr<Ekiga::FormRequestSimple> (new Ekiga::FormRequestSimple (boost::bind (&Local::Presentity::edit_presentity_form_submitted, this, _1, _2))); std::string name = get_name (); std::string uri = get_uri (); std::set<std::string> groups = get_groups (); std::set<std::string> all_groups = cluster->existing_groups (); request->title (_("Edit roster element")); request->instructions (_("Please fill in this form to change an existing " "element of ekiga's internal roster")); request->text ("name", _("Name:"), name, _("Name of the contact, as shown in your roster")); request->text ("uri", _("Address:"), uri, _("Address, e.g. sip:[email protected]; if you do not specify the host part, e.g. sip:xyz, then you can choose it by right-clicking on the contact in roster")); request->boolean ("preferred", _("Is a preferred contact"), is_preferred ()); request->editable_set ("groups", _("Choose groups:"), groups, all_groups); questions (request); }
Glib::ustring genericFilechooserWindow::getURIToFile ( void ) { return get_uri(); }
struct uri * get_proxied_uri(struct uri *uri) { if (uri->protocol == PROTOCOL_PROXY) return get_uri(uri->data, URI_BASE); return get_composed_uri(uri, URI_BASE); }
static int setup_http_build_200(http_cb_t * phttp, mime_header_t * presponse_hdr) { char buf[128]; const char *data; const char * type; const cooked_data_types_t *pckd; int dlen; mime_hdr_datatype_t dtype; int len; // Setup content length if (!get_cooked_known_header_data(presponse_hdr, MIME_HDR_CONTENT_LENGTH, &pckd, &dlen, &dtype)) { if (dtype == DT_SIZE) { phttp->content_length = pckd->u.dt_size.ll; } if( !CHECK_HTTP_FLAG(phttp, HRF_TRANSCODE_CHUNKED) ) { len = snprintf(buf, sizeof(buf), "%ld", CHECK_HTTP_FLAG(phttp, HRF_MULTIPART_RESPONSE) ? phttp->pseudo_content_length : phttp->content_length); add_known_header(presponse_hdr, MIME_HDR_CONTENT_LENGTH, buf, len); } } glob_http_tot_content_length ++; if (!is_known_header_present(presponse_hdr, MIME_HDR_CONTENT_TYPE)) { const namespace_config_t *nsc; /* Only fill up content_type when it is NFS OM */ nsc = phttp->nsconf; if(nsc && nsc->http_config) { if((nsc->http_config->origin.select_method == OSS_NFS_CONFIG) || (nsc->http_config->origin.select_method == OSS_NFS_SERVER_MAP)) { get_uri(phttp, &data, &len); type = get_http_content_type(data, len); add_known_header(presponse_hdr, MIME_HDR_CONTENT_TYPE, type, strlen(type)); } } } delete_known_header(presponse_hdr, MIME_HDR_CONNECTION) ; if( CHECK_HTTP_FLAG(phttp, HRF_CONNECTION_KEEP_ALIVE) ) { add_known_header(presponse_hdr, MIME_HDR_CONNECTION, "Keep-Alive", 10); SET_HTTP_FLAG(phttp, HRF_CONNECTION_KEEP_ALIVE); } else { add_known_header(presponse_hdr, MIME_HDR_CONNECTION, "Close", 5); CLEAR_HTTP_FLAG(phttp, HRF_CONNECTION_KEEP_ALIVE); } #if 0 add_known_header(presponse_hdr, MIME_HDR_CACHE_CONTROL, "no-cache", 8); #endif return 1; }
int add_favorite(struct tab *t, struct karg *args) { char file[PATH_MAX]; FILE *f; char *line = NULL; size_t urilen, linelen; const gchar *uri, *title; if (t == NULL) return (1); /* don't allow adding of xtp pages to favorites */ if (t->xtp_meaning != XT_XTP_TAB_MEANING_NORMAL) { show_oops(t, "%s: can't add xtp pages to favorites", __func__); return (1); } snprintf(file, sizeof file, "%s" PS "%s", work_dir, XT_FAVS_FILE); if ((f = fopen(file, "r+")) == NULL) { show_oops(t, "Can't open favorites file: %s", strerror(errno)); return (1); } title = get_title(t, FALSE); uri = get_uri(t); if (title == NULL || uri == NULL) { show_oops(t, "can't add page to favorites"); goto done; } urilen = strlen(uri); for (;;) { if ((line = fparseln(f, &linelen, NULL, NULL, 0)) == NULL) if (feof(f) || ferror(f)) break; if (linelen == urilen && !strcmp(line, uri)) goto done; free(line); line = NULL; } fprintf(f, "\n%s\n%s", title, uri); done: if (line) free(line); fclose(f); update_favorite_tabs(NULL); return (0); }
char * zurl(const char * url, char * opt){ const char * host = get_host(url); const char * uri = get_uri(url); unsigned int m,n; m = n = 0; struct field * data = get_data(uri,&m); struct field * params = get_params(uri,&n); char * buffer = http_request("GET", host, uri, HTTP_EDITION, params, m, data, n,1); free_kv(data,m); free_kv(params,n); return buffer; }
void Local::Presentity::remove () { boost::shared_ptr<Ekiga::PresenceCore> pcore = presence_core.lock (); if (pcore) pcore->unfetch_presence (get_uri ()); xmlUnlinkNode (node); xmlFreeNode (node); trigger_saving (); removed (); }
static JSBool smjs_load_uri(JSContext *ctx, uintN argc, jsval *rval) { jsval *argv = JS_ARGV(ctx, rval); struct smjs_load_uri_hop *hop; struct download *download; JSString *jsstr; unsigned char *uri_string; struct uri *uri; if (argc < 2) return JS_FALSE; jsstr = JS_ValueToString(smjs_ctx, argv[0]); uri_string = JS_EncodeString(smjs_ctx, jsstr); uri = get_uri(uri_string, 0); if (!uri) return JS_FALSE; download = mem_alloc(sizeof(*download)); if (!download) { done_uri(uri); return JS_FALSE; } hop = mem_alloc(sizeof(*hop)); if (!hop) { mem_free(download); done_uri(uri); return JS_FALSE; } hop->callback = argv[1]; hop->ses = smjs_ses; if (!JS_AddNamedValueRoot(smjs_ctx, &hop->callback, "smjs_load_uri_hop.callback")) { mem_free(hop); mem_free(download); done_uri(uri); return JS_FALSE; } download->data = hop; download->callback = (download_callback_T *) smjs_loading_callback; load_uri(uri, NULL, download, PRI_MAIN, CACHE_MODE_NORMAL, -1); done_uri(uri); return JS_TRUE; }
lib::error_code process_handshake(request_type const & req, std::string const & subprotocol, response_type & res) const { std::array<char, 16> key_final; // copy key1 into final key decode_client_key(req.get_header("Sec-WebSocket-Key1"), &key_final[0]); // copy key2 into final key decode_client_key(req.get_header("Sec-WebSocket-Key2"), &key_final[4]); // copy key3 into final key // key3 should be exactly 8 bytes. If it is more it will be truncated // if it is less the final key will almost certainly be wrong. // TODO: decide if it is best to silently fail here or produce some sort // of warning or exception. const std::string& key3 = req.get_header("Sec-WebSocket-Key3"); auto sz = std::min(size_t(8), key3.size()); std::copy(key3.begin(), key3.begin() + sz, key_final.begin() + 8); res.append_header( "Sec-WebSocket-Key3", md5::md5_hash_string(std::string(key_final.begin(), key_final.end())) ); res.append_header("Upgrade","WebSocket"); res.append_header("Connection","Upgrade"); // Echo back client's origin unless our local application set a // more restrictive one. if (res.get_header("Sec-WebSocket-Origin") == "") { res.append_header("Sec-WebSocket-Origin",req.get_header("Origin")); } // Echo back the client's request host unless our local application // set a different one. if (res.get_header("Sec-WebSocket-Location") == "") { uri_ptr uri = get_uri(req); res.append_header("Sec-WebSocket-Location",uri->str()); } if (subprotocol != "") { res.replace_header("Sec-WebSocket-Protocol",subprotocol); } return lib::error_code(); }
/* Establish connection to a peer. As a backend, it uses the internal and more * generic connection creater which takes care of DNS querying etc. */ enum bittorrent_state make_bittorrent_peer_connection(struct bittorrent_connection *bittorrent, struct bittorrent_peer *peer_info) { enum bittorrent_state result = BITTORRENT_STATE_OUT_OF_MEM; struct uri *uri = NULL; struct string uri_string = NULL_STRING; struct bittorrent_peer_connection *peer; peer = init_bittorrent_peer_connection(-1); if (!peer) goto out; peer->local.initiater = 1; add_to_list(bittorrent->peers, peer); peer->bittorrent = bittorrent; peer->bitfield = init_bitfield(bittorrent->meta.pieces); if (!peer->bitfield) goto out; memcpy(peer->id, peer_info->id, sizeof(peer->id)); /* XXX: Very hacky; construct a fake URI from which make_connection() * can extract the IP address and port number. */ /* FIXME: Rather change the make_connection() interface. This is an ugly * hack. */ if (!init_string(&uri_string)) goto out; if (!add_format_to_string(&uri_string, #ifdef CONFIG_IPV6 strchr((const char *)peer_info->ip, ':') ? "bittorrent-peer://[%s]:%u/" : #endif "bittorrent-peer://%s:%u/", peer_info->ip, (unsigned) peer_info->port)) goto out; uri = get_uri(uri_string.source, 0); if (!uri) goto out; make_connection(peer->socket, uri, send_bittorrent_peer_handshake, 1); result = BITTORRENT_STATE_OK; out: if (uri) done_uri(uri); done_string(&uri_string); if (peer && result != BITTORRENT_STATE_OK) done_bittorrent_peer_connection(peer); return result; }
void file_uri_replace(SessionId sessionId, const char * pJoiner, std::string & data) { qcc::String p; vRecvFiles::iterator iter; size_t start_pos = 0; size_t end_pos; while ((start_pos = data.find("file://", start_pos)) != std::string::npos) { if ((end_pos = data.find("\'", start_pos)) != std::string::npos) { if ((iter = std::find_if(gRecvFiles.begin(), gRecvFiles.end(), find_uri(sessionId, pJoiner, data.substr(start_pos, end_pos - start_pos).data()))) != gRecvFiles.end()) data.replace(start_pos, end_pos - start_pos, get_uri((*iter)->path.data()).data()); } start_pos++; } }
bool RL::Entry::populate_menu (Ekiga::MenuBuilder& builder) { bool populated = false; boost::shared_ptr<Ekiga::PresenceCore> presence_core = core.get<Ekiga::PresenceCore> ("presence-core"); std::string uri(get_uri ()); builder.add_action ("refresh", _("_Refresh"), boost::bind (&RL::Entry::refresh, this)); if ( !uri.empty ()) populated = presence_core->populate_presentity_menu (Ekiga::PresentityPtr (this, null_deleter ()), uri, builder); return populated; }
char * join(char *baseuri, char *reluri){ URI *uri; char *res; int r; uri = parseuris(baseuri,reluri); if(!uri) return NULL; res = get_uri(uri); uri_destroy(uri); return res; }
void Opal::Presentity::add_actions () { /* Pull actions */ boost::shared_ptr<Ekiga::PresenceCore> pcore = presence_core.lock (); if (pcore) pcore->pull_actions (*this, get_name (), get_uri ()); add_action (Ekiga::ActionPtr (new Ekiga::Action ("edit", _("_Edit"), boost::bind (&Opal::Presentity::edit_presentity, this)))); add_action (Ekiga::ActionPtr (new Ekiga::Action ("remove", _("_Remove"), boost::bind (&Opal::Presentity::remove, this)))); add_action (Ekiga::ActionPtr (new Ekiga::Action ("rename", _("Rename _Groups"), boost::bind (&Opal::Account::on_rename_group, (Opal::Account *) &account, get_groups ())))); }
ret_code_t fumi_block_setsource(void) { SaHpiBankNumT banknum; SaHpiTextBufferT uri; if ( get_banknum( &banknum) != HPI_SHELL_OK ) { return HPI_SHELL_PARM_ERROR; } if ( get_uri( &uri) != HPI_SHELL_OK ) { return HPI_SHELL_PARM_ERROR; } return set_source( Domain->sessionId, fumi_block_env.rptid, fumi_block_env.fuminum, banknum, &uri ); }
void handshake_response(const http::parser::request& request,http::parser::response& response) { char key_final[16]; // copy key1 into final key decode_client_key(request.header("Sec-WebSocket-Key1"), &key_final[0]); // copy key2 into final key decode_client_key(request.header("Sec-WebSocket-Key2"), &key_final[4]); // copy key3 into final key // key3 should be exactly 8 bytes. If it is more it will be truncated // if it is less the final key will almost certainly be wrong. // TODO: decide if it is best to silently fail here or produce some sort // of warning or exception. const std::string& key3 = request.header("Sec-WebSocket-Key3"); std::copy(key3.c_str(), key3.c_str()+std::min(static_cast<size_t>(8), key3.size()), &key_final[8]); m_key3 = md5_hash_string(std::string(key_final,16)); response.add_header("Upgrade","websocket"); response.add_header("Connection","Upgrade"); // TODO: require headers that need application specific information? // Echo back client's origin unless our local application set a // more restrictive one. if (response.header("Sec-WebSocket-Origin") == "") { response.add_header("Sec-WebSocket-Origin",request.header("Origin")); } // Echo back the client's request host unless our local application // set a different one. if (response.header("Sec-WebSocket-Location") == "") { // TODO: extract from host header rather than hard code uri_ptr uri = get_uri(request); response.add_header("Sec-WebSocket-Location",uri->str()); } }
static GFile * get_download_location (BuilderSourceFile *self, gboolean *is_inline, BuilderContext *context, GError **error) { g_autoptr(SoupURI) uri = NULL; const char *path; g_autofree char *base_name = NULL; GFile *download_dir = NULL; g_autoptr(GFile) sha256_dir = NULL; g_autoptr(GFile) file = NULL; uri = get_uri (self, error); if (uri == NULL) return FALSE; path = soup_uri_get_path (uri); if (g_str_has_prefix (self->url, "data:")) { *is_inline = TRUE; return g_file_new_for_path ("inline data"); } base_name = g_path_get_basename (path); if (self->sha256 == NULL || *self->sha256 == 0) { g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED, "Sha256 not specified"); return FALSE; } download_dir = builder_context_get_download_dir (context); sha256_dir = g_file_get_child (download_dir, self->sha256); file = g_file_get_child (sha256_dir, base_name); *is_inline = FALSE; return g_steal_pointer (&file); }
void html_base(struct html_context *html_context, unsigned char *a, unsigned char *xxx3, unsigned char *xxx4, unsigned char **xxx5) { unsigned char *al; al = get_url_val(a, (unsigned char *)"href", html_context->doc_cp); if (al) { unsigned char *base = join_urls(html_context->base_href, al); struct uri *uri = base ? get_uri(base, 0) : NULL; mem_free(al); mem_free_if(base); if (uri) { done_uri(html_context->base_href); html_context->base_href = uri; } } al = get_target(html_context->options, a); if (al) mem_free_set(&html_context->base_target, al); }
bool Local::Presentity::populate_menu (Ekiga::MenuBuilder &builder) { bool populated = false; boost::shared_ptr<Ekiga::PresenceCore> pcore = presence_core.lock (); if (!pcore) return false; populated = pcore->populate_presentity_menu (PresentityPtr(this, null_deleter ()), get_uri (), builder); if (populated) builder.add_separator (); builder.add_action ("edit", _("_Edit"), boost::bind (&Local::Presentity::edit_presentity, this)); builder.add_action ("remove", _("_Remove"), boost::bind (&Local::Presentity::remove, this)); return true; }
static HRESULT WINAPI HTMLLocation_get_protocol(IHTMLLocation *iface, BSTR *p) { HTMLLocation *This = impl_from_IHTMLLocation(iface); BSTR protocol, ret; unsigned len; IUri *uri; HRESULT hres; TRACE("(%p)->(%p)\n", This, p); if(!p) return E_POINTER; if(!(uri = get_uri(This))) { FIXME("No current URI\n"); return E_NOTIMPL; } hres = IUri_GetSchemeName(uri, &protocol); if(FAILED(hres)) return hres; if(hres == S_FALSE) { SysFreeString(protocol); *p = NULL; return S_OK; } len = SysStringLen(protocol); ret = SysAllocStringLen(protocol, len+1); SysFreeString(protocol); if(!ret) return E_OUTOFMEMORY; ret[len] = ':'; *p = ret; return S_OK; }
void Pane::save_state(QSettings *s) { s->setValue("path", get_uri()); }
int http_session(int* connect_fd,struct sockaddr_in * client_addr) { char recv_buf[RECV_BUFFER_SIZE+1]; unsigned char send_buf[SEND_BUFFER_SIZE+1]; unsigned char file_buf[FILE_MAX_SIZE+1]; memset(recv_buf,'\0',sizeof(recv_buf)); memset(send_buf,'\0',sizeof(send_buf)); memset(file_buf,'\0',sizeof(file_buf)); char uri_buf[URI_SIZE+1]; memset(uri_buf,'\0',sizeof(uri_buf)); int maxfd=*connect_fd+1; fd_set read_set; FD_ZERO(&read_set); struct timeval timeout; timeout.tv_sec=TIME_OUT_SEC; timeout.tv_usec=TIME_OUT_USEC; int flag=1; int res=0; int read_bytes=0; int send_bytes=0; int file_size=0; char * mime_type; int uri_status; FD_SET(*connect_fd,&read_set); while(flag) { res=select(maxfd,&read_set,NULL,NULL,&timeout); switch(res) { case -1: perror("select () error ,in http_session.c"); close(*connect_fd); return -1; break; case 0: continue; break; default: if(FD_ISSET(*connect_fd,&read_set)) { memset(recv_buf,'\0',sizeof(recv_buf)); if((read_bytes=recv(*connect_fd,recv_buf,RECV_BUFFER_SIZE,0))==0) { return 0; }else if(read_bytes>0) { if(is_http_protocol(recv_buf)==0) { fprintf(stderr,"not httlp protocol \n"); close(*connect_fd); return -1; }else { memset(uri_buf,'\0',sizeof(uri_buf)); if(get_uri(recv_buf,uri_buf)==NULL) { uri_status=URI_TOO_LONG; } else { printf("URI:%s\n",uri_buf); uri_status=get_uri_status(uri_buf); switch(uri_status) { case FILE_OK: printf("file ok\n"); mime_type=get_mime_type(uri_buf); printf("mime type :%s\n",mime_type); file_size=get_file_disk(uri_buf,file_buf); send_bytes=reply_normal_information(send_buf,file_buf,file_size,mime_type); break; case FILE_NOT_FOUND: printf("in switch on case FILE_NOT_FOUND\n"); send_bytes=set_error_information(send_buf,FILE_NOT_FOUND); break; case FILE_FORBIDEN: break; default: break; } send(*connect_fd,send_buf,send_bytes,0); } } } } } } return 0; }
bool Local::Presentity::has_uri (const std::string uri) const { return uri == get_uri (); }
/* Authorize digest credentials */ int authorize(struct sip_msg* msg, str* realm, int hftype) { auth_result_t ret; struct hdr_field* h; auth_body_t* cred = NULL; str* uri; struct sip_uri puri; str domain; domain = *realm; /* see what is to do after a first look at the message */ ret = pre_auth(msg, &domain, hftype, &h); switch(ret) { case ERROR: return 0; case AUTHORIZED: return 1; case NO_CREDENTIALS: cred = NULL; break; case DO_AUTHORIZATION: cred = (auth_body_t*)h->parsed; break; } if (get_uri(msg, &uri) < 0) { LOG(L_ERR, M_NAME":authorize(): From/To URI not found\n"); return -1; } if (parse_uri(uri->s, uri->len, &puri) < 0) { LOG(L_ERR, M_NAME":authorize(): Error while parsing From/To URI\n"); return -1; } // user.s = (char *)pkg_malloc(puri.user.len); // un_escape(&(puri.user), &user); /* parse the ruri, if not yet */ if(msg->parsed_uri_ok==0 && parse_sip_msg_uri(msg)<0) { LOG(L_ERR,M_NAME":authorize(): ERROR while parsing the Request-URI\n"); return -1; } /* preliminary check */ if(cred) { if (puri.host.len != cred->digest.realm.len) { DBG(M_NAME":authorize(): Credentials realm and URI host do not " "match\n"); return -1; } if (strncasecmp(puri.host.s, cred->digest.realm.s, puri.host.len) != 0) { DBG(M_NAME":authorize(): Credentials realm and URI host do not " "match\n"); return -1; } } if( diameter_authorize(cred?h:NULL, &msg->first_line.u.request.method, puri, msg->parsed_uri, msg->id, rb) != 1) { send_resp(msg, 500, "Internal Server Error", NULL, 0); return -1; } if( srv_response(msg, rb, hftype) != 1 ) return -1; mark_authorized_cred(msg, h); return 1; }
void Local::Presentity::edit_presentity_form_submitted (bool submitted, Ekiga::Form &result) { if (!submitted) return; const std::string new_name = result.text ("name"); const std::set<std::string> groups = get_groups (); const std::set<std::string> new_groups = result.editable_set ("groups"); std::string new_uri = result.text ("uri"); const std::string uri = get_uri (); bool preferred = result.boolean ("preferred"); std::set<xmlNodePtr> nodes_to_remove; new_uri = canonize_uri (new_uri); for (xmlNodePtr child = node->children ; child != NULL ; child = child->next) { if (child->type == XML_ELEMENT_NODE && child->name != NULL) { if (xmlStrEqual (BAD_CAST ("name"), child->name)) { robust_xmlNodeSetContent (node, &child, "name", new_name); } } } if (uri != new_uri) { boost::shared_ptr<Ekiga::PresenceCore> pcore = presence_core.lock (); if (pcore) { pcore->unfetch_presence (uri); pcore->fetch_presence (new_uri); } presence = "unknown"; xmlSetProp (node, (const xmlChar*)"uri", (const xmlChar*)new_uri.c_str ()); } // the first loop looks at groups we were in : are we still in ? for (xmlNodePtr child = node->children ; child != NULL ; child = child->next) { if (child->type == XML_ELEMENT_NODE && child->name != NULL) { if (xmlStrEqual (BAD_CAST ("group"), child->name)) { xmlChar* xml_str = xmlNodeGetContent (child); if (xml_str != NULL) { if (new_groups.find ((const char*) xml_str) == new_groups.end ()) { nodes_to_remove.insert (child); // don't free what we loop on! } xmlFree (xml_str); } } } } // ok, now we can clean up! for (std::set<xmlNodePtr>::iterator iter = nodes_to_remove.begin (); iter != nodes_to_remove.end (); ++iter) { xmlUnlinkNode (*iter); xmlFreeNode (*iter); } // the second loop looking for groups we weren't in but are now for (std::set<std::string>::const_iterator iter = new_groups.begin (); iter != new_groups.end (); iter++) { if (std::find (groups.begin (), groups.end (), *iter) == groups.end ()) { xmlNewChild (node, NULL, BAD_CAST "group", BAD_CAST robust_xmlEscape (node->doc, *iter).c_str ()); } } if (preferred) { xmlSetProp (node, BAD_CAST "preferred", BAD_CAST "true"); } else { xmlSetProp (node, BAD_CAST "preferred", BAD_CAST "false"); } updated (); trigger_saving (); }