static int read_any_identity(xmlNode *an, cp_any_identity_t **dst)
{
cp_domain_t *domain, *last_domain = NULL;
cp_except_domain_t *except, *last_except = NULL;
xmlNode *n;
int res = RES_OK;
*dst = (cp_any_identity_t*)cds_malloc(sizeof(cp_any_identity_t));
if (!*dst) return RES_MEMORY_ERR;
memset(*dst, 0, sizeof(**dst));
n = an->children;
while (n) {
if (n->type == XML_ELEMENT_NODE) {
if (cmp_node(n, "domain", common_policy_ns) >= 0) {
res = read_domain(n, &domain);
if (res != 0) break;
LINKED_LIST_ADD((*dst)->domains, last_domain, domain);
}
else if (cmp_node(n, "except-domain", common_policy_ns) >= 0) {
res = read_except_domain(n, &except);
if (res != 0) break;
LINKED_LIST_ADD((*dst)->except_domains, last_except, except);
}
}
n = n->next;
}
return res;
}
static int
read_rdata_atom(namedb_type *db, uint16_t type, int index, uint32_t domain_count, domain_type **domains, rdata_atom_type *result)
{
uint8_t data[65536];
if (rdata_atom_is_domain(type, index)) {
result->domain = read_domain(db, domain_count, domains);
if (!result->domain)
return 0;
} else {
uint16_t size;
if (fread(&size, sizeof(size), 1, db->fd) != 1)
return 0;
size = ntohs(size);
if (fread(data, sizeof(uint8_t), size, db->fd) != size)
return 0;
result->data = (uint16_t *) region_alloc(
db->region, sizeof(uint16_t) + size);
memcpy(result->data, &size, sizeof(uint16_t));
memcpy((uint8_t *) result->data + sizeof(uint16_t), data, size);
}
return 1;
}
void read_start_values_from_inputfile()
{
/**************************************************************************/
/* read in the variable 'frac_gen_type' which controlls the type of */
/* generating process */
/**************************************************************************/
frac_gen_type = read_frac_gen_type(); /*read_startvalues.c*/
if ((frac_gen_type == 1) || (frac_gen_type == 3))
{
/***********************************************************************/
/* read in the start number to activate the random generator */
/* just do it for */
/* o.) frac_gen_type = 1: stochastic generating process */
/* o.) frac_gen_type = 3: deterministic + stochastic generating process*/
/***********************************************************************/
read_rseed(); /*read_startvalues.c*/
/***********************************************************************/
/* read fracture density 'frac_dens_3d' [fracture area m^2 / m^3] */
/***********************************************************************/
/*AH 16.03.00
frac_dens_3d = get_var_integer(uvar, "frac_dens_3d");
*/
frac_dens_3d = get_var_double(uvar, "frac_dens_3d");
}
/**************************************************************************/
/* read in the domain size */
/**************************************************************************/
read_domain(); /*read_startvalues.c*/
}
static void *status_thread (void *p)
{
THREAD_SIGINIT;
/* (void)p; */ /* To inhibit "unused variable" warning */
if (!global.strict_suid) {
if (!run_as(global.run_as)) {
pdnsd_exit();
}
}
if (listen(stat_sock,5)==-1) {
log_warn("Error: could not listen on socket: %s.\nStatus readback will be impossible",strerror(errno));
goto exit_thread;
}
for(;;) {
struct sockaddr_un ra;
socklen_t res=sizeof(ra);
int rs;
if ((rs=accept(stat_sock,(struct sockaddr *)&ra,&res))!=-1) {
uint16_t cmd;
DEBUG_MSG("Status socket query pending.\n");
if (read_short(rs,&cmd)) {
/* Check magic number in command */
if((cmd & 0xff00) == CTL_CMDVERNR) {
const char *errmsg;
cmd &= 0xff;
switch(cmd) {
case CTL_STATS: {
struct utsname nm;
DEBUG_MSG("Received STATUS query.\n");
if(!print_succ(rs))
break;
uname(&nm);
if(fsprintf(rs,"pdnsd-%s running on %s.\n",VERSION,nm.nodename)<0 ||
report_cache_stat(rs)<0 ||
report_thread_stat(rs)<0 ||
report_conf_stat(rs)<0)
{
DEBUG_MSG("Error writing to control socket: %s\n"
"Failed to send status report.\n",strerror(errno));
}
}
break;
case CTL_SERVER: {
char *label,*dnsaddr;
int indx;
uint16_t cmd2;
DEBUG_MSG("Received SERVER command.\n");
if (read_allocstring(rs,&label,NULL)<=0) {
print_serr(rs,"Error reading server label.");
break;
}
if (!read_short(rs,&cmd2)) {
print_serr(rs,"Missing up|down|retest.");
goto free_label_break;
}
if(!read_allocstring(rs, &dnsaddr,NULL)) {
print_serr(rs,"Error reading DNS addresses.");
goto free_label_break;
}
/* Note by Paul Rombouts:
We are about to access server configuration data.
Now that the configuration can be changed during run time,
we should be using locks before accessing server config data, even if it
is read-only access.
However, as long as this is the only thread that calls reload_config_file()
it should be OK to read the server config without locks, but it is
something to keep in mind.
*/
{
char *endptr;
indx=strtol(label,&endptr,0);
if(!*endptr) {
if (indx<0 || indx>=DA_NEL(servers)) {
print_serr(rs,"Server index out of range.");
goto free_dnsaddr_label_break;
}
}
else {
if (!strcmp(label, "all"))
indx=-2; /* all servers */
else
indx=-1; /* compare names */
}
}
if(cmd2==CTL_S_UP || cmd2==CTL_S_DOWN || cmd2==CTL_S_RETEST) {
if(!dnsaddr) {
if (indx==-1) {
int i;
for (i=0;i<DA_NEL(servers);++i) {
char *servlabel=DA_INDEX(servers,i).label;
if (servlabel && !strcmp(servlabel,label))
goto found_label;
}
print_serr(rs,"Bad server label.");
goto free_dnsaddr_label_break;
found_label:;
}
if(mark_servers(indx,(indx==-1)?label:NULL,(cmd2==CTL_S_RETEST)?-1:(cmd2==CTL_S_UP))==0)
print_succ(rs);
else
print_serr(rs,"Could not start up or signal server status thread.");
}
else { /* Change server addresses */
if(indx==-2) {
print_serr(rs,"Can't use label \"all\" to change server addresses.");
goto free_dnsaddr_label_break;
}
if(indx==-1) {
int i;
for(i=0;i<DA_NEL(servers);++i) {
char *servlabel=DA_INDEX(servers,i).label;
if (servlabel && !strcmp(servlabel,label)) {
if(indx!=-1) {
print_serr(rs,"server label must be unique to change server addresses.");
goto free_dnsaddr_label_break;
}
indx=i;
}
}
if(indx==-1) {
print_serr(rs,"Bad server label.");
goto free_dnsaddr_label_break;
}
}
{
char *ipstr,*q=dnsaddr;
addr_array ar=NULL;
pdnsd_a addr;
int err;
for(;;) {
for(;;) {
if(!*q) goto change_servs;
if(*q!=',' && !isspace(*q)) break;
++q;
}
ipstr=q;
for(;;) {
++q;
if(!*q) break;
if(*q==',' || isspace(*q)) {*q++=0; break; }
}
if(!str2pdnsd_a(ipstr,&addr)) {
print_serr(rs,"Bad server ip");
goto free_ar;
}
if(!(ar=DA_GROW1(ar))) {
print_serr(rs,"Out of memory.");
goto free_dnsaddr_label_break;
}
DA_LAST(ar)=addr;
}
change_servs:
err=change_servers(indx,ar,(cmd2==CTL_S_RETEST)?-1:(cmd2==CTL_S_UP));
if(err==0)
print_succ(rs);
else
print_serr(rs,err==ETIMEDOUT?"Timed out while trying to gain access to server data.":
err==ENOMEM?"Out of memory.":
"Could not start up or signal server status thread.");
free_ar:
da_free(ar);
}
}
}
else
print_serr(rs,"Bad command.");
free_dnsaddr_label_break:
free(dnsaddr);
free_label_break:
free(label);
}
break;
case CTL_RECORD: {
uint16_t cmd2;
unsigned char name[DNSNAMEBUFSIZE],buf[DNSNAMEBUFSIZE];
DEBUG_MSG("Received RECORD command.\n");
if (!read_short(rs,&cmd2))
goto incomplete_command;
if (read_domain(rs, charp buf, sizeof(buf))<=0)
goto incomplete_command;
if ((errmsg=parsestr2rhn(buf,sizeof(buf),name))!=NULL)
goto bad_domain_name;
switch (cmd2) {
case CTL_R_DELETE:
del_cache(name);
print_succ(rs);
break;
case CTL_R_INVAL:
invalidate_record(name);
print_succ(rs);
break;
default:
print_serr(rs,"Bad command.");
}
}
break;
case CTL_SOURCE: {
uint32_t ttl;
char *fn;
uint16_t servaliases,flags;
unsigned char buf[DNSNAMEBUFSIZE],owner[DNSNAMEBUFSIZE];
DEBUG_MSG("Received SOURCE command.\n");
if (read_allocstring(rs,&fn,NULL)<=0) {
print_serr(rs,"Bad filename name.");
break;
}
if (read_domain(rs, charp buf, sizeof(buf))<=0 ||
!read_long(rs,&ttl) ||
!read_short(rs,&servaliases) || /* serve aliases */
!read_short(rs,&flags)) /* caching flags */
{
print_serr(rs,"Malformed or incomplete command.");
goto free_fn;
}
if ((errmsg=parsestr2rhn(buf,sizeof(buf),owner))!=NULL) {
print_serr(rs,errmsg);
goto free_fn;
}
if (ttl < 0) {
print_serr(rs, "Bad TTL.");
goto free_fn;
}
if(flags&DF_NEGATIVE) {
print_serr(rs, "Bad cache flags.");
goto free_fn;
}
{
char *errmsg;
if (read_hosts(fn,owner,ttl,flags,servaliases,&errmsg))
print_succ(rs);
else {
print_serr(rs,errmsg?:"Out of memory.");
free(errmsg);
}
}
free_fn:
free(fn);
}
break;
case CTL_ADD: {
uint32_t ttl;
unsigned sz;
uint16_t tp,flags,nadr=0;
unsigned char name[DNSNAMEBUFSIZE],buf[DNSNAMEBUFSIZE],dbuf[2+DNSNAMEBUFSIZE];
size_t adrbufsz=0;
unsigned char *adrbuf=NULL;
DEBUG_MSG("Received ADD command.\n");
if (!read_short(rs,&tp))
goto incomplete_command;
if (read_domain(rs, charp buf, sizeof(buf))<=0)
goto incomplete_command;
if (!read_long(rs,&ttl))
goto incomplete_command;
if (!read_short(rs,&flags)) /* caching flags */
goto incomplete_command;
if ((errmsg=parsestr2rhn(buf,sizeof(buf),name))!=NULL)
goto bad_domain_name;
if (ttl < 0)
goto bad_ttl;
if(flags&DF_NEGATIVE)
goto bad_flags;
switch (tp) {
case T_A:
sz=sizeof(struct in_addr);
#if ALLOW_LOCAL_AAAA
goto read_adress_list;
case T_AAAA:
sz=sizeof(struct in6_addr);
read_adress_list:
#endif
if (!read_short(rs,&nadr))
goto incomplete_command;
if (!nadr)
goto bad_arg;
adrbufsz= nadr * (size_t)sz;
adrbuf= malloc(adrbufsz);
if(!adrbuf)
goto out_of_memory;
{
size_t nread=0;
while(nread<adrbufsz) {
ssize_t m=read(rs,adrbuf+nread,adrbufsz-nread);
if(m<=0) {free(adrbuf); goto bad_arg;}
nread += m;
}
}
break;
case T_CNAME:
case T_PTR:
case T_NS:
if (read_domain(rs, charp buf, sizeof(buf))<=0)
goto incomplete_command;
if ((errmsg=parsestr2rhn(buf,sizeof(buf),dbuf))!=NULL)
goto bad_domain_name;
sz=rhnlen(dbuf);
break;
case T_MX:
if (read(rs,dbuf,2)!=2)
goto bad_arg;
if (read_domain(rs, charp buf, sizeof(buf))<=0)
goto incomplete_command;
if ((errmsg=parsestr2rhn(buf,sizeof(buf),dbuf+2))!=NULL)
goto bad_domain_name;
sz=rhnlen(dbuf+2)+2;
break;
default:
goto bad_arg;
}
{
dns_cent_t cent;
if (!init_cent(¢, name, 0, 0, flags DBG1)) {
free(adrbuf);
goto out_of_memory;
}
if(adrbuf) {
unsigned char *adrp; int i;
for(adrp=adrbuf,i=0; i<nadr; adrp += sz,++i) {
if (!add_cent_rr(¢,tp,ttl,0,CF_LOCAL,sz,adrp DBG1)) {
free_cent(¢ DBG1);
free(adrbuf);
goto out_of_memory;
}
}
free(adrbuf);
}
else if (!add_cent_rr(¢,tp,ttl,0,CF_LOCAL,sz,dbuf DBG1)) {
free_cent(¢ DBG1);
goto out_of_memory;
}
if(cent.qname[0]==1 && cent.qname[1]=='*') {
/* Wild card record.
Set the DF_WILD flag for the name with '*.' removed. */
if(!set_cent_flags(¢.qname[2],DF_WILD)) {
print_serr(rs,
"Before defining records for a name with a wildcard"
" you must first define some records for the name"
" with '*.' removed.");
goto cleanup_cent;
}
}
add_cache(¢);
print_succ(rs);
cleanup_cent:
free_cent(¢ DBG1);
}
}
break;
case CTL_NEG: {
uint32_t ttl;
uint16_t tp;
unsigned char name[DNSNAMEBUFSIZE],buf[DNSNAMEBUFSIZE];
DEBUG_MSG("Received NEG command.\n");
if (read_domain(rs, charp buf, sizeof(buf))<=0)
goto incomplete_command;
if (!read_short(rs,&tp))
goto incomplete_command;
if (!read_long(rs,&ttl))
goto incomplete_command;
if ((errmsg=parsestr2rhn(buf,sizeof(buf),name))!=NULL) {
DEBUG_MSG("NEG: received bad domain name.\n");
goto bad_domain_name;
}
if (tp!=255 && PDNSD_NOT_CACHED_TYPE(tp)) {
DEBUG_MSG("NEG: received bad record type.\n");
print_serr(rs,"Bad record type.");
break;
}
if (ttl < 0)
goto bad_ttl;
{
dns_cent_t cent;
if (tp==255) {
if (!init_cent(¢, name, ttl, 0, DF_LOCAL|DF_NEGATIVE DBG1))
goto out_of_memory;
} else {
if (!init_cent(¢, name, 0, 0, 0 DBG1))
goto out_of_memory;
if (!add_cent_rrset_by_type(¢,tp,ttl,0,CF_LOCAL|CF_NEGATIVE DBG1)) {
free_cent(¢ DBG1);
goto out_of_memory;
}
}
add_cache(¢);
free_cent(¢ DBG1);
}
print_succ(rs);
}
break;
case CTL_CONFIG: {
char *fn,*errmsg;
DEBUG_MSG("Received CONFIG command.\n");
if (!read_allocstring(rs,&fn,NULL)) {
print_serr(rs,"Bad filename name.");
break;
}
if (reload_config_file(fn,&errmsg))
print_succ(rs);
else {
print_serr(rs,errmsg?:"Out of memory.");
free(errmsg);
}
free(fn);
}
break;
case CTL_INCLUDE: {
char *fn,*errmsg;
DEBUG_MSG("Received INCLUDE command.\n");
if (read_allocstring(rs,&fn,NULL)<=0) {
print_serr(rs,"Bad filename name.");
break;
}
if (read_config_file(fn,NULL,NULL,0,&errmsg))
print_succ(rs);
else {
print_serr(rs,errmsg?:"Out of memory.");
free(errmsg);
}
free(fn);
}
break;
case CTL_EVAL: {
char *str,*errmsg;
DEBUG_MSG("Received EVAL command.\n");
if (!read_allocstring(rs,&str,NULL)) {
print_serr(rs,"Bad input string.");
break;
}
if (confparse(NULL,str,NULL,NULL,0,&errmsg))
print_succ(rs);
else {
print_serr(rs,errmsg?:"Out of memory.");
free(errmsg);
}
free(str);
}
break;
case CTL_EMPTY: {
slist_array sla=NULL;
char *names; unsigned len;
DEBUG_MSG("Received EMPTY command.\n");
if (!read_allocstring(rs,&names,&len)) {
print_serr(rs,"Bad arguments.");
break;
}
if(names) {
char *p=names, *last=names+len;
while(p<last) {
int tp;
char *q;
slist_t *sl;
unsigned sz;
unsigned char rhn[DNSNAMEBUFSIZE];
if(*p=='-') {
tp=C_EXCLUDED;
++p;
}
else {
tp=C_INCLUDED;
if(*p=='+') ++p;
}
/* skip a possible leading dot. */
if(p+1<last && *p=='.' && *(p+1)) ++p;
q=p;
while(q<last && *q) ++q;
if ((errmsg=parsestr2rhn(ucharp p,q-p,rhn))!=NULL) {
DEBUG_MSG("EMPTY: received bad domain name: %s\n",p);
print_serr(rs,errmsg);
goto free_sla_names_break;
}
sz=rhnlen(rhn);
if (!(sla=DA_GROW1_F(sla,free_slist_domain))) {
print_serr(rs,"Out of memory.");
goto free_names_break;
}
sl=&DA_LAST(sla);
if (!(sl->domain=malloc(sz))) {
print_serr(rs,"Out of memory.");
goto free_sla_names_break;
}
memcpy(sl->domain,rhn,sz);
sl->exact=0;
sl->rule=tp;
p = q+1;
}
}
if(empty_cache(sla))
print_succ(rs);
else
print_serr(rs,"Could not lock the cache.");
free_sla_names_break:
free_slist_array(sla);
free_names_break:
free(names);
}
break;
case CTL_DUMP: {
int rv,exact=0;
unsigned char *nm=NULL;
char buf[DNSNAMEBUFSIZE];
unsigned char rhn[DNSNAMEBUFSIZE];
DEBUG_MSG("Received DUMP command.\n");
if (!(rv=read_domain(rs,buf,sizeof(buf)))) {
print_serr(rs,"Bad domain name.");
break;
}
if(rv>0) {
int sz;
exact=1; nm= ucharp buf; sz=sizeof(buf);
if(buf[0]=='.' && buf[1]) {
exact=0; ++nm; --sz;
}
if ((errmsg=parsestr2rhn(nm,sz,rhn))!=NULL)
goto bad_domain_name;
nm=rhn;
}
if(!print_succ(rs))
break;
if((rv=dump_cache(rs,nm,exact))<0 ||
(!rv && fsprintf(rs,"Could not find %s%s in the cache.\n",
exact?"":nm?"any entries matching ":"any entries",
nm?buf:"")<0))
{
DEBUG_MSG("Error writing to control socket: %s\n",strerror(errno));
}
}
break;
incomplete_command:
print_serr(rs,"Malformed or incomplete command.");
break;
bad_arg:
print_serr(rs,"Bad arg.");
break;
bad_domain_name:
print_serr(rs,errmsg);
break;
bad_ttl:
print_serr(rs, "Bad TTL.");
break;
bad_flags:
print_serr(rs, "Bad cache flags.");
break;
out_of_memory:
print_serr(rs,"Out of memory.");
break;
default:
print_serr(rs,"Unknown command.");
}
}
else {
DEBUG_MSG("Incorrect magic number in status-socket command code: %02x\n",cmd>>8);
print_serr(rs,"Command code contains incompatible version number.");
}
}
else {
static rrset_type *
read_rrset(namedb_type *db,
uint32_t domain_count, domain_type **domains,
uint32_t zone_count, zone_type **zones)
{
rrset_type *rrset;
int i, j;
domain_type *owner;
uint16_t type;
uint16_t klass;
uint32_t soa_minimum;
owner = read_domain(db, domain_count, domains);
if (!owner)
return NULL;
rrset = (rrset_type *) region_alloc(db->region, sizeof(rrset_type));
rrset->zone = read_zone(db, zone_count, zones);
if (!rrset->zone)
return NULL;
if (fread(&type, sizeof(type), 1, db->fd) != 1)
return NULL;
type = ntohs(type);
if (fread(&klass, sizeof(klass), 1, db->fd) != 1)
return NULL;
klass = ntohs(klass);
if (fread(&rrset->rr_count, sizeof(rrset->rr_count), 1, db->fd) != 1)
return NULL;
rrset->rr_count = ntohs(rrset->rr_count);
rrset->rrs = (rr_type *) region_alloc(
db->region, rrset->rr_count * sizeof(rr_type));
assert(rrset->rr_count > 0);
for (i = 0; i < rrset->rr_count; ++i) {
rr_type *rr = &rrset->rrs[i];
rr->owner = owner;
rr->type = type;
rr->klass = klass;
if (fread(&rr->rdata_count, sizeof(rr->rdata_count), 1, db->fd) != 1)
return NULL;
rr->rdata_count = ntohs(rr->rdata_count);
rr->rdatas = (rdata_atom_type *) region_alloc(
db->region, rr->rdata_count * sizeof(rdata_atom_type));
if (fread(&rr->ttl, sizeof(rr->ttl), 1, db->fd) != 1)
return NULL;
rr->ttl = ntohl(rr->ttl);
for (j = 0; j < rr->rdata_count; ++j) {
if (!read_rdata_atom(db, rr->type, j, domain_count, domains, &rr->rdatas[j]))
return NULL;
}
}
domain_add_rrset(owner, rrset);
if (rrset_rrtype(rrset) == TYPE_SOA) {
assert(owner == rrset->zone->apex);
rrset->zone->soa_rrset = rrset;
/* BUG #103 add another soa with a tweaked ttl */
rrset->zone->soa_nx_rrset = region_alloc(db->region, sizeof(rrset_type));
rrset->zone->soa_nx_rrset->rrs =
region_alloc(db->region, rrset->rr_count * sizeof(rr_type));
memcpy(rrset->zone->soa_nx_rrset->rrs, rrset->rrs, sizeof(rr_type));
rrset->zone->soa_nx_rrset->rr_count = 1;
rrset->zone->soa_nx_rrset->next = 0;
/* also add a link to the zone */
rrset->zone->soa_nx_rrset->zone = rrset->zone;
/* check the ttl and MINIMUM value and set accordinly */
memcpy(&soa_minimum, rdata_atom_data(rrset->rrs->rdatas[6]),
rdata_atom_size(rrset->rrs->rdatas[6]));
if (rrset->rrs->ttl > ntohl(soa_minimum)) {
rrset->zone->soa_nx_rrset->rrs[0].ttl = ntohl(soa_minimum);
}
owner->has_SOA = 1;
} else if (owner == rrset->zone->apex
&& rrset_rrtype(rrset) == TYPE_NS)
{
rrset->zone->ns_rrset = rrset;
}
#ifdef NSEC3
#ifndef FULL_PREHASH
else if (type == TYPE_NSEC3) {
if (0 != namedb_add_nsec3_domain(db, owner, rrset->zone)) {
return NULL;
}
}
#endif /* !FULL_PREHASH */
#endif /* NSEC3 */
if (rrset_rrtype(rrset) == TYPE_RRSIG && owner == rrset->zone->apex) {
for (i = 0; i < rrset->rr_count; ++i) {
if (rr_rrsig_type_covered(&rrset->rrs[i]) == TYPE_DNSKEY) {
rrset->zone->is_secure = 1;
break;
}
}
}
return rrset;
}
int main(int argc, char *argv[]) {
int j;
int n;
int status;
char directory[256],outputdir[256];
if (argc > 4) {
printf("Too many arguments.Only using first 3.\n");
}
n = atoi(argv[1]);
time_step = atof(argv[2]);
strcpy(directory,argv[3]);
nb = 2;
sprintf(outputdir,"%stemp_files/",directory);
status = mkdir(outputdir,S_IRWXU | S_IRWXG | S_IRWXO);
if (status == -33) {
printf("Status is -33 for some reason.\n");
}
//sprintf(param_fname,"%sparam_file.txt",directory);
read_param_file(directory);
nx = params.nx;
ny = params.ny;
nz = params.nz;
CFL = params.cfl;
IndirectTerm = params.indirect;
size_x = nx;
size_y = ny+2*NGHY;
size_z = nz;
stride = size_x*size_y;
pitch = size_x;
pitch2d = 0;
//size_t double_to_int = sizeof(double)/sizeof(int);
pitch2d_int = 0 ;//pitch*(int)double_to_int;
dx = 2*M_PI/nx;
if (size_x % 2 == 0) NEVEN = TRUE;
else NEVEN = FALSE;
num_threads = 1;
#ifdef _OPENMP
//omp_set_num_threads(8);
num_threads = omp_get_max_threads();
printf("Using %d threads\n",num_threads);
#endif
allocate_all();
#ifdef _FFTW
allocate_conv();
#endif
read_domain(directory);
read_files(n,directory);
//read_single_file(n,1,directory);
/*
if (cfl_dt < dt) {
printf("Using cfl limited timestep of %.4e instead of %.4e\n",cfl_dt,dt);
dt = cfl_dt;
}
*/
//move_to_com();
read_stockholm(directory);
/*
for(j=0;j<size_y;j++) {
dens0[j] = params.mdot/(3*M_PI*Nu(ymed(j)));
vy0[j] = -1.5*Nu(ymin(j))/ymin(j);
vx0[j] = pow(ymed(j),-.5);
vx0[j] *= sqrt(1.0+pow(params.h,2)*pow(ymed(j),2*params.flaringindex)*
(2.0*params.flaringindex - 1.5));
vx0[j] -= omf*ymed(j);
}
*/
omf0 = omf;
output_stock(outputdir);
output_init(outputdir);
init_rk5();
nsteps = 0;
double tstart = psys[0].t;
double tend = psys[0].t + time_step;
double time = tstart;
#ifdef _FFTW
printf("Using FFTW to compute fourier transforms\n");
#endif
#ifdef ARTIFICIALVISCOSITY
printf("Using ARTIFICIAL VISCOSITY\n");
#endif
#ifdef FARGO
printf("Using FARGO TRANSPORT\n");
#endif
#ifdef STOCKHOLMACC
printf("Damping to current average in stockholm boundaries.\n");
#endif
#ifdef NOWAVEKILLRHO
printf("Not damping the density.\n");
#endif
#ifdef FIXEDPSYS
printf("Planetary system is FIXED.\n");
#endif
printf("Starting time = %.3f\nEnding time = %.3f\n",tstart,tend);
set_bc();
set_dtLt(-1.0);
while ((time < tend) && nsteps<MAXSTEPS) {
#ifdef FARGO
compute_vmed(vx);
#endif
dt = cfl();
if (dt <= MINDT) {
printf("Timestep has fallen below minimum!\n");
break;
}
if (time + dt > tend) {
dt = tend-time;
}
printf("\r t=%.3f, dt = %.8f, %02d%% complete...",time,dt,(int)(100*(time-tstart)/(tend-tstart)));
fflush(stdout);
set_avg(0);
potential();
#ifndef FIXEDPSYS
move_planet();
#endif
source_step();
set_Lamex();
viscosity();
#ifdef ARTIFICIALVISCOSITY
artificial_visc();
#endif
temp_to_vel();
set_bc();
vel_to_temp();
#ifdef FARGO
compute_vmed(vx_temp);
#endif
transport_step();
time += dt;
set_avg(1);
set_Lamdep();
set_bc();
stockholm();
//output_psys(outputdir,nsteps);
nsteps++;
}
// temp_to_vel();
set_dtLt(1.0);
dt = tend - tstart;
for(j=0;j<size_y;j++) {
dbart[j]/=dt;
//Lt[j]/=dt;
//Lt[j+size_y]/=dt;
//Ld[j]/=dt;
//Ld[j+size_y]/=dt;
//Lw[j]/=dt;
//Lw[j+size_y]/=dt;
Lw[j] = Lt[j] - Ld[j];
Lw[j+size_y] = Lt[j+size_y] - Ld[j+size_y];
drFt[j]/=dt;
drFd[j]/=dt;
drFdB[j]/=dt;
mdotl[j]/=dt;
drFnu[j]/=dt;
drFw[j]/=dt;
drFwB[j]/=dt;
Lamex[j]/=dt;
//Lamex[j+size_y]/=dt;
Lamdep[j]/=dt;
LamdepB[j]/=dt;
dtLt[j]/=dt;
dtLd[j]/=dt;
dtLw[j]/=dt;
dtLd_rhs[j]/=dt;
mdotavg[j] /= dt;
LamdepS[j + size_y*0] /= dt;
LamdepS[j + size_y*1] /= dt;
LamdepS[j + size_y*2] /= dt;
LamdepS[j + size_y*3] /= dt;
LamdepS[j + size_y*4] /= dt;
LamdepS[j + size_y*5] /= dt;
LamdepS[j + size_y*6] /= dt;
}
int mi;
for(mi=1;mi<MMAX+2;mi++) {
for(j=0;j<size_y;j++) {
Lamex[j + size_y*mi] /= dt;
drFd[j + size_y*mi] /= dt;
dtLt[j + size_y*mi] /= dt;
}
}
output(outputdir);
output_torque(directory,n);
output_torque(outputdir,n);
free_rk5();
#ifdef _FFTW
free_conv();
#endif
//free_all();
return 0;
}
