int rad_load_proposals(ikev2_ctx *i2,CONF_SECTION *cf)
{
rad_assert(i2!=NULL && cf!=NULL);
CONF_SECTION *cf_prop=NULL;
cf=cf_subsection_find_next(cf,NULL,"proposals");
if(!cf) {
ERROR(IKEv2_LOG_PREFIX "Can't find proposals section");
return -1;
}
int nprop=0;
for(
cf_prop=cf_subsection_find_next(cf,NULL,"proposal");
cf_prop;
cf_prop=cf_subsection_find_next(cf,cf_prop,"proposal")
) {
nprop++;
struct Proposal *prop;
struct Protocol *prot;
prop=AddProposal(&i2->suppProp);
prot=AddProtocol(prop,IKEv2_PID_IKE_SA,0,0);
if(rad_load_transforms(prot,cf_prop)) {
ERROR(IKEv2_LOG_PREFIX "Failed to load proposal (%d)",
nprop);
return -1;
}
}
if(!nprop) {
ERROR(IKEv2_LOG_PREFIX "Can't find any proposal");
return -1;
}
return 0;
}
IpcsClassifierRecord::IpcsClassifierRecord (Tlv tlv)
{
NS_ASSERT_MSG (tlv.GetType () == CsParamVectorTlvValue::Packet_Classification_Rule, "Invalid TLV");
ClassificationRuleVectorTlvValue* rules = ((ClassificationRuleVectorTlvValue*)(tlv.PeekValue ()));
m_priority = 0;
m_index = 0;
m_tosLow = 0;
m_tosHigh = 0;
m_tosMask = 0;
m_cid = 0;
for (std::vector<Tlv*>::const_iterator iter = rules->Begin (); iter != rules->End (); ++iter)
{
switch ((*iter)->GetType ())
{
case ClassificationRuleVectorTlvValue::Priority:
{
m_priority = ((U8TlvValue*)((*iter)->PeekValue ()))->GetValue ();
break;
}
case ClassificationRuleVectorTlvValue::ToS:
{
NS_FATAL_ERROR ("ToS Not implemented-- please implement and contribute a patch");
break;
}
case ClassificationRuleVectorTlvValue::Protocol:
{
ProtocolTlvValue * list = (ProtocolTlvValue *)(*iter)->PeekValue ();
for (std::vector<uint8_t>::const_iterator iter2 = list->Begin (); iter2 != list->End (); ++iter2)
{
AddProtocol (*iter2);
}
break;
}
case ClassificationRuleVectorTlvValue::IP_src:
{
Ipv4AddressTlvValue * list = (Ipv4AddressTlvValue *)(*iter)->PeekValue ();
for (std::vector<Ipv4AddressTlvValue::ipv4Addr>::const_iterator iter2 = list->Begin (); iter2 != list->End (); ++iter2)
{
AddSrcAddr ((*iter2).Address, (*iter2).Mask);
}
break;
}
case ClassificationRuleVectorTlvValue::IP_dst:
{
Ipv4AddressTlvValue * list = (Ipv4AddressTlvValue *)(*iter)->PeekValue ();
for (std::vector<Ipv4AddressTlvValue::ipv4Addr>::const_iterator iter2 = list->Begin (); iter2 != list->End (); ++iter2)
{
AddDstAddr ((*iter2).Address, (*iter2).Mask);
}
break;
}
case ClassificationRuleVectorTlvValue::Port_src:
{
PortRangeTlvValue * list = (PortRangeTlvValue *)(*iter)->PeekValue ();
for (std::vector<PortRangeTlvValue::PortRange>::const_iterator iter2 = list->Begin (); iter2 != list->End (); ++iter2)
{
AddSrcPortRange ((*iter2).PortLow, (*iter2).PortHigh);
}
break;
}
case ClassificationRuleVectorTlvValue::Port_dst:
{
PortRangeTlvValue * list = (PortRangeTlvValue *)(*iter)->PeekValue ();
for (std::vector<PortRangeTlvValue::PortRange>::const_iterator iter2 = list->Begin (); iter2 != list->End (); ++iter2)
{
AddDstPortRange ((*iter2).PortLow, (*iter2).PortHigh);
}
break;
}
case ClassificationRuleVectorTlvValue::Index:
{
m_index = ((U16TlvValue*)((*iter)->PeekValue ()))->GetValue ();
break;
}
}
}
}
static void GIOdispatch(GIOControl *gc, enum giofuncs gf) {
unichar_t *temp, *pt, *tpt;
int i;
gc->gf = gf;
if ( _GIO_stdfuncs.useragent == NULL )
_GIO_stdfuncs.useragent = copy("*****@*****.**");
temp = _GIO_translateURL(gc->path,gf);
if ( temp!=NULL ) {
if ( gc->origpath==NULL )
gc->origpath = gc->path;
else
free(gc->path);
gc->path = temp;
}
if ( gc->topath!=NULL ) {
temp = _GIO_translateURL(gc->topath,gf);
if ( temp!=NULL ) {
free(gc->topath);
gc->topath = temp;
}
if ( gf==gf_renamefile ) {
if (( pt = uc_strstr(gc->path,"://"))== NULL )
pt = gc->path;
else {
pt=u_strchr(pt+3,'/');
if ( pt==NULL ) pt = gc->path+u_strlen(gc->path);
}
if (( tpt = uc_strstr(gc->topath,"://"))== NULL )
tpt = gc->topath;
else {
tpt=u_strchr(tpt+3,'/');
if ( tpt==NULL ) tpt = gc->topath+u_strlen(gc->topath);
}
if ( tpt-gc->topath!=pt-gc->path ||
u_strnmatch(gc->path,gc->topath,pt-gc->path)!=0 ) {
_GIO_reporterror(gc,EXDEV);
return;
}
}
}
pt = uc_strstr(gc->path,"://");
if ( pt!=NULL ) {
for ( i=0; i<plen; ++i )
if ( u_strnmatch(protocols[i].proto,gc->path,pt-gc->path)==0 )
break;
if ( i>=plen && !AddProtocol(gc->path,pt-gc->path) ) {
gc->protocol_index = -2;
gc->return_code = 501;
gc->error = err501;
uc_strcpy(gc->status,"No support for browsing: ");
u_strncpy(gc->status+u_strlen(gc->status), gc->path, pt-gc->path );
gc->done = true;
(gc->receiveerror)(gc);
return;
}
gc->protocol_index = i;
if ( !protocols[i].dothread )
(protocols[i].dispatcher)(gc);
else {
#ifndef HAVE_PTHREAD_H
gc->return_code = 501;
gc->error = err501;
uc_strcpy(gc->status,"No support for protocol");
gc->done = true;
(gc->receiveerror)(gc);
return;
#else
static pthread_cond_t initcond = PTHREAD_COND_INITIALIZER;
static pthread_mutex_t initmutex = PTHREAD_MUTEX_INITIALIZER;
/* could put stuff here to queue functions if we get too many */
/* threads, or perhaps even a thread pool */
uc_strcpy(gc->status,"Queued");
gc->threaddata = (struct gio_threaddata *) malloc(sizeof(struct gio_threaddata));
gc->threaddata->mutex = initmutex;
gc->threaddata->cond = initcond;
if ( _GIO_stdfuncs.gdraw_sync_thread!=NULL )
(_GIO_stdfuncs.gdraw_sync_thread)(NULL,NULL,NULL);
pthread_create(&gc->threaddata->thread,NULL,
(ptread_startfunc_t *) (protocols[i].dispatcher), gc);
#endif
}
} else {
gc->protocol_index = -1;
_GIO_localDispatch(gc);
}
}
CUrlRichEditCtrl::CUrlRichEditCtrl() : m_nContextUrl(-1), m_lpDragObject(NULL)
{
AddProtocol(_T("www."), FALSE);
AddProtocol(_T("http://"), FALSE);
AddProtocol(_T("https://"), FALSE);
AddProtocol(_T("ftp://"), FALSE);
AddProtocol(_T("outlook:"), FALSE);
AddProtocol(_T("mailto:"), FALSE);
AddProtocol(_T("Notes://"), FALSE);
AddProtocol(_T("evernote://"), FALSE);
AddProtocol(_T("onenote:///"), FALSE);
AddProtocol(_T("excel:"), FALSE);
AddProtocol(_T("winword:"), FALSE);
AddProtocol(_T("thunderlink://"), FALSE);
AddProtocol(_T("wiki:"), FALSE);
// Note: The correct file URI protocol has an extra trailing slash
// but we use the incorrect one to pick up badly formatted URIs
AddProtocol(_T("file://"), FALSE);
}
