/* length=0 specifies ASCIIZ data */
int SMBCALL smb_getmsgidx_by_hash(smb_t* smb, smbmsg_t* msg, unsigned source
,unsigned flags, const void* data, size_t length)
{
int retval;
size_t n=2;
hash_t** hashes;
hash_t found;
if((hashes=(hash_t**)calloc(n, sizeof(hash_t*)))==NULL)
return(SMB_ERR_MEM);
if(length==0)
hashes[0]=smb_hashstr(0,0,source,flags,data);
else
hashes[0]=smb_hash(0,0,source,flags,data,length);
if(hashes[0]==NULL) {
FREE_LIST(hashes,n);
return(SMB_ERR_MEM);
}
if((retval=smb_findhash(smb, hashes, &found, 1<<source, FALSE))==SMB_SUCCESS) {
if(found.number==0)
retval=SMB_FAILURE; /* use better error value here? */
else {
msg->hdr.number=found.number;
retval=smb_getmsgidx(smb, msg);
}
}
FREE_LIST(hashes,n);
return(retval);
}
Card::~Card()
{
// Delete stack-allocated tags
FREE_LIST(tags, Tag)
// Delete child cards
FREE_LIST(attached, Card)
delete scriptHost;
}
/* Calculates and stores the hashes for a single message */
int SMBCALL smb_hashmsg(smb_t* smb, smbmsg_t* msg, const uchar* text, BOOL update)
{
size_t n;
int retval=SMB_SUCCESS;
hash_t found;
hash_t** hashes; /* This is a NULL-terminated list of hashes */
if(smb->status.attr&SMB_EMAIL)
return(SMB_SUCCESS);
hashes=smb_msghashes(msg,text);
if(smb_findhash(smb, hashes, &found, SMB_HASH_SOURCE_ALL, update)==SMB_SUCCESS && !update) {
retval=SMB_DUPE_MSG;
safe_snprintf(smb->last_error,sizeof(smb->last_error)
,"duplicate %s: %s found in message #%lu"
,smb_hashsourcetype(found.source)
,smb_hashsource(msg,found.source)
,found.number);
} else
if((retval=smb_addhashes(smb,hashes,/* skip_marked? */TRUE))==SMB_SUCCESS)
msg->flags|=MSG_FLAG_HASHED;
FREE_LIST(hashes,n);
return(retval);
}
// listen for a reload
void* reloader( void* arg ) {
while( g_running ) {
sem_wait( &reload_sem );
if( !g_running )
return NULL;
// do the reload
struct md_syndicate_conf new_conf;
memset( &new_conf, 0, sizeof(new_conf) );
if( g_config_file == NULL )
continue;
int rc = md_read_conf( g_config_file, &new_conf );
if( rc != 0 ) {
errorf("md_read_conf rc = %d\n", rc );
continue;
}
// get the users next
struct md_user_entry** users = md_parse_secrets_file( g_secrets_file );
if( users == NULL ) {
errorf("%s", "md_parse_secrets_file rc = NULL\n");
continue;
}
// reload the HTTP server with new users
md_http_wlock( &http );
struct md_user_entry** old_users = http.users;
char** old_replicas = g_conf->replica_urls;
http.users = users;
g_conf->replica_urls = new_conf.replica_urls;
new_conf.replica_urls = NULL;
md_http_unlock( &http );
if( old_replicas )
FREE_LIST( old_replicas );
for( int i = 0; old_users[i] != NULL; i++ ) {
md_free_user_entry( old_users[i] );
free( old_users[i] );
}
free( old_users );
md_free_conf( &new_conf );
// do the reload
http_reload( users, g_conf->replica_urls );
}
return NULL;
}
void confread_free(struct starter_config *cfg)
{
int i;
struct starter_conn *conn, *c;
FREE_LIST(cfg->setup.interfaces);
pfreeany(cfg->setup.virtual_private);
pfreeany(cfg->setup.listen);
for(i=0 ;i<KSF_MAX; i++) {
pfreeany(cfg->setup.strings[i]);
}
confread_free_conn(&(cfg->conn_default));
for(conn = cfg->conns.tqh_first; conn != NULL; ) {
c = conn;
conn = conn->link.tqe_next;
confread_free_conn(c);
pfree(c);
}
pfree(cfg);
}
void confread_free(struct starter_config *cfg)
{
FREE_LIST(cfg->setup.interfaces);
pfree(cfg->ctlbase);
int i;
for (i = 0; i < KSF_MAX; i++)
pfreeany(cfg->setup.strings[i]);
confread_free_conn(&cfg->conn_default);
struct starter_conn *conn;
for (conn = cfg->conns.tqh_first; conn != NULL; ) {
struct starter_conn *c = conn;
conn = conn->link.tqe_next;
confread_free_conn(c);
pfree(c);
}
pfree(cfg);
}
bool test_list()
{
bool test_result = true; // true == passed
DEFINE_LIST(int, int_list);
DEFINE_LIST(Vector, vec_list);
int_list test_int;
vec_list test_vec;
CREATE_LIST(test_int, int, 5);
CREATE_LIST(test_vec, Vector, 5);
ADD_LIST(test_int, 5);
CHECK(test_int.l[0] == 5, "test_int vector ADD_LIST failed");
CHECK(test_int.cur_size = 1, "test_int vector ADD_LIST failed");
ADD_LIST(test_int, 6);
ADD_LIST(test_int, 7);
ADD_LIST(test_int, 8);
ADD_LIST(test_int, 9);
ADD_LIST(test_int, 10);
ADD_LIST(test_int, 11);
CHECK(test_int.l[0] == 5, "test_int vector ADD_LIST failed");
CHECK(test_int.l[1] == 6, "test_int vector ADD_LIST failed");
CHECK(test_int.l[2] == 7, "test_int vector ADD_LIST failed");
CHECK(test_int.l[3] == 8, "test_int vector ADD_LIST failed");
CHECK(test_int.l[4] == 9, "test_int vector ADD_LIST failed");
CHECK(test_int.l[5] == 10, "test_int vector ADD_LIST failed");
CHECK(test_int.l[6] == 11, "test_int vector ADD_LIST failed");
CHECK(test_int.cur_size == 7, "test_int vector ADD_LIST failed");
CHECK(test_int.max_size == 10, "test_int vector ADD_LIST failed");
FREE_LIST(test_int);
Vector val;
val.v[0] = val.v[1] = val.v[2] = val.v[3] = 10.0f;
ADD_LIST(test_vec, val);
CHECK(test_vec.l[0].v[0] == 10.0f, "test_vec vector ADD_LIST failed");
CHECK(test_vec.l[0].v[1] == 10.0f, "test_vec vector ADD_LIST failed");
CHECK(test_vec.l[0].v[2] == 10.0f, "test_vec vector ADD_LIST failed");
CHECK(test_vec.l[0].v[3] == 10.0f, "test_vec vector ADD_LIST failed");
Vector inc;
VEC_ASSIGN(inc, 1.0f, 1.0f, 1.0f, 1.0f);
VEC_ADD(val, val, inc);
ADD_LIST(test_vec, val);
VEC_ADD(val, val, inc);
ADD_LIST(test_vec, val);
VEC_ADD(val, val, inc);
ADD_LIST(test_vec, val);
VEC_ADD(val, val, inc);
ADD_LIST(test_vec, val);
VEC_ADD(val, val, inc);
ADD_LIST(test_vec, val);
VEC_ADD(val, val, inc);
ADD_LIST(test_vec, val);
CHECK(test_vec.l[6].v[0] == 16.0f, "test_vec vector ADD_LIST failed");
CHECK(test_vec.l[6].v[1] == 16.0f, "test_vec vector ADD_LIST failed");
CHECK(test_vec.l[6].v[2] == 16.0f, "test_vec vector ADD_LIST failed");
CHECK(test_vec.l[6].v[3] == 16.0f, "test_vec vector ADD_LIST failed");
CHECK(test_int.cur_size == 7, "test_int vector ADD_LIST failed");
CHECK(test_int.max_size == 10, "test_int vector ADD_LIST failed");
return test_result;
}
static bool load_conn(struct ub_ctx *dnsctx,
struct starter_conn *conn,
struct config_parsed *cfgp,
struct section_list *sl,
bool alsoprocessing,
bool defaultconn,
bool resolvip,
err_t *perr)
{
bool err = FALSE;
err |= load_conn_basic(conn, sl,
defaultconn ? k_default : k_set, perr);
move_comment_list(&conn->comments, &sl->comments);
if (err)
return err;
if (conn->strings[KSF_ALSO] != NULL &&
!alsoprocessing) {
starter_log(LOG_LEVEL_INFO,
"also= is not valid in section '%s'",
sl->name);
return TRUE; /* error */
}
/* now, process the also's */
if (conn->alsos)
FREE_LIST(conn->alsos);
conn->alsos = new_list(conn->strings[KSF_ALSO]);
if (alsoprocessing && conn->alsos != NULL) {
struct section_list *sl1;
/* note: for the duration of this loop body
* conn->alsos is migrated to local variable alsos.
*/
char **alsos = conn->alsos;
int alsosize;
int alsoplace;
conn->alsos = NULL;
/* reset all of the "beenhere" flags */
for (sl1 = cfgp->sections.tqh_first; sl1 != NULL;
sl1 = sl1->link.tqe_next)
sl1->beenhere = FALSE;
sl->beenhere = TRUE;
/* count them */
for (alsosize = 0; alsos[alsosize] != NULL; alsosize++)
;
alsoplace = 0;
while (alsoplace < alsosize && alsos[alsoplace] != NULL &&
alsoplace < ALSO_LIMIT) {
/*
* for each also= listed, go find this section's keyword list, and
* load it as well. This may extend the also= list (and the end),
* which we handle by zeroing the also list, and adding to it after
* checking for duplicates.
*/
for (sl1 = cfgp->sections.tqh_first;
sl1 != NULL &&
!streq(alsos[alsoplace], sl1->name);
sl1 = sl1->link.tqe_next)
;
starter_log(LOG_LEVEL_DEBUG,
"\twhile loading conn '%s' also including '%s'",
conn->name, alsos[alsoplace]);
/*
* if we found something that matches by name, and we haven't be
* there, then process it.
*/
if (sl1 && !sl1->beenhere) {
conn->strings_set[KSF_ALSO] = FALSE;
pfreeany(conn->strings[KSF_ALSO]);
conn->strings[KSF_ALSO] = NULL;
sl1->beenhere = TRUE;
/* translate things, but do not replace earlier settings!*/
err |= translate_conn(conn, sl1, k_set, perr);
if (conn->strings[KSF_ALSO] != NULL) {
/* now, check out the KSF_ALSO, and extend list if we need to */
char **newalsos = new_list(
conn->strings[KSF_ALSO]);
if (newalsos != NULL) {
char **ra;
int newalsoplace;
/* count them */
for (newalsoplace = 0;
newalsos[newalsoplace] !=
NULL;
newalsoplace++)
;
/* extend conn->alss */
ra = alloc_bytes((alsosize +
newalsoplace + 1) *
sizeof(char *),
"conn->alsos");
memcpy(ra, alsos, alsosize * sizeof(char *));
pfree(alsos);
alsos = ra;
for (newalsoplace = 0;
newalsos[newalsoplace] !=
NULL;
newalsoplace++) {
assert(conn != NULL);
assert(conn->name !=
NULL);
starter_log(
LOG_LEVEL_DEBUG,
"\twhile processing section '%s' added also=%s",
sl1->name,
newalsos[newalsoplace]);
alsos[alsosize++] =
clone_str(newalsos[newalsoplace],
"alsos");
}
alsos[alsosize] = NULL;
}
FREE_LIST(newalsos);
}
}
alsoplace++;
}
/* migrate alsos back to conn->alsos */
conn->alsos = alsos;
if (alsoplace >= ALSO_LIMIT) {
starter_log(LOG_LEVEL_INFO,
"while loading conn '%s', too many also= used at section %s. Limit is %d",
conn->name,
alsos[alsoplace],
ALSO_LIMIT);
return TRUE; /* error */
}
}
#ifdef PARSER_TYPE_DEBUG
/* translate strings/numbers into conn items */
starter_log(LOG_LEVEL_DEBUG,
"#checking options_set[KBF_TYPE,%d]=%d %d",
KBF_TYPE,
conn->options_set[KBF_TYPE], conn->options[KBF_TYPE]);
#endif
if (conn->options_set[KBF_TYPE]) {
switch ((enum keyword_satype)conn->options[KBF_TYPE]) {
case KS_TUNNEL:
conn->policy |= POLICY_TUNNEL;
conn->policy &= ~POLICY_SHUNT_MASK;
break;
case KS_TRANSPORT:
conn->policy &= ~POLICY_TUNNEL;
conn->policy &= ~POLICY_SHUNT_MASK;
break;
case KS_PASSTHROUGH:
conn->policy &=
~(POLICY_ENCRYPT | POLICY_AUTHENTICATE |
POLICY_TUNNEL | POLICY_RSASIG);
conn->policy &= ~POLICY_SHUNT_MASK;
conn->policy |= POLICY_SHUNT_PASS;
break;
case KS_DROP:
conn->policy &=
~(POLICY_ENCRYPT | POLICY_AUTHENTICATE |
POLICY_TUNNEL | POLICY_RSASIG);
conn->policy &= ~POLICY_SHUNT_MASK;
conn->policy |= POLICY_SHUNT_DROP;
break;
case KS_REJECT:
conn->policy &=
~(POLICY_ENCRYPT | POLICY_AUTHENTICATE |
POLICY_TUNNEL | POLICY_RSASIG);
conn->policy &= ~POLICY_SHUNT_MASK;
conn->policy |= POLICY_SHUNT_REJECT;
break;
}
}
if (conn->options_set[KBF_FAILURESHUNT]) {
conn->policy &= ~POLICY_FAIL_MASK;
switch(conn->options[KBF_FAILURESHUNT]) {
case KFS_FAIL_NONE:
conn->policy |= POLICY_FAIL_NONE;
break;
case KFS_FAIL_PASS:
conn->policy |= POLICY_FAIL_PASS;
break;
case KFS_FAIL_DROP:
conn->policy |= POLICY_FAIL_DROP;
break;
case KFS_FAIL_REJECT:
conn->policy |= POLICY_FAIL_REJECT;
break;
}
}
if (conn->options_set[KBF_NEGOTIATIONSHUNT]) {
switch(conn->options[KBF_NEGOTIATIONSHUNT]) {
case KNS_FAIL_PASS:
conn->policy |= POLICY_NEGO_PASS;
break;
case KNS_FAIL_DROP:
conn->policy &= ~POLICY_NEGO_PASS;
break;
}
}
KW_POLICY_FLAG(KBF_COMPRESS, POLICY_COMPRESS);
KW_POLICY_FLAG(KBF_PFS, POLICY_PFS);
/* reset authby flags */
if (conn->options_set[KBF_AUTHBY]) {
conn->policy &= ~(POLICY_ID_AUTH_MASK);
#ifdef FIPS_CHECK
if (libreswan_fipsmode()) {
if (LIN(POLICY_PSK, conn->options[KBF_AUTHBY])) {
starter_log(LOG_LEVEL_INFO,
"while loading conn '%s', PSK not allowed in FIPS mode with NSS",
conn->name);
return TRUE; /* error */
}
}
#endif
conn->policy |= conn->options[KBF_AUTHBY];
#ifdef STARTER_POLICY_DEBUG
starter_log(LOG_LEVEL_DEBUG,
"%s: setting conn->policy=%08x (%08x)",
conn->name,
(unsigned int)conn->policy,
conn->options[KBF_AUTHBY]);
#endif
}
KW_POLICY_NEGATIVE_FLAG(KBF_IKEPAD, POLICY_NO_IKEPAD);
KW_POLICY_NEGATIVE_FLAG(KBF_REKEY, POLICY_DONT_REKEY);
KW_POLICY_FLAG(KBF_AGGRMODE, POLICY_AGGRESSIVE);
KW_POLICY_FLAG(KBF_MODECONFIGPULL, POLICY_MODECFG_PULL);
KW_POLICY_FLAG(KBF_OVERLAPIP, POLICY_OVERLAPIP);
KW_POLICY_FLAG(KBF_IKEv2_ALLOW_NARROWING,
POLICY_IKEV2_ALLOW_NARROWING);
KW_POLICY_FLAG(KBF_IKEv2_PAM_AUTHORIZE,
POLICY_IKEV2_PAM_AUTHORIZE);
if (conn->strings_set[KSF_ESP])
conn->esp = clone_str(conn->strings[KSF_ESP],"KSF_ESP");
#ifdef HAVE_LABELED_IPSEC
if (conn->strings_set[KSF_POLICY_LABEL])
conn->policy_label = clone_str(conn->strings[KSF_POLICY_LABEL],"KSF_POLICY_LABEL");
if (conn->policy_label != NULL)
starter_log(LOG_LEVEL_DEBUG, "connection's policy label: %s",
conn->policy_label);
#endif
if (conn->strings_set[KSF_IKE])
conn->ike = clone_str(conn->strings[KSF_IKE],"KSF_IKE");
if (conn->strings_set[KSF_MODECFGDNS1]) {
conn->modecfg_dns1 = clone_str(conn->strings[KSF_MODECFGDNS1],"KSF_MODECFGDNS1");
}
if (conn->strings_set[KSF_MODECFGDNS2]) {
conn->modecfg_dns2 = clone_str(conn->strings[KSF_MODECFGDNS2], "KSF_MODECFGDNS2");
}
if (conn->strings_set[KSF_MODECFGDOMAIN]) {
conn->modecfg_domain = clone_str(conn->strings[KSF_MODECFGDOMAIN],"KSF_MODECFGDOMAIN");
}
if (conn->strings_set[KSF_MODECFGBANNER]) {
conn->modecfg_banner = clone_str(conn->strings[KSF_MODECFGBANNER],"KSF_MODECFGBANNER");
}
if (conn->strings_set[KSF_CONNALIAS])
conn->connalias = clone_str(conn->strings[KSF_CONNALIAS],"KSF_CONNALIAS");
if (conn->options_set[KBF_PHASE2]) {
conn->policy &= ~(POLICY_AUTHENTICATE | POLICY_ENCRYPT);
conn->policy |= conn->options[KBF_PHASE2];
}
if (conn->options_set[KBF_IKEv2]) {
lset_t policy = LEMPTY;
switch (conn->options[KBF_IKEv2]) {
case fo_never:
policy = POLICY_IKEV1_ALLOW;
break;
case fo_permit:
/* this is the default for now */
policy = POLICY_IKEV1_ALLOW | POLICY_IKEV2_ALLOW;
break;
case fo_propose:
policy = POLICY_IKEV1_ALLOW | POLICY_IKEV2_ALLOW | POLICY_IKEV2_PROPOSE;
break;
case fo_insist:
policy = POLICY_IKEV2_ALLOW | POLICY_IKEV2_PROPOSE;
break;
}
conn->policy = (conn->policy & ~POLICY_IKEV2_MASK) | policy;
}
if (conn->options_set[KBF_IKE_FRAG]) {
switch (conn->options[KBF_IKE_FRAG]) {
case ynf_no:
conn->policy &= ~POLICY_IKE_FRAG_ALLOW;
conn->policy &= ~POLICY_IKE_FRAG_FORCE;
break;
case ynf_yes:
/* this is the default */
conn->policy |= POLICY_IKE_FRAG_ALLOW;
break;
case ynf_force:
conn->policy |= POLICY_IKE_FRAG_ALLOW |
POLICY_IKE_FRAG_FORCE;
break;
}
}
if (conn->options_set[KBF_SAREFTRACK]) {
switch (conn->options[KBF_SAREFTRACK]) {
case sat_yes:
/* this is the default */
conn->policy |= POLICY_SAREF_TRACK;
break;
case sat_conntrack:
conn->policy |= POLICY_SAREF_TRACK |
POLICY_SAREF_TRACK_CONNTRACK;
break;
case sat_no:
conn->policy &= ~POLICY_SAREF_TRACK;
conn->policy &= ~POLICY_SAREF_TRACK_CONNTRACK;
break;
}
}
err |= validate_end(dnsctx, conn, &conn->left, "left", resolvip, perr);
err |= validate_end(dnsctx, conn, &conn->right, "right", resolvip, perr);
/*
* TODO:
* verify both ends are using the same inet family, if one end
* is "%any" or "%defaultroute", then perhaps adjust it.
* ensource this for left,leftnexthop,right,rightnexthop
* Ideally, phase out connaddrfamily= which now wrongly assumes
* left,leftnextop,leftsubnet are the same inet family
* Currently, these tests are implicitely done, and wrongly
* in case of 6in4 and 4in6 tunnels
*/
if (conn->options_set[KBF_AUTO])
conn->desired_state = conn->options[KBF_AUTO];
return err;
}
/**
* Load a parsed config
*
* @param cfg starter_config structure
* @param cfgp config_parsed (ie: valid) struct
* @param perr pointer to store errors in
* @return bool TRUE if unsuccessfull
*/
static bool load_setup(struct starter_config *cfg,
struct config_parsed *cfgp)
{
bool err = FALSE;
struct kw_list *kw;
for (kw = cfgp->config_setup; kw; kw = kw->next) {
/**
* the parser already made sure that only config keywords were used,
* but we double check!
*/
assert(kw->keyword.keydef->validity & kv_config);
switch (kw->keyword.keydef->type) {
case kt_string:
case kt_filename:
case kt_dirname:
case kt_loose_enum:
/* all treated as strings for now */
assert(kw->keyword.keydef->field <
sizeof(cfg->setup.strings));
pfreeany(cfg->setup.strings[kw->keyword.keydef->
field]);
cfg->setup.strings[kw->keyword.keydef->field] =
clone_str(kw->string, "kt_loose_enum kw->string");
cfg->setup.strings_set[kw->keyword.keydef->field] =
TRUE;
break;
case kt_list:
case kt_bool:
case kt_invertbool:
case kt_enum:
case kt_number:
case kt_time:
case kt_percent:
/* all treated as a number for now */
assert(kw->keyword.keydef->field <
sizeof(cfg->setup.options));
cfg->setup.options[kw->keyword.keydef->field] =
kw->number;
cfg->setup.options_set[kw->keyword.keydef->field] =
TRUE;
break;
case kt_bitstring:
case kt_rsakey:
case kt_ipaddr:
case kt_subnet:
case kt_range:
case kt_idtype:
err = TRUE;
break;
case kt_comment:
break;
case kt_obsolete:
starter_log(LOG_LEVEL_INFO,
"Warning: ignored obsolete keyword '%s'",
kw->keyword.keydef->keyname);
break;
case kt_obsolete_quiet:
starter_log(LOG_LEVEL_DEBUG,
"Warning: ignored obsolete keyword '%s'",
kw->keyword.keydef->keyname);
break;
default:
/* NEVER HAPPENS */
break;
}
}
/* now process some things with specific values */
/* interfaces has to be chopped up */
if (cfg->setup.interfaces)
FREE_LIST(cfg->setup.interfaces);
cfg->setup.interfaces = new_list(cfg->setup.strings[KSF_INTERFACES]);
return err;
}
STD_ERROR DLLEXPORT DRV_FunctionGenerator_Close ( int *pHandle )
{
STD_ERROR StdError = {0};
tsDriverInfo *pDriverInfo = NULL,
tDriverInfo = {0};
CmtTSVHandle VariableHandle = 0;
CmtThreadLockHandle LockHandle = 0;
pfFunctionGenerator_Close pWrapperFunction = NULL;
int bHandleExists = 0;
int bLocked = 0;
if ( pHandle == NULL )
{STD_ERR (DRV_ERROR_PASSED_NULL);}
VariableHandle = *pHandle;
*pHandle = 0;
if ( VariableHandle == 0 )
{STD_ERR (DRV_ERROR_PASSED_NULL);}
if ( CmtGetTSVPtr ( VariableHandle , &pDriverInfo ) < 0 )
{STD_ERR (DRV_ERROR_GET_TSV_POINTER);}
memcpy( &tDriverInfo , pDriverInfo , sizeof(tsDriverInfo));
FREE( pDriverInfo->pLastStateFileName );
CmtReleaseTSVPtr ( VariableHandle );
if ( tDriverInfo.InstrumentType != DRIVER_TYPE_FUNCTION_GENERATOR )
{STD_ERR (DRV_ERROR_INCORRECT_DRIVER_TYPE);}
LockHandle = tDriverInfo.InstrumentLockHandle;
pWrapperFunction = tDriverInfo.tInstrDB.functionGeneratorDriverFunctions.FunctionGenerator_Close;
bHandleExists = DRIVER_MANAGER_IsConnectionExists( tDriverInfo.pInstrumentAddress , NULL , NULL );
if ( pWrapperFunction && bHandleExists )
{
CHK_PROCCESS_GET_LOCK ( LockHandle );
if ( pDriverInfo->bDemoMode == 0 )
{
FREE_STDERR_COPY( pWrapperFunction( &tDriverInfo.InstrumentHandle ));
}
CmtReleaseLock ( LockHandle );
LockHandle=0;
bLocked=0;
DRIVER_MANAGER_RemoveConnectionExists( tDriverInfo.pInstrumentAddress , tDriverInfo.InstrumentHandle );
}
if ( pWrapperFunction == NULL )
{
char szMessage[LOW_STRING] = {0};
sprintf( szMessage , "Method \"%s\"\nis not implemented in driver:\n%s" , "FunctionGenerator_Close" , tDriverInfo.pDriverFileName );
ShowMessage ( INSTR_TYPE_CONTINUE , "Implementation Error . . ." , szMessage , NULL );
}
FREE(tDriverInfo.pInstrumentAddress);
FREE(tDriverInfo.pDriverFileName);
if ( tDriverInfo.pCalibration )
{
FREE(tDriverInfo.pCalibration->pStateFileName);
FREE(tDriverInfo.pCalibration->pCalibrationRefName);
FREE(tDriverInfo.pCalibration->pConnectionDescription);
FREE(tDriverInfo.pCalibration->pConnectionImage);
FREE(tDriverInfo.pCalibration->vlfFrequency);
FREE(tDriverInfo.pCalibration->vlfLoss);
FREE(tDriverInfo.pCalibration->vlfPowerList);
FREE_LIST(tDriverInfo.pCalibration->vlfLossList,tDriverInfo.pCalibration->iNumberOfPowers);
FREE(tDriverInfo.pCalibration);
}
FREE( tDriverInfo.ptCallbacks );
Error:
if ( LockHandle && bLocked )
CmtReleaseLock ( LockHandle );
if ( VariableHandle )
CmtDiscardTSV ( VariableHandle );
if ( DRIVER_MANAGER_IsConnectionExistsByType( DRIVER_TYPE_FUNCTION_GENERATOR ) == 0 )
FreeLibrary( tDriverInfo.LibraryHandle );
*pHandle = 0;
if ( StdError.error )
{FREE_CALLOC_COPY_STRING (StdError.pszErrorDescription, "Error while closing instrument driver.");}
return StdError;
}
void sgFreeAllLists()
{
#define FREE_LIST(type, head, func) \
{ \
struct type *next; \
while(head != NULL) { \
next = head->next; \
func(head); \
head = next; \
} \
}
/* settings linked list */
FREE_LIST(Setting, Setting, sgFreeSetting)
lastSetting = NULL;
Setting = NULL;
/* sources */
FREE_LIST(Source, Source, sgFreeSource)
lastSource = NULL;
Source = NULL;
lastActiveSource = NULL;
/* dests */
FREE_LIST(Destination, Dest, sgFreeDestination)
lastDest = NULL;
Dest = NULL;
/* rewrites */
FREE_LIST(sgRewrite, Rewrite, sgFreeRewrite)
lastRewrite = NULL;
Rewrite = NULL;
lastRewriteRegExec = NULL;
/* time structures */
FREE_LIST(Time, Time, sgFreeTime)
lastTime = NULL;
Time = NULL;
lastTimeElement = NULL;
TimeElement = NULL;
/* log file stats */
FREE_LIST(LogFileStat, LogFileStat, sgFreeLogFileStat)
lastLogFileStat = NULL;
LogFileStat = NULL;
/* access control lists */
FREE_LIST(Acl, Acl, sgFreeAcl)
lastAcl = NULL;
defaultAcl = NULL;
Acl = NULL;
lastAclDest = NULL;
/* single variables */
free(globalLogDir);
globalLogDir = NULL;
sgFree(TimeElementsEvents);
TimeElementsEvents = NULL;
}
char *FileReq(char *dir, const char *ext, char *result)
{
static char *cwd = NULL;
static s32 cursor_pos = 1;
static s32 first_visible;
static s32 num_items = 0;
DIR *dirstream;
struct dirent *direntry;
static s32 row;
char tmp_string[41];
u32 keys;
if (dir)
ChDir(dir);
cwd = GetCwd();
for (;;) {
keys = key_read();
video_clear();
if (keys & KEY_SELECT) {
FREE_LIST();
key_reset();
return NULL;
}
if (num_items == 0) {
dirstream = opendir(cwd);
if (dirstream == NULL) {
port_printf(0, 20, "error opening directory");
return NULL;
}
// read directory entries
while ((direntry = readdir(dirstream))) {
s32 type = get_entry_type(cwd, direntry->d_name);
// this is a very ugly way of only accepting a certain extension
if ((type == 0 && strcmp(direntry->d_name, ".")) ||
check_ext(direntry->d_name) ||
(ext && (strlen(direntry->d_name) > 4 &&0 == strncasecmp(direntry->d_name + (strlen(direntry->d_name) - strlen(ext)), ext, strlen(ext))))) {
// Hide ".." if at Unix root dir. Don't display Unix hidden files (.file).
if ((!strcmp(direntry->d_name, "..") && strcmp(cwd, "/")) || direntry->d_name[0] != '.')
{
filereq_dir_items[num_items].name = (char *)malloc(strlen(direntry->d_name) + 1);
strcpy(filereq_dir_items[num_items].name, direntry->d_name);
filereq_dir_items[num_items].type = type;
num_items++;
if (num_items > 1024) break;
}
}
}
closedir(dirstream);
sort_dir(filereq_dir_items, num_items);
cursor_pos = 0;
first_visible = 0;
}
// display current directory
int len = strlen(cwd);
if (len > 40) {
strcpy(tmp_string, "..");
strcat(tmp_string, cwd + len - 38);
port_printf(0, MENU_Y, tmp_string);
} else
port_printf(0, MENU_Y, cwd);
if (keys & KEY_DOWN) { //down
if (++cursor_pos >= num_items) {
cursor_pos = 0;
first_visible = 0;
}
if ((cursor_pos - first_visible) >= MENU_HEIGHT) first_visible++;
} else if (keys & KEY_UP) { // up
if (--cursor_pos < 0) {
cursor_pos = num_items - 1;
first_visible = cursor_pos - MENU_HEIGHT + 1;
if (first_visible < 0) first_visible = 0;
}
if (cursor_pos < first_visible) first_visible--;
} else if (keys & KEY_LEFT) { //left
if (cursor_pos >= 10) cursor_pos -= 10;
else cursor_pos = 0;
if (cursor_pos < first_visible) first_visible = cursor_pos;
} else if (keys & KEY_RIGHT) { //right
if (cursor_pos < (num_items - 11)) cursor_pos += 10;
else cursor_pos = num_items - 1;
if ((cursor_pos - first_visible) >= MENU_HEIGHT)
first_visible = cursor_pos - (MENU_HEIGHT - 1);
} else if (keys & KEY_A) { // button 1
// directory selected
if (filereq_dir_items[cursor_pos].type == 0) {
strcat(cwd, "/");
strcat(cwd, filereq_dir_items[cursor_pos].name);
ChDir(cwd);
cwd = GetCwd();
FREE_LIST();
key_reset();
} else {
sprintf(result, "%s/%s", cwd, filereq_dir_items[cursor_pos].name);
if (dir)
strcpy(dir, cwd);
video_clear();
port_printf(16 * 8, 120, "LOADING");
video_flip();
FREE_LIST();
key_reset();
return result;
}
} else if (keys & KEY_B) {
cursor_pos = 0;
first_visible = 0;
key_reset();
}
// display directory contents
row = 0;
while (row < num_items && row < MENU_HEIGHT) {
if (row == (cursor_pos - first_visible)) {
// draw cursor
port_printf(MENU_X + 16, MENU_LS + (10 * row), "-->");
}
if (filereq_dir_items[row + first_visible].type == 0)
port_printf(MENU_X, MENU_LS + (10 * row), "DIR");
int len = strlen(filereq_dir_items[row + first_visible].name);
if (len > 32) {
snprintf(tmp_string, 16, "%s", filereq_dir_items[row + first_visible].name);
strcat(tmp_string, "..");
strcat(tmp_string, &filereq_dir_items[row + first_visible].name[len - 15]);
} else
snprintf(tmp_string, 33, "%s", filereq_dir_items[row + first_visible].name);
port_printf(MENU_X + (8 * 5), MENU_LS + (10 * row), tmp_string);
row++;
}
while (row < MENU_HEIGHT)
row++;
video_flip();
timer_delay(75);
if (keys & (KEY_A | KEY_B | KEY_X | KEY_Y | KEY_L | KEY_R |
KEY_LEFT | KEY_RIGHT | KEY_UP | KEY_DOWN))
timer_delay(50);
}
return NULL;
}
void SMBCALL smb_freehashes(hash_t** hashes)
{
size_t n;
FREE_LIST(hashes,n);
}
static bool load_conn(
#ifdef DNSSEC
struct ub_ctx *dnsctx,
#endif
struct starter_conn *conn,
const struct config_parsed *cfgp,
struct section_list *sl,
bool alsoprocessing,
bool defaultconn,
bool resolvip,
err_t *perr)
{
bool err;
/* turn all of the keyword/value pairs into options/strings in left/right */
err = translate_conn(conn, sl,
defaultconn ? k_default : k_set,
perr);
move_comment_list(&conn->comments, &sl->comments);
if (err)
return err;
if (conn->strings[KSCF_ALSO] != NULL &&
!alsoprocessing) {
starter_log(LOG_LEVEL_INFO,
"also= is not valid in section '%s'",
sl->name);
/* ??? should we not set *perr? */
return TRUE; /* error */
}
/* now, process the also's */
if (conn->alsos != NULL)
FREE_LIST(conn->alsos);
conn->alsos = new_list(conn->strings[KSCF_ALSO]);
if (alsoprocessing && conn->alsos != NULL) {
struct section_list *sl1;
/* note: for the duration of this loop body
* conn->alsos is migrated to local variable alsos.
*/
char **alsos = conn->alsos;
int alsosize;
int alsoplace;
conn->alsos = NULL;
/* reset all of the "beenhere" flags */
for (sl1 = cfgp->sections.tqh_first; sl1 != NULL;
sl1 = sl1->link.tqe_next)
sl1->beenhere = FALSE;
sl->beenhere = TRUE;
/* count them */
for (alsosize = 0; alsos[alsosize] != NULL; alsosize++)
;
alsoplace = 0;
while (alsoplace < alsosize && alsos[alsoplace] != NULL &&
alsoplace < ALSO_LIMIT) {
/*
* for each also= listed, go find this section's keyword list, and
* load it as well. This may extend the also= list (and the end),
* which we handle by zeroing the also list, and adding to it after
* checking for duplicates.
*/
for (sl1 = cfgp->sections.tqh_first;
sl1 != NULL &&
!streq(alsos[alsoplace], sl1->name);
sl1 = sl1->link.tqe_next)
;
starter_log(LOG_LEVEL_DEBUG,
"\twhile loading conn '%s' also including '%s'",
conn->name, alsos[alsoplace]);
/*
* if we found something that matches by name,
* and we haven't been there, then process it.
*/
if (sl1 != NULL && !sl1->beenhere) {
conn->strings_set[KSCF_ALSO] = FALSE;
pfreeany(conn->strings[KSCF_ALSO]);
conn->strings[KSCF_ALSO] = NULL;
sl1->beenhere = TRUE;
/* translate things, but do not replace earlier settings! */
err |= translate_conn(conn, sl1, k_set, perr);
if (conn->strings[KSCF_ALSO] != NULL) {
/* now, check out the KSCF_ALSO, and extend list if we need to */
char **newalsos = new_list(
conn->strings[KSCF_ALSO]);
if (newalsos != NULL) {
char **ra;
int newalsoplace;
/* count them */
for (newalsoplace = 0;
newalsos[newalsoplace] !=
NULL;
newalsoplace++)
;
/* extend conn->alss */
ra = alloc_bytes((alsosize +
newalsoplace + 1) *
sizeof(char *),
"conn->alsos");
memcpy(ra, alsos, alsosize * sizeof(char *));
pfree(alsos);
alsos = ra;
for (newalsoplace = 0;
newalsos[newalsoplace] !=
NULL;
newalsoplace++) {
assert(conn != NULL);
assert(conn->name !=
NULL);
starter_log(
LOG_LEVEL_DEBUG,
"\twhile processing section '%s' added also=%s",
sl1->name,
newalsos[newalsoplace]);
alsos[alsosize++] =
clone_str(newalsos[newalsoplace],
"alsos");
}
alsos[alsosize] = NULL;
}
FREE_LIST(newalsos);
}
}
alsoplace++;
}
/* migrate alsos back to conn->alsos */
conn->alsos = alsos;
if (alsoplace >= ALSO_LIMIT) {
starter_log(LOG_LEVEL_INFO,
"while loading conn '%s', too many also= used at section %s. Limit is %d",
conn->name,
alsos[alsoplace],
ALSO_LIMIT);
/* ??? should we not set *perr? */
return TRUE; /* error */
}
}
if (conn->options_set[KBF_TYPE]) {
switch ((enum keyword_satype)conn->options[KBF_TYPE]) {
case KS_TUNNEL:
if (conn->options_set[KBF_AUTHBY] &&
conn->options[KBF_AUTHBY] == POLICY_AUTH_NEVER) {
*perr = "connection type=tunnel must not specify authby=never";
return TRUE;
}
conn->policy |= POLICY_TUNNEL;
conn->policy &= ~POLICY_SHUNT_MASK;
break;
case KS_TRANSPORT:
if (conn->options_set[KBF_AUTHBY] &&
conn->options[KBF_AUTHBY] == POLICY_AUTH_NEVER) {
*perr = "connection type=transport must not specify authby=never";
return TRUE;
}
conn->policy &= ~POLICY_TUNNEL;
conn->policy &= ~POLICY_SHUNT_MASK;
break;
case KS_PASSTHROUGH:
if (!conn->options_set[KBF_AUTHBY] ||
conn->options[KBF_AUTHBY] != POLICY_AUTH_NEVER) {
*perr = "connection type=passthrough must specify authby=never";
}
conn->policy &=
~(POLICY_ENCRYPT | POLICY_AUTHENTICATE |
POLICY_TUNNEL | POLICY_RSASIG);
conn->policy &= ~POLICY_SHUNT_MASK;
conn->policy |= POLICY_SHUNT_PASS;
break;
case KS_DROP:
if (!conn->options_set[KBF_AUTHBY] ||
conn->options[KBF_AUTHBY] != POLICY_AUTH_NEVER) {
*perr = "connection type=drop must specify authby=never";
}
conn->policy &=
~(POLICY_ENCRYPT | POLICY_AUTHENTICATE |
POLICY_TUNNEL | POLICY_RSASIG);
conn->policy &= ~POLICY_SHUNT_MASK;
conn->policy |= POLICY_SHUNT_DROP;
break;
case KS_REJECT:
if (!conn->options_set[KBF_AUTHBY] ||
conn->options[KBF_AUTHBY] != POLICY_AUTH_NEVER) {
*perr = "connection type=drop must specify authby=never";
}
conn->policy &=
~(POLICY_ENCRYPT | POLICY_AUTHENTICATE |
POLICY_TUNNEL | POLICY_RSASIG);
conn->policy &= ~POLICY_SHUNT_MASK;
conn->policy |= POLICY_SHUNT_REJECT;
break;
}
}
if (conn->options_set[KBF_FAILURESHUNT]) {
conn->policy &= ~POLICY_FAIL_MASK;
switch (conn->options[KBF_FAILURESHUNT]) {
case KFS_FAIL_NONE:
conn->policy |= POLICY_FAIL_NONE;
break;
case KFS_FAIL_PASS:
conn->policy |= POLICY_FAIL_PASS;
break;
case KFS_FAIL_DROP:
conn->policy |= POLICY_FAIL_DROP;
break;
case KFS_FAIL_REJECT:
conn->policy |= POLICY_FAIL_REJECT;
break;
}
}
if (conn->options_set[KBF_NEGOTIATIONSHUNT]) {
switch (conn->options[KBF_NEGOTIATIONSHUNT]) {
case KNS_FAIL_PASS:
conn->policy |= POLICY_NEGO_PASS;
break;
case KNS_FAIL_DROP:
conn->policy &= ~POLICY_NEGO_PASS;
break;
}
}
KW_POLICY_FLAG(KBF_COMPRESS, POLICY_COMPRESS);
KW_POLICY_FLAG(KBF_PFS, POLICY_PFS);
/* reset authby= flags */
if (conn->options_set[KBF_AUTHBY]) {
conn->policy &= ~POLICY_ID_AUTH_MASK;
conn->policy |= conn->options[KBF_AUTHBY];
}
KW_POLICY_NEGATIVE_FLAG(KBF_IKEPAD, POLICY_NO_IKEPAD);
KW_POLICY_NEGATIVE_FLAG(KBF_REKEY, POLICY_DONT_REKEY);
KW_POLICY_FLAG(KBF_AGGRMODE, POLICY_AGGRESSIVE);
KW_POLICY_FLAG(KBF_MODECONFIGPULL, POLICY_MODECFG_PULL);
KW_POLICY_FLAG(KBF_OVERLAPIP, POLICY_OVERLAPIP);
KW_POLICY_FLAG(KBF_IKEv2_ALLOW_NARROWING,
POLICY_IKEV2_ALLOW_NARROWING);
KW_POLICY_FLAG(KBF_IKEv2_PAM_AUTHORIZE,
POLICY_IKEV2_PAM_AUTHORIZE);
# define str_to_conn(member, kscf) { \
if (conn->strings_set[kscf]) \
conn->member = clone_str(conn->strings[kscf], #kscf); \
}
str_to_conn(esp, KSCF_ESP);
#ifdef HAVE_LABELED_IPSEC
str_to_conn(policy_label, KSCF_POLICY_LABEL);
if (conn->policy_label != NULL)
starter_log(LOG_LEVEL_DEBUG, "connection's policy label: %s",
conn->policy_label);
#endif
str_to_conn(ike, KSCF_IKE);
str_to_conn(modecfg_dns1, KSCF_MODECFGDNS1);
str_to_conn(modecfg_dns2, KSCF_MODECFGDNS2);
str_to_conn(modecfg_domain, KSCF_MODECFGDOMAIN);
str_to_conn(modecfg_banner, KSCF_MODECFGBANNER);
/* mark-in= and mark-out= override mark= */
str_to_conn(conn_mark_in, KSCF_CONN_MARK_BOTH);
str_to_conn(conn_mark_out, KSCF_CONN_MARK_BOTH);
str_to_conn(conn_mark_in, KSCF_CONN_MARK_IN);
str_to_conn(conn_mark_out, KSCF_CONN_MARK_OUT);
str_to_conn(vti_iface, KSCF_VTI_IFACE);
str_to_conn(connalias, KSCF_CONNALIAS);
# undef str_to_conn
if (conn->options_set[KBF_PHASE2]) {
conn->policy &= ~(POLICY_AUTHENTICATE | POLICY_ENCRYPT);
conn->policy |= conn->options[KBF_PHASE2];
}
if (conn->options_set[KBF_IKEv2]) {
lset_t pv2 = LEMPTY;
switch (conn->options[KBF_IKEv2]) {
case fo_never:
pv2 = POLICY_IKEV1_ALLOW;
break;
case fo_permit:
/* this is the default for now */
pv2 = POLICY_IKEV1_ALLOW | POLICY_IKEV2_ALLOW;
break;
case fo_propose:
pv2 = POLICY_IKEV1_ALLOW | POLICY_IKEV2_ALLOW | POLICY_IKEV2_PROPOSE;
break;
case fo_insist:
pv2 = POLICY_IKEV2_ALLOW | POLICY_IKEV2_PROPOSE;
break;
}
conn->policy = (conn->policy & ~POLICY_IKEV2_MASK) | pv2;
}
if (conn->options_set[KBF_ESN]) {
conn->policy &= ~(POLICY_ESN_NO | POLICY_ESN_YES);
switch (conn->options[KBF_ESN]) {
case esn_yes:
conn->policy |= POLICY_ESN_YES;
break;
case esn_no:
/* this is the default for now */
conn->policy |= POLICY_ESN_NO;
break;
case esn_either:
conn->policy |= POLICY_ESN_NO | POLICY_ESN_YES;
break;
}
}
if (conn->options_set[KBF_IKE_FRAG]) {
conn->policy &= ~(POLICY_IKE_FRAG_ALLOW | POLICY_IKE_FRAG_FORCE);
switch (conn->options[KBF_IKE_FRAG]) {
case ynf_no:
break;
case ynf_yes:
/* this is the default */
conn->policy |= POLICY_IKE_FRAG_ALLOW;
break;
case ynf_force:
conn->policy |= POLICY_IKE_FRAG_ALLOW |
POLICY_IKE_FRAG_FORCE;
break;
}
}
if (conn->options_set[KBF_SAREFTRACK]) {
conn->policy &= ~(POLICY_SAREF_TRACK | POLICY_SAREF_TRACK_CONNTRACK);
switch (conn->options[KBF_SAREFTRACK]) {
case sat_yes:
/* this is the default */
conn->policy |= POLICY_SAREF_TRACK;
break;
case sat_conntrack:
conn->policy |= POLICY_SAREF_TRACK |
POLICY_SAREF_TRACK_CONNTRACK;
break;
case sat_no:
break;
}
}
/*
* some options are set as part of our default, but
* some make no sense for shunts, so remove those again
*/
if (NEVER_NEGOTIATE(conn->policy)) {
/* remove IPsec related options */
conn->policy &= ~(POLICY_PFS | POLICY_COMPRESS | POLICY_ESN_NO |
POLICY_ESN_YES | POLICY_SAREF_TRACK |
POLICY_SAREF_TRACK_CONNTRACK);
/* remove IKE related options */
conn->policy &= ~(POLICY_IKEV1_ALLOW | POLICY_IKEV2_ALLOW |
POLICY_IKEV2_PROPOSE | POLICY_IKE_FRAG_ALLOW |
POLICY_IKE_FRAG_FORCE);
}
err |= validate_end(
#ifdef DNSSEC
dnsctx,
#endif
conn, &conn->left, "left", resolvip, perr);
err |= validate_end(
#ifdef DNSSEC
dnsctx,
#endif
conn, &conn->right, "right", resolvip, perr);
/*
* TODO:
* verify both ends are using the same inet family, if one end
* is "%any" or "%defaultroute", then perhaps adjust it.
* ensource this for left,leftnexthop,right,rightnexthop
* Ideally, phase out connaddrfamily= which now wrongly assumes
* left,leftnextop,leftsubnet are the same inet family
* Currently, these tests are implicitely done, and wrongly
* in case of 6in4 and 4in6 tunnels
*/
if (conn->options_set[KBF_AUTO])
conn->desired_state = conn->options[KBF_AUTO];
return err;
}
void DLLEXPORT TECOM_MEM_FreeList( void **pPointer , int iNumberOfItems )
{
FREE_LIST(pPointer,iNumberOfItems);
return;
}
static void free_all_node_list(struct Scene *scene)
{
FREE_LIST(scene, ObjectInstance, ObjFree);
FREE_LIST(scene, Accelerator, AccFree);
FREE_LIST(scene, FrameBuffer, FbFree);
FREE_LIST(scene, ObjectGroup, ObjGroupFree);
FREE_LIST(scene, Turbulence, TrbFree);
FREE_LIST(scene, Procedure, PrcFree);
FREE_LIST(scene, Texture, TexFree);
FREE_LIST(scene, Camera, CamFree);
FREE_LIST(scene, Shader, ShdFree);
FREE_LIST(scene, Volume, VolFree);
FREE_LIST(scene, Curve, CrvFree);
FREE_LIST(scene, Light, LgtFree);
FREE_LIST(scene, Mesh, MshFree);
/* plugins should be freed the last since they contain free functions for others */
FREE_LIST(scene, Plugin, PlgClose);
}
