void librandom::GammaRandomDev::set_status(const DictionaryDatum& d)
{
double a_tmp;
if ( updateValue<double>(d, "order", a_tmp) )
set_order(a_tmp);
}
void g::get_independences( int * tab, int p, int max_is){
all_independent_sets( max_is, p );
/* for( int i = 0; i < max_is; i++ ){
cout << cliques[i].size() << endl;
}*/
for( uint64_t i = 0; i < p; i++ ){
int k = max_is;
uint64_t s = (~i) & ( ( 1 << n ) - 1 );
tab[i] = k;
bool no_is = true;
while( no_is && k > 0 ){
//for( vector< uint64_t >::iterator it = cliques[k-1].begin();
// it != cliques[k-1].end() && no_is; it++ ){
// cerr << s << " " << *it << endl;
if( set_order(s) >= k ){
for( int cl = 0; cl < clique_num[k-1]; cl++ ){
if( ( s | cliques[k-1][cl] ) == s ){
no_is = false;
}
}
}
if( no_is ){
tab[i]--;
k--;
}
}
}
delete [] cliques;
delete [] clique_num;
}
// by default, init as exponential density with mean 1
librandom::GammaRandomDev::GammaRandomDev( RngPtr r_source, double a_in )
: RandomDev( r_source )
, a( a_in )
, b_( 1.0 )
{
set_order( a );
}
librandom::GammaRandomDev::GammaRandomDev( double a_in )
: RandomDev()
, a( a_in )
, b_( 1.0 )
{
set_order( a );
}
void ManagerBase::notifyDiscardNotify(Seat* s, const CircleRecord* r)
{
Message m(MsgType::DiscardNotify);
auto msg = m.get<DiscardNotifyMsg>();
msg->set_seat(s->id());
msg->set_order(r ? r->circle().size() : 0);
notify(&m);
}
void CPSong::reset(bool p_clear_patterns,bool p_clear_samples,bool p_clear_instruments,bool p_clear_variables) {
if (p_clear_variables) {
variables.name[0]=0;
variables.message[0]=0;
variables.row_highlight_major=16;
variables.row_highlight_minor=4;
variables.mixing_volume=48;
variables.old_effects=false;
if (p_clear_instruments) //should not be cleared, if not clearing instruments!!
variables.use_instruments=false;
variables.stereo_separation=128;
variables.use_linear_slides=true;
variables.use_stereo=true;
initial_variables.global_volume=128;
initial_variables.speed=6;
initial_variables.tempo=125;
for (int i=0;i<CPPattern::WIDTH;i++) {
initial_variables.channel[i].pan=32;
initial_variables.channel[i].volume=CHANNEL_MAX_VOLUME;
initial_variables.channel[i].mute=false;
initial_variables.channel[i].surround=false;
initial_variables.channel[i].chorus=0;
initial_variables.channel[i].reverb=0;
}
effects.chorus.delay_ms=6;
effects.chorus.separation_ms=3;
effects.chorus.depth_ms10=6,
effects.chorus.speed_hz10=5;
effects.reverb_mode=REVERB_MODE_ROOM;
}
if (p_clear_samples) {
for (int i=0;i<MAX_SAMPLES;i++)
get_sample(i)->reset();
}
if (p_clear_instruments) {
for (int i=0;i<MAX_INSTRUMENTS;i++)
get_instrument(i)->reset();
}
if (p_clear_patterns) {
for (int i=0;i<MAX_PATTERNS;i++)
get_pattern(i)->clear();
for (int i=0;i<MAX_ORDERS;i++)
set_order( i, CP_ORDER_NONE );
}
}
void CPSong::cleanup_unused_orders(){
bool finito=false;
for (int j=0;j<MAX_ORDERS;j++) {
if (get_order(j)==CP_ORDER_NONE)
finito=true;
if (finito)
set_order(j,CP_ORDER_NONE);
}
}
void librandom::GammaRandomDev::set_status(const DictionaryDatum& d)
{
double a_new = a;
double b_new = b_;
updateValue<double>(d, "order", a_new);
updateValue<double>(d, "scale", b_new);
if ( a_new <= 0. )
throw BadParameterValue("Gamma RDV: order > 0 required.");
if ( b_new <= 0. )
throw BadParameterValue("Gamma RDV: scale > 0 required.");
set_order(a_new);
b_ = b_new;
}
static void guardian_faction(plane * pl, int id)
{
region *r;
faction *f = findfaction(id);
if (!f) {
f = calloc(1, sizeof(faction));
f->banner = _strdup("Sie dienen dem großen Wyrm");
f->passw = _strdup(itoa36(rng_int()));
set_email(&f->email, "*****@*****.**");
f->name = _strdup("Igjarjuks Kundschafter");
f->race = new_race[RC_ILLUSION];
f->age = turn;
f->locale = find_locale("de");
f->options =
want(O_COMPRESS) | want(O_REPORT) | want(O_COMPUTER) | want(O_ADRESSEN) |
want(O_DEBUG);
f->no = id;
addlist(&factions, f);
fhash(f);
}
if (f->race != new_race[RC_ILLUSION]) {
assert(!"guardian id vergeben");
exit(0);
}
f->lastorders = turn;
f->alive = true;
for (r = regions; r; r = r->next)
if (getplane(r) == pl && rterrain(r) != T_FIREWALL) {
unit *u;
freset(r, RF_ENCOUNTER);
for (u = r->units; u; u = u->next) {
if (u->faction == f)
break;
}
if (u)
continue;
u = createunit(r, f, 1, new_race[RC_GOBLIN]);
set_string(&u->name, "Igjarjuks Auge");
set_item(u, I_RING_OF_INVISIBILITY, 1);
set_order(&u->thisorder, NULL);
fset(u, UFL_ANON_FACTION);
set_money(u, 1000);
}
}
static DBusMessage *pbap_set_order(DBusConnection *connection,
DBusMessage *message, void *user_data)
{
struct pbap_data *pbap = user_data;
const char *order;
if (dbus_message_get_args(message, NULL,
DBUS_TYPE_STRING, &order,
DBUS_TYPE_INVALID) == FALSE)
return g_dbus_create_error(message,
ERROR_INF ".InvalidArguments", NULL);
if (set_order(pbap, order) < 0)
return g_dbus_create_error(message,
ERROR_INF ".InvalidArguments", "InvalidFilter");
return dbus_message_new_method_return(message);
}
void u_setfaction(unit * u, faction * f)
{
int cnt = u->number;
if (u->faction == f)
return;
if (u->faction) {
set_number(u, 0);
if (count_unit(u))
--u->faction->no_units;
join_group(u, NULL);
free_orders(&u->orders);
set_order(&u->thisorder, NULL);
if (u->nextF)
u->nextF->prevF = u->prevF;
if (u->prevF)
u->prevF->nextF = u->nextF;
else
u->faction->units = u->nextF;
}
if (f != NULL) {
if (f->units)
f->units->prevF = u;
u->prevF = NULL;
u->nextF = f->units;
f->units = u;
} else
u->nextF = NULL;
u->faction = f;
if (u->region)
update_interval(f, u->region);
if (cnt && f) {
set_number(u, cnt);
if (count_unit(u))
++f->no_units;
}
}
/*%
* Get a list of IP addresses and port numbers for host hostname and
* service servname.
*/
int
getaddrinfo(const char *hostname, const char *servname,
const struct addrinfo *hints, struct addrinfo **res)
{
struct servent *sp;
const char *proto;
int family, socktype, flags, protocol;
struct addrinfo *ai, *ai_list;
int err = 0;
int port, i;
int (*net_order[FOUND_MAX+1])(const char *, int, struct addrinfo **,
int, int);
if (hostname == NULL && servname == NULL)
return (EAI_NONAME);
proto = NULL;
if (hints != NULL) {
if ((hints->ai_flags & ~(ISC_AI_MASK)) != 0)
return (EAI_BADFLAGS);
if (hints->ai_addrlen || hints->ai_canonname ||
hints->ai_addr || hints->ai_next) {
errno = EINVAL;
return (EAI_SYSTEM);
}
family = hints->ai_family;
socktype = hints->ai_socktype;
protocol = hints->ai_protocol;
flags = hints->ai_flags;
switch (family) {
case AF_UNSPEC:
switch (hints->ai_socktype) {
case SOCK_STREAM:
proto = "tcp";
break;
case SOCK_DGRAM:
proto = "udp";
break;
}
break;
case AF_INET:
case AF_INET6:
switch (hints->ai_socktype) {
case 0:
break;
case SOCK_STREAM:
proto = "tcp";
break;
case SOCK_DGRAM:
proto = "udp";
break;
case SOCK_RAW:
break;
default:
return (EAI_SOCKTYPE);
}
break;
#ifdef AF_LOCAL
case AF_LOCAL:
switch (hints->ai_socktype) {
case 0:
break;
case SOCK_STREAM:
break;
case SOCK_DGRAM:
break;
default:
return (EAI_SOCKTYPE);
}
break;
#endif
default:
return (EAI_FAMILY);
}
} else {
protocol = 0;
family = 0;
socktype = 0;
flags = 0;
}
#ifdef AF_LOCAL
/*!
* First, deal with AF_LOCAL. If the family was not set,
* then assume AF_LOCAL if the first character of the
* hostname/servname is '/'.
*/
if (hostname != NULL &&
(family == AF_LOCAL || (family == 0 && *hostname == '/')))
return (get_local(hostname, socktype, res));
if (servname != NULL &&
(family == AF_LOCAL || (family == 0 && *servname == '/')))
return (get_local(servname, socktype, res));
#endif
/*
* Ok, only AF_INET and AF_INET6 left.
*/
ai_list = NULL;
/*
* First, look up the service name (port) if it was
* requested. If the socket type wasn't specified, then
* try and figure it out.
*/
if (servname != NULL) {
char *e;
port = strtol(servname, &e, 10);
if (*e == '\0') {
if (socktype == 0)
return (EAI_SOCKTYPE);
if (port < 0 || port > 65535)
return (EAI_SERVICE);
port = htons((unsigned short) port);
} else {
sp = getservbyname(servname, proto);
if (sp == NULL)
return (EAI_SERVICE);
port = sp->s_port;
if (socktype == 0) {
if (strcmp(sp->s_proto, "tcp") == 0)
socktype = SOCK_STREAM;
else if (strcmp(sp->s_proto, "udp") == 0)
socktype = SOCK_DGRAM;
}
}
} else
port = 0;
/*
* Next, deal with just a service name, and no hostname.
* (we verified that one of them was non-null up above).
*/
if (hostname == NULL && (flags & AI_PASSIVE) != 0) {
if (family == AF_INET || family == 0) {
ai = ai_alloc(AF_INET, sizeof(struct sockaddr_in));
if (ai == NULL)
return (EAI_MEMORY);
ai->ai_socktype = socktype;
ai->ai_protocol = protocol;
SIN(ai->ai_addr)->sin_port = port;
ai->ai_next = ai_list;
ai_list = ai;
}
if (family == AF_INET6 || family == 0) {
ai = ai_alloc(AF_INET6, sizeof(struct sockaddr_in6));
if (ai == NULL) {
_freeaddrinfo(ai_list);
return (EAI_MEMORY);
}
ai->ai_socktype = socktype;
ai->ai_protocol = protocol;
SIN6(ai->ai_addr)->sin6_port = port;
ai->ai_next = ai_list;
ai_list = ai;
}
*res = ai_list;
return (0);
}
/*
* If the family isn't specified or AI_NUMERICHOST specified, check
* first to see if it is a numeric address.
* Though the gethostbyname2() routine will recognize numeric addresses,
* it will only recognize the format that it is being called for. Thus,
* a numeric AF_INET address will be treated by the AF_INET6 call as
* a domain name, and vice versa. Checking for both numerics here
* avoids that.
*/
if (hostname != NULL &&
(family == 0 || (flags & AI_NUMERICHOST) != 0)) {
char abuf[sizeof(struct in6_addr)];
char nbuf[NI_MAXHOST];
int addrsize, addroff;
#ifdef IRS_HAVE_SIN6_SCOPE_ID
char *p, *ep;
char ntmp[NI_MAXHOST];
isc_uint32_t scopeid;
#endif
#ifdef IRS_HAVE_SIN6_SCOPE_ID
/*
* Scope identifier portion.
*/
ntmp[0] = '\0';
if (strchr(hostname, '%') != NULL) {
strncpy(ntmp, hostname, sizeof(ntmp) - 1);
ntmp[sizeof(ntmp) - 1] = '\0';
p = strchr(ntmp, '%');
ep = NULL;
/*
* Vendors may want to support non-numeric
* scopeid around here.
*/
if (p != NULL)
scopeid = (isc_uint32_t)strtoul(p + 1,
&ep, 10);
if (p != NULL && ep != NULL && ep[0] == '\0')
*p = '\0';
else {
ntmp[0] = '\0';
scopeid = 0;
}
} else
scopeid = 0;
#endif
if (inet_pton(AF_INET, hostname, (struct in_addr *)abuf)
== 1) {
if (family == AF_INET6) {
/*
* Convert to a V4 mapped address.
*/
struct in6_addr *a6 = (struct in6_addr *)abuf;
memmove(&a6->s6_addr[12], &a6->s6_addr[0], 4);
memset(&a6->s6_addr[10], 0xff, 2);
memset(&a6->s6_addr[0], 0, 10);
goto inet6_addr;
}
addrsize = sizeof(struct in_addr);
addroff = (char *)(&SIN(0)->sin_addr) - (char *)0;
family = AF_INET;
goto common;
#ifdef IRS_HAVE_SIN6_SCOPE_ID
} else if (ntmp[0] != '\0' &&
inet_pton(AF_INET6, ntmp, abuf) == 1) {
if (family && family != AF_INET6)
return (EAI_NONAME);
addrsize = sizeof(struct in6_addr);
addroff = (char *)(&SIN6(0)->sin6_addr) - (char *)0;
family = AF_INET6;
goto common;
#endif
} else if (inet_pton(AF_INET6, hostname, abuf) == 1) {
if (family != 0 && family != AF_INET6)
return (EAI_NONAME);
inet6_addr:
addrsize = sizeof(struct in6_addr);
addroff = (char *)(&SIN6(0)->sin6_addr) - (char *)0;
family = AF_INET6;
common:
ai = ai_alloc(family,
((family == AF_INET6) ?
sizeof(struct sockaddr_in6) :
sizeof(struct sockaddr_in)));
if (ai == NULL)
return (EAI_MEMORY);
ai_list = ai;
ai->ai_socktype = socktype;
SIN(ai->ai_addr)->sin_port = port;
memmove((char *)ai->ai_addr + addroff, abuf, addrsize);
if ((flags & AI_CANONNAME) != 0) {
#ifdef IRS_HAVE_SIN6_SCOPE_ID
if (ai->ai_family == AF_INET6)
SIN6(ai->ai_addr)->sin6_scope_id =
scopeid;
#endif
if (getnameinfo(ai->ai_addr,
(socklen_t)ai->ai_addrlen,
nbuf, sizeof(nbuf), NULL, 0,
NI_NUMERICHOST) == 0) {
ai->ai_canonname = strdup(nbuf);
if (ai->ai_canonname == NULL) {
_freeaddrinfo(ai);
return (EAI_MEMORY);
}
} else {
/* XXX raise error? */
ai->ai_canonname = NULL;
}
}
goto done;
} else if ((flags & AI_NUMERICHOST) != 0) {
return (EAI_NONAME);
}
}
if (hostname == NULL && (flags & AI_PASSIVE) == 0) {
set_order(family, net_order);
for (i = 0; i < FOUND_MAX; i++) {
if (net_order[i] == NULL)
break;
err = (net_order[i])(hostname, flags, &ai_list,
socktype, port);
if (err != 0) {
if (ai_list != NULL) {
_freeaddrinfo(ai_list);
ai_list = NULL;
}
break;
}
}
} else
err = resolve_name(family, hostname, flags, &ai_list,
socktype, port);
if (ai_list == NULL) {
if (err == 0)
err = EAI_NONAME;
return (err);
}
done:
ai_list = ai_reverse(ai_list);
*res = ai_list;
return (0);
}
void piracy_cmd(unit * u, order *ord)
{
region *r = u->region;
ship *sh = u->ship, *sh2;
direction_t target_dir;
struct {
const faction *target;
int value;
} aff[MAXDIRECTIONS];
int saff = 0;
int *il;
if (!validate_pirate(u, ord)) {
return;
}
il = parse_ids(ord);
/* Feststellen, ob schon ein anderer alliierter Pirat ein
* Ziel gefunden hat. */
target_dir = find_piracy_target(u, il);
/* Wenn nicht, sehen wir, ob wir ein Ziel finden. */
if (target_dir == NODIRECTION) {
direction_t dir;
/* Einheit ist also Kapitän. Jetzt gucken, in wievielen
* Nachbarregionen potentielle Opfer sind. */
for (dir = 0; dir < MAXDIRECTIONS; dir++) {
region *rc = rconnect(r, dir);
aff[dir].value = 0;
aff[dir].target = 0;
if (rc && fval(rc->terrain, SAIL_INTO) && can_takeoff(sh, r, rc)) {
for (sh2 = rc->ships; sh2; sh2 = sh2->next) {
unit *cap = ship_owner(sh2);
if (cap) {
faction *f = visible_faction(cap->faction, cap);
if (alliedunit(u, f, HELP_FIGHT))
continue;
if (!il || intlist_find(il, cap->faction->no)) { // TODO: shouldn't this be f->no?
++aff[dir].value;
if (rng_int() % aff[dir].value == 0) {
aff[dir].target = f;
}
}
}
}
/* Und aufaddieren. */
saff += aff[dir].value;
}
}
if (saff != 0) {
saff = rng_int() % saff;
for (dir = 0; dir != MAXDIRECTIONS; ++dir) {
if (saff < aff[dir].value) {
target_dir = dir;
a_add(&r->attribs, mk_piracy(u->faction, aff[dir].target, target_dir));
break;
}
saff -= aff[dir].value;
}
}
}
free(il);
/* Wenn kein Ziel gefunden, entsprechende Meldung generieren */
if (target_dir == NODIRECTION) {
ADDMSG(&u->faction->msgs, msg_message("piratenovictim",
"ship region", sh, r));
return;
}
/* Meldung generieren */
ADDMSG(&u->faction->msgs, msg_message("piratesawvictim",
"ship region dir", sh, r, target_dir));
/* Befehl konstruieren */
set_order(&u->thisorder, create_order(K_MOVE, u->faction->locale, "%s",
LOC(u->faction->locale, directions[target_dir])));
/* Bewegung ausführen */
init_order(u->thisorder);
move_cmd(u, true);
}
void g::get_independences3( int * tab, int p, int max_is){
all_independent_sets( max_is, p );
bool no_is = true;
int ks = max_is;
// make lists of each order
set_list * slists[ks];
for( int i = 0; i < ks; i++ ){
slists[i] = new set_list( -1, NULL );
}
int o;
tab[ p - 1 ] = 0;
// set_list * slist = new set_list( -1, NULL );
for( int i = 0; i < p-1; i++ ){
tab[i] = 1;
// slist = new set_list( i, slist );
int s = (~i) & ( ( 1 << n ) - 1);
o = set_order(s);
if( o > ks ){
o = ks;
}
slists[o-1] = new set_list( i, slists[o-1] );
}
set_list * slist;
set_list * head;// = slist;
set_list * prev;// = head;
int i, s, cl_num;
for( int k_1 = max_is; k_1 >= 2; k_1-- ){
head = slists[k_1-1];
prev = head;
for( int k = k_1; k > 1; k-- ){
bool no_is = true;
cl_num = clique_num[k-1];
for( int cl = 0; cl < cl_num; cl++ ){
uint64_t clique = cliques[k-1][cl];
// start at beginning
slist = head;
// traverse the whole list
while( slist != NULL ){
i = slist->v;
s = (~i) & ( ( 1 << n ) - 1);
if( ( s | clique ) == s ){
if( slist == head ){
head = slist->next;
delete slist;
slist = head;
}
else{
prev->next = slist->next;
delete slist;
slist = prev->next;
}
tab[i] = k;
}
else{
prev = slist;
slist = slist->next;
}
}
if( head == NULL ){
break;
}
}
if( head == NULL ){
break;
}
}
}
delete [] cliques;
delete [] clique_num;
}
int small_grib(unsigned char **sec, int mode, float *data, double *lon, double *lat, unsigned int ndata,
int ix0, int ix1, int iy0, int iy1, FILE *out) {
int can_subset, grid_template;
int nx, ny, res, scan, new_nx, new_ny, i, j;
unsigned int sec3_len, new_ndata, k, npnts;
unsigned char *sec3, *new_sec[9];
double units;
int basic_ang, sub_ang, cyclic_grid;
float *new_data;
get_nxny(sec, &nx, &ny, &npnts, &res, &scan); /* get nx, ny, and scan mode of grid */
grid_template = code_table_3_1(sec);
// make a copy of the gds (sec3)
sec3_len = GB2_Sec3_size(sec);
sec3 = (unsigned char *) malloc(sec3_len);
for (k = 0; k < sec3_len; k++) sec3[k] = sec[3][k];
// make a copy of the sec[] with new sec3
new_sec[0] = sec[0];
new_sec[1] = sec[1];
new_sec[2] = sec[2];
new_sec[3] = sec3;
new_sec[4] = sec[4];
new_sec[5] = sec[5];
new_sec[6] = sec[6];
new_sec[7] = sec[7];
// new_sec[8] = sec[8]; not needed by writing routines
can_subset = 1;
if (lat == NULL || lon == NULL) can_subset = 0;
new_nx = ix1-ix0+1;
new_ny = iy1-iy0+1;
if (new_nx <= 0) fatal_error("small_grib, new_nx is <= 0","");
if (new_ny <= 0) fatal_error("small_grib, new_ny is <= 0","");
new_ndata = new_nx * new_ny;
cyclic_grid = 0;
if (can_subset) {
cyclic_grid = cyclic(sec);
// lat-lon grid - no thinning
if ((grid_template == 0 && sec3_len == 72) || (grid_template == 1 && sec3_len == 04)) {
uint_char(new_nx,sec3+30); // nx
uint_char(new_ny,sec3+34); // ny
basic_ang = GDS_LatLon_basic_ang(sec3);
sub_ang = GDS_LatLon_sub_ang(sec3);
if (basic_ang != 0) {
units = (double) basic_ang / (double) sub_ang;
}
else {
units = 0.000001;
}
i = lat[ idx(ix0,iy0,nx,ny,cyclic_grid) ] / units; // lat1
int_char(i,sec3+46);
i = lon[ idx(ix0,iy0,nx,ny,cyclic_grid) ] / units; // lon1
int_char(i,sec3+50);
i = lat[ idx(ix1,iy1,nx,ny,cyclic_grid) ] / units; // lat2
int_char(i,sec3+55);
i = lon[ idx(ix1,iy1,nx,ny,cyclic_grid) ] / units; // lon2
int_char(i,sec3+59);
}
else if ((grid_template == 40 && sec3_len == 72)) { // full Gaussian grid
uint_char(new_nx,sec3+30); // nx
uint_char(new_ny,sec3+34); // ny
basic_ang = GDS_Gaussian_basic_ang(sec3);
sub_ang = GDS_Gaussian_sub_ang(sec3);
if (basic_ang != 0) {
units = (double) basic_ang / (double) sub_ang;
}
else {
units = 0.000001;
}
i = lat[ idx(ix0,iy0,nx,ny,cyclic_grid) ] / units; // lat1
int_char(i,sec3+46);
i = lon[ idx(ix0,iy0,nx,ny,cyclic_grid) ] / units; // lon1
int_char(i,sec3+50);
i = lat[ idx(ix1,iy1,nx,ny,cyclic_grid) ] / units; // lat2
int_char(i,sec3+55);
i = lon[ idx(ix1,iy1,nx,ny,cyclic_grid) ] / units; // lon2
int_char(i,sec3+59);
}
// polar-stereo graphic, lambert conformal , no thinning
else if ((grid_template == 20 && sec3_len == 65) || // polar stereographic
(grid_template == 30 && sec3_len == 81)) { // lambert conformal
uint_char(new_nx,sec3+30); // nx
uint_char(new_ny,sec3+34); // ny
i = (int) (lat[ idx(ix0,iy0,nx,ny,cyclic_grid) ] * 1000000.0); // lat1
int_char(i,sec3+38);
i = (int) (lon[ idx(ix0,iy0,nx,ny,cyclic_grid) ] * 1000000.0); // lon1
int_char(i,sec3+42);
}
// mercator, no thinning
else if (grid_template == 10 && sec3_len == 72) { // mercator
uint_char(new_nx,sec3+30); // nx
uint_char(new_ny,sec3+34); // ny
units = 0.000001;
i = lat[ idx(ix0,iy0,nx,ny,cyclic_grid) ] / units; // lat1
int_char(i,sec3+38);
i = lon[ idx(ix0,iy0,nx,ny,cyclic_grid) ] / units; // lon1
int_char(i,sec3+42);
i = lat[ idx(ix1,iy1,nx,ny,cyclic_grid) ] / units; // lat2
int_char(i,sec3+51);
i = lon[ idx(ix1,iy1,nx,ny,cyclic_grid) ] / units; // lon2
int_char(i,sec3+55);
}
else {
can_subset = 0;
}
}
// copy data to a new array
if (can_subset) {
uint_char(new_ndata, sec3+6);
new_data = (float *) malloc(new_ndata * sizeof(float));
#pragma omp parallel for private(i,j,k)
for(j = iy0; j <= iy1; j++) {
k = (j-iy0)*(ix1-ix0+1);
for(i = ix0; i <= ix1; i++) {
new_data[(i-ix0) + k ] = data[ idx(i,j,nx,ny,cyclic_grid) ];
}
}
}
else {
new_ndata = ndata;
new_data = (float *) malloc(new_ndata * sizeof(float));
for (k = 0; k < ndata; k++) new_data[k] = data[k];
new_nx = nx;
new_ny = ny;
}
set_order(new_sec, output_order);
grib_wrt(new_sec, new_data, new_ndata, new_nx, new_ny, use_scale, dec_scale,
bin_scale, wanted_bits, max_bits, grib_type, out);
if (flush_mode) fflush(out);
free(new_data);
free(sec3);
return 0;
}
/** creates a new unit.
*
* @param dname: name, set to NULL to get a default.
* @param creator: unit to inherit stealth, group, building, ship, etc. from
*/
unit *create_unit(region * r, faction * f, int number, const struct race *urace,
int id, const char *dname, unit * creator)
{
unit *u = (unit *)calloc(1, sizeof(unit));
assert(urace);
if (f) {
assert(f->alive);
u_setfaction(u, f);
if (f->locale) {
order *deford = default_order(f->locale);
if (deford) {
set_order(&u->thisorder, NULL);
addlist(&u->orders, deford);
}
}
}
u_seteffstealth(u, -1);
u_setrace(u, urace);
u->irace = NULL;
set_number(u, number);
/* die nummer der neuen einheit muss vor name_unit generiert werden,
* da der default name immer noch 'Nummer u->no' ist */
createunitid(u, id);
/* zuerst in die Region setzen, da zb Drachennamen den Regionsnamen
* enthalten */
if (r)
move_unit(u, r, NULL);
/* u->race muss bereits gesetzt sein, wird für default-hp gebraucht */
/* u->region auch */
u->hp = unit_max_hp(u) * number;
if (!dname) {
name_unit(u);
} else {
u->name = _strdup(dname);
}
if (creator) {
attrib *a;
/* erbt Kampfstatus */
setstatus(u, creator->status);
/* erbt Gebäude/Schiff */
if (creator->region == r) {
if (creator->building) {
u_set_building(u, creator->building);
}
if (creator->ship && fval(u_race(u), RCF_CANSAIL)) {
u_set_ship(u, creator->ship);
}
}
/* Tarnlimit wird vererbt */
if (fval(creator, UFL_STEALTH)) {
attrib *a = a_find(creator->attribs, &at_stealth);
if (a) {
int stealth = a->data.i;
a = a_add(&u->attribs, a_new(&at_stealth));
a->data.i = stealth;
}
}
/* Temps von parteigetarnten Einheiten sind wieder parteigetarnt */
if (fval(creator, UFL_ANON_FACTION)) {
fset(u, UFL_ANON_FACTION);
}
/* Daemonentarnung */
set_racename(&u->attribs, get_racename(creator->attribs));
if (fval(u_race(u), RCF_SHAPESHIFT) && fval(u_race(creator), RCF_SHAPESHIFT)) {
u->irace = creator->irace;
}
/* Gruppen */
if (creator->faction == f && fval(creator, UFL_GROUP)) {
a = a_find(creator->attribs, &at_group);
if (a) {
group *g = (group *) a->data.v;
set_group(u, g);
}
}
a = a_find(creator->attribs, &at_otherfaction);
if (a) {
a_add(&u->attribs, make_otherfaction(get_otherfaction(a)));
}
a = a_add(&u->attribs, a_new(&at_creator));
a->data.v = creator;
}
return u;
}
/*FUNCTION*-------------------------------------------------------------
*
* Function Name : getaddrinfo
* Returned Value : RTCS_OK or error code
* Comments :
* Get a list of IP addresses and port numbers for host hostname and service servname.
*
*END*-----------------------------------------------------------------*/
int32_t getaddrinfo
(
const char *hostname, /* host name or IP or NULL */
const char *servname, /* service name or port number */
const struct addrinfo *hints, /* set flags */
struct addrinfo **res /* [OUT]list of address structures */
)
{
const char *proto = NULL;
int family;
int socktype;
int flags;
int protocol;
struct addrinfo *ai;
struct addrinfo *ai_list;
uint16_t port;
uint16_t err;
uint16_t i;
int (*net_order[FOUND_MAX+1])(const char *, int, struct addrinfo **,int, int);
/*hostname and send name can not be NULL in same time*/
if (hostname == NULL && servname == NULL)
{
return (EAI_NONAME);
}
proto = NULL;
if (hints != NULL)
{
if ((hints->ai_flags & ~(ISC_AI_MASK)) != 0)
{
return (EAI_BADFLAGS);
}
if (hints->ai_addrlen || hints->ai_canonname || hints->ai_addr || hints->ai_next)
{
_task_errno = MQX_EINVAL;
return (EAI_SYSTEM);
}
family = hints->ai_family;
socktype = hints->ai_socktype;
protocol = hints->ai_protocol;
flags = hints->ai_flags;
/* looking for correct protocol depended on family and socket type */
switch (family) {
case AF_UNSPEC:
#if RTCSCFG_ENABLE_IP4
case AF_INET:
#endif
#if RTCSCFG_ENABLE_IP6
case AF_INET6:
#endif
if(hints->ai_socktype == 0)
{
break;
}else if(hints->ai_socktype == SOCK_STREAM) {
proto = "tcp";
}else if(hints->ai_socktype == SOCK_DGRAM) {
proto = "udp";
}else{
return (EAI_SOCKTYPE);
}
break;
default:
return (EAI_FAMILY);
}/* end of switch (family) */
} else {
protocol = 0;
family = 0;
socktype = 0;
flags = 0;
}/* end of (hints != NULL) */
if(proto !=NULL)
{
protocol = (strcmp(proto,"tcp")) ? 2 : 1;
}
/*
* Ok, only AF_INET and AF_INET6 left.
*/
/*************************************/
/*
* First, look up the service port if it was
* requested. If the socket type wasn't specified, then
* try and figure it out.
*/
if (servname != NULL) {
char *e;
port = strtol(servname, &e, 10);
if (*e == '\0') //*e - end pointer
{ /* Port number.*/
if (socktype == 0) //Not sure that it is necessary here
{
return (EAI_SOCKTYPE);
}
/* When port will be in network endian, do mqx_htons(&tmp,(uint16_t) port); */
}
else
{
/* We use only port number. We do not use a service name */
return (EAI_SERVICE);
}/*end of (*e == '\0')*/
}
else
{
port = 0;
} /* end (servname != NULL) */
/*
* Next, deal with just a service name, and no hostname.
* (we verified that one of them was non-null up above).
*/
ai_list = NULL;
if (hostname == NULL && (flags & AI_PASSIVE) != 0)
{
#if RTCSCFG_ENABLE_IP4
if (family == AF_INET || family == 0)
{
/* Allocate an addrinfo structure, and a sockaddr structure */
ai = ai_alloc(AF_INET, sizeof(struct sockaddr_in));
if (ai == NULL)
{
freeaddrinfo(ai_list);
return (EAI_MEMORY);
}
ai->ai_socktype = socktype;
ai->ai_protocol = protocol;
SIN(ai->ai_addr)->sin_port = port;
ai->ai_next = ai_list;
ai_list = ai;
}
#endif
#if RTCSCFG_ENABLE_IP6
if (family == AF_INET6 || family == 0)
{
ai = ai_alloc(AF_INET6, sizeof(struct sockaddr_in6));
if (ai == NULL)
{
freeaddrinfo(ai_list);
return (EAI_MEMORY);
}
ai->ai_socktype = socktype;
ai->ai_protocol = protocol;
SIN6(ai->ai_addr)->sin6_port = port;
ai->ai_next = ai_list;
ai_list = ai;
}
#endif
*res = ai;
return (0);
}/* end of (hostname == NULL && (flags & AI_PASSIVE) != 0) */
/*
* If the host is not NULL and the family isn't specified or AI_NUMERICHOST
* specified, check first to see if it is a numeric address.
* Though the gethostbyname2() routine
* will recognize numeric addresses, it will only recognize
* the format that it is being called for. Thus, a numeric
* AF_INET address will be treated by the AF_INET6 call as
* a domain name, and vice versa. Checking for both numerics
* here avoids that.
*/
if (hostname != NULL && (family == 0 || (flags & AI_NUMERICHOST) != 0))
{
char abuf[sizeof(struct in6_addr)];
char nbuf[NI_MAXHOST];
int addrsize, addroff;
char *p, *ep;
char ntmp[NI_MAXHOST];
uint32_t scopeid;
/*
* Scope identifier portion.
* scope id must be a decimal number
*/
ntmp[0] = '\0';
if (strchr(hostname, '%') != NULL)
{
strncpy(ntmp, hostname, sizeof(ntmp) - 1);
ntmp[sizeof(ntmp) - 1] = '\0';
/*Returns a pointer to the first occurrence of character '%'.*/
p = strchr(ntmp, '%');
ep = NULL;
/*
* Vendors may want to support non-numeric
* scopeid around here.
*/
if (p != NULL)
{
scopeid = (uint32_t)strtoul(p + 1, &ep, 10);
}
if (p != NULL && ep != NULL && ep[0] == '\0')
{
*p = '\0';
}else {
ntmp[0] = '\0';
scopeid = 0;
}
} else{
scopeid = 0;
} /* end of (strchr(hostname, '%') != NULL) */
/*
* Converts a human readable IP address into an address
* family appropriate 32bit or 128bit binary structure.
*/
if (inet_pton(AF_INET, hostname, (struct in_addr *)abuf,sizeof( *((struct in_addr *)abuf)))== RTCS_OK)
{
if (family == AF_INET6)
{
/*
* Convert to a V4 mapped address.
*/
struct in6_addr *a6 = (struct in6_addr *)abuf;
memcpy(&a6->s6_addr[12], &a6->s6_addr[0], 4);
memset(&a6->s6_addr[10], 0xff, 2);
memset(&a6->s6_addr[0], 0, 10);
goto inet6_addr;
}
addrsize = sizeof(struct in_addr);
addroff = (char *)(&SIN(0)->sin_addr) - (char *)0;
family = AF_INET;
goto common;
} else if (ntmp[0] != '\0' && inet_pton(AF_INET6, ntmp, abuf,sizeof(struct in6_addr)) == RTCS_OK)
{
if (family && family != AF_INET6)
{
return (EAI_NONAME);
}
addrsize = sizeof(struct in6_addr);
addroff = (char *)(&SIN6(0)->sin6_addr) - (char *)0;
family = AF_INET6;
goto common;
} else if (inet_pton(AF_INET6, hostname, abuf,sizeof(struct in6_addr)) == RTCS_OK)
{
if (family != 0 && family != AF_INET6)
{
return (EAI_NONAME);
}
inet6_addr:
addrsize = sizeof(struct in6_addr);
addroff = (char *)(&SIN6(0)->sin6_addr) - (char *)0;
family = AF_INET6;
common:
ai = ai_clone(ai_list, family);
if (ai == NULL)
{
return (EAI_MEMORY);
}
ai_list = ai;
ai->ai_socktype = socktype;
//ai->ai_protocol = protocol;
SIN(ai->ai_addr)->sin_port = port;
memcpy((char *)ai->ai_addr + addroff, abuf, addrsize);
if (flags & AI_CANONNAME)
{
if (ai->ai_family == AF_INET6)
{
SIN6(ai->ai_addr)->sin6_scope_id = scopeid;
}
if (getnameinfo( ai->ai_addr,
ai->ai_addrlen,
nbuf,
sizeof(nbuf),
NULL,
0,
NI_NUMERICHOST
) == 0)
{
ai->ai_canonname = strdup(nbuf);
if (ai->ai_canonname == NULL)
{
freeaddrinfo(ai_list);
return (EAI_MEMORY);
}
} else
{
/* XXX raise error? */
ai->ai_canonname = NULL;
}
}/*end of (flags & AI_CANONNAME)*/
goto done;
} else if ((flags & AI_NUMERICHOST) != 0)
{
return (EAI_NONAME);
}
}/* end of (inet_pton(AF_INET, hostname, (struct in_addr *)abuf)== 1) */
set_order(family, net_order);
for (i = 0; i < FOUND_MAX; i++) {
if (net_order[i] == NULL)
break;
err = (net_order[i])(hostname, flags, &ai_list,
socktype, port);
if (err != 0)
return (err);
}
if (ai_list == NULL)
return (EAI_NODATA);
done:
ai_list->ai_protocol = protocol;
ai_list->ai_flags = flags;
ai_list = ai_reverse(ai_list);
*res = ai_list;
return (0);
}
int
main(int argc, char *argv[])
{
char errbuf[_POSIX2_LINE_MAX];
extern char *optarg;
extern int optind;
double delay = 5;
char *viewstr = NULL;
gid_t gid;
int countmax = 0;
int maxlines = 0;
int ch;
ut = open(_PATH_UTMP, O_RDONLY);
if (ut < 0) {
warn("No utmp");
}
kd = kvm_openfiles(NULL, NULL, NULL, O_RDONLY, errbuf);
gid = getgid();
if (setresgid(gid, gid, gid) == -1)
err(1, "setresgid");
while ((ch = getopt(argc, argv, "BNabd:ins:w:")) != -1) {
switch (ch) {
case 'a':
maxlines = -1;
break;
case 'B':
averageonly = 1;
if (countmax < 2)
countmax = 2;
/* FALLTHROUGH */
case 'b':
rawmode = 1;
interactive = 0;
break;
case 'd':
countmax = atoi(optarg);
if (countmax < 0)
countmax = 0;
break;
case 'i':
interactive = 1;
break;
case 'N':
nflag = 0;
break;
case 'n':
/* this is a noop, -n is the default */
nflag = 1;
break;
case 's':
delay = atof(optarg);
if (delay <= 0)
delay = 5;
break;
case 'w':
rawwidth = atoi(optarg);
if (rawwidth < 1)
rawwidth = DEFAULT_WIDTH;
if (rawwidth >= MAX_LINE_BUF)
rawwidth = MAX_LINE_BUF - 1;
break;
default:
usage();
/* NOTREACHED */
}
}
if (kd == NULL)
warnx("kvm_openfiles: %s", errbuf);
argc -= optind;
argv += optind;
if (argc == 1) {
double del = atof(argv[0]);
if (del == 0)
viewstr = argv[0];
else
delay = del;
} else if (argc == 2) {
viewstr = argv[0];
delay = atof(argv[1]);
if (delay <= 0)
delay = 5;
}
udelay = (useconds_t)(delay * 1000000.0);
if (udelay < 1)
udelay = 1;
naptime = (double)udelay / 1000000.0;
gethostname(hostname, sizeof (hostname));
gethz();
initialize();
set_order(NULL);
if (viewstr && set_view(viewstr)) {
fprintf(stderr, "Unknown/ambiguous view name: %s\n", viewstr);
return 1;
}
if (check_termcap()) {
rawmode = 1;
interactive = 0;
}
setup_term(maxlines);
if (rawmode && countmax == 0)
countmax = 1;
gotsig_alarm = 1;
engine_loop(countmax);
return 0;
}