void
TAO_Notify_EventChannel::save_attrs(TAO_Notify::NVPList& attrs)
{
TAO_Notify_Object::save_attrs(attrs);
add_attr(attrs, this->admin_properties().max_global_queue_length());
add_attr(attrs, this->admin_properties().max_consumers());
add_attr(attrs, this->admin_properties().max_suppliers());
add_attr(attrs, this->admin_properties().reject_new_events());
}
static int new_add_to_ipset(const char *setname, const struct all_addr *ipaddr, int af, int remove)
{
struct nlmsghdr *nlh;
struct nfgenmsg *nfg;
struct nlattr *nested[2];
uint8_t proto;
int addrsz = INADDRSZ;
ssize_t rc;
#ifdef HAVE_IPV6
if (af == AF_INET6)
addrsz = IN6ADDRSZ;
#endif
if (strlen(setname) >= IPSET_MAXNAMELEN)
{
errno = ENAMETOOLONG;
return -1;
}
memset(buffer, 0, BUFF_SZ);
nlh = (struct nlmsghdr *)buffer;
nlh->nlmsg_len = NL_ALIGN(sizeof(struct nlmsghdr));
nlh->nlmsg_type = (remove ? IPSET_CMD_DEL : IPSET_CMD_ADD) | (NFNL_SUBSYS_IPSET << 8);
nlh->nlmsg_flags = NLM_F_REQUEST;
nfg = (struct nfgenmsg *)(buffer + nlh->nlmsg_len);
nlh->nlmsg_len += NL_ALIGN(sizeof(struct nfgenmsg));
nfg->nfgen_family = af;
nfg->version = NFNETLINK_V0;
nfg->res_id = htons(0);
proto = IPSET_PROTOCOL;
add_attr(nlh, IPSET_ATTR_PROTOCOL, sizeof(proto), &proto);
add_attr(nlh, IPSET_ATTR_SETNAME, strlen(setname) + 1, setname);
nested[0] = (struct nlattr *)(buffer + NL_ALIGN(nlh->nlmsg_len));
nlh->nlmsg_len += NL_ALIGN(sizeof(struct nlattr));
nested[0]->nla_type = NLA_F_NESTED | IPSET_ATTR_DATA;
nested[1] = (struct nlattr *)(buffer + NL_ALIGN(nlh->nlmsg_len));
nlh->nlmsg_len += NL_ALIGN(sizeof(struct nlattr));
nested[1]->nla_type = NLA_F_NESTED | IPSET_ATTR_IP;
add_attr(nlh,
(af == AF_INET ? IPSET_ATTR_IPADDR_IPV4 : IPSET_ATTR_IPADDR_IPV6) | NLA_F_NET_BYTEORDER,
addrsz, &ipaddr->addr);
nested[1]->nla_len = (void *)buffer + NL_ALIGN(nlh->nlmsg_len) - (void *)nested[1];
nested[0]->nla_len = (void *)buffer + NL_ALIGN(nlh->nlmsg_len) - (void *)nested[0];
while ((rc = sendto(ipset_sock, buffer, nlh->nlmsg_len, 0,
(struct sockaddr *)&snl, sizeof(snl))) == -1 && retry_send());
return rc;
}
xml_node& xml_node::add_attr(const char* name, size_t n)
{
char buf[32];
safe_snprintf(buf, sizeof(buf), "%lu", (unsigned long) n);
return add_attr(name, buf);
}
xml_node& xml_node::add_attr(const char* name, int n)
{
char buf[32];
safe_snprintf(buf, sizeof(buf), "%d", n);
return add_attr(name, buf);
}
void Metalink4Writer::write_piece_hash(const MetalinkFile& file)
{
if(file.get_piece_hashes().empty()) return;
if(file.get_piece_hash_type().empty()) return;
start(wxT("pieces"));
add_attr(wxT("length"),
wxString::Format(wxT("%lu"), file.get_piece_length()));
add_attr(wxT("type"), file.get_piece_hash_type());
close_start();
const std::vector<wxString>& hashes = file.get_piece_hashes();
for(std::vector<wxString>::const_iterator i = hashes.begin(),
eoi = hashes.end(); i != eoi; ++i) {
add_element(wxT("hash"), *i);
}
end(wxT("pieces"));
}
attrp_t make_attr_raw(ptr_t buf, int bufsize, int type, ptr_t data, int len)
{
uint32_t l;
if ((l = add_attr(buf, bufsize, type, data, len)) < 0)
return NULL;
return (attrp_t) buf;
}
void Metalink3Writer::write_metalink()
{
write_text(wxString(wxT("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n")), true);
start(wxT("metalink"));
add_attr(wxT("version"), wxT("3.0"));
add_attr(wxT("generator"), get_generator());
add_attr(wxT("xmlns"), wxT("http://www.metalinker.org/"));
close_start();
start(wxT("files"));
close_start();
const std::vector<MetalinkFile>& files = metalink_.get_files();
for(std::vector<MetalinkFile>::const_iterator i = files.begin(),
eoi = files.end(); i != eoi; ++i) {
write_file(*i);
}
end(wxT("files"));
end(wxT("metalink"));
}
void Metalink3Writer::write_piece_hashes(const MetalinkFile& file)
{
if(!has_piece_hashes(file)) return;
start(wxT("pieces"));
add_attr(wxT("length"),
wxString::Format(wxT("%lu"), file.get_piece_length()));
add_attr(wxT("type"), file.get_piece_hash_type());
close_start();
const std::vector<wxString>& hashes = file.get_piece_hashes();
long index = 0;
for(std::vector<wxString>::const_iterator i = hashes.begin(),
eoi = hashes.end(); i != eoi; ++i) {
start(wxT("hash"));
add_attr(wxT("piece"), wxString::Format(wxT("%ld"), index));
end(wxT("hash"), *i);
index++;
}
end(wxT("pieces"));
}
xml_node& xml_node::add_attr(const char* name, acl_int64 n)
{
char buf[32];
#ifdef WIN32
safe_snprintf(buf, sizeof(buf), "%I64d", n);
#else
safe_snprintf(buf, sizeof(buf), "%lld", n);
#endif
return add_attr(name, buf);
}
void Metalink4Writer::write_hashes(const MetalinkFile& file)
{
const std::vector<MetalinkHash>& hashes = file.get_file_hashes();
for(std::vector<MetalinkHash>::const_iterator i = hashes.begin(),
eoi = hashes.end(); i != eoi; ++i) {
start(wxT("hash"));
add_attr(wxT("type"), (*i).type);
end(wxT("hash"), (*i).value);
}
}
void Metalink4Writer::write_source(const MetalinkSource& source)
{
if(source.is_torrent()) {
start(wxT("metaurl"));
add_attr(wxT("mediatype"), wxT("torrent"));
if(!source.get_prioritystr().empty()) {
add_attr(wxT("priority"), source.get_prioritystr());
}
end(wxT("metaurl"), source.get_uri());
} else {
start(wxT("url"));
if(!source.get_prioritystr().empty()) {
add_attr(wxT("priority"), source.get_prioritystr());
}
if(!source.get_location().empty()) {
add_attr(wxT("location"), source.get_location());
}
end(wxT("url"), source.get_uri());
}
}
attrp_t nl2m_addattr(znl2msghdr *hdr, int maxlen, int type, ptr_t data, int len)
{
uint32_t l;
ptr_t tail = (ptr_t)hdr + hdr->znl2msg_len;
maxlen -= hdr->znl2msg_len;
if ((l = add_attr(tail, maxlen, type, data, len)) < 0)
return NULL;
hdr->znl2msg_len += l;
return (attrp_t) tail;
}
static void add_attribute( char *attribute, int type, P_Void_ptr value )
/* This method adds an attribute-value pair to the gob's attribute list.
* Note that it does not make a new copy of the attribute or value info.
*/
{
P_Gob *self= (P_Gob *)po_this;
METHOD_IN
ger_debug("gob_mthd: add_attribute");
self->attr= add_attr( self->attr, attribute, type, value );
METHOD_OUT
}
void Metalink4Writer::write_metalink()
{
write_text(wxT("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"));
start(wxT("metalink"));
add_attr(wxT("xmlns"), wxT("urn:ietf:params:xml:ns:metalink"));
close_start();
add_element(wxT("generator"), get_generator());
const std::vector<MetalinkFile>& files = metalink_.get_files();
for(std::vector<MetalinkFile>::const_iterator i = files.begin(),
eoi = files.end(); i != eoi; ++i) {
write_file(*i);
}
end(wxT("metalink"));
}
void Metalink4Writer::write_file(const MetalinkFile& file)
{
start(wxT("file"));
add_attr(wxT("name"), file.get_filename());
close_start();
add_element(wxT("identity"), file.get_identity());
add_element(wxT("description"), file.get_description());
add_element(wxT("version"), file.get_version());
add_element(wxT("size"), file.get_size());
write_hashes(file);
write_piece_hash(file);
const std::vector<MetalinkSource>& sources = file.get_sources();
for(std::vector<MetalinkSource>::const_iterator i = sources.begin(),
eoi = sources.end(); i != eoi; ++i) {
write_source(*i);
}
end(wxT("file"));
}
/*
* Gathers basic MPI information; sets up reader CM.
*/
int
adios_read_flexpath_init_method (MPI_Comm comm, PairStruct* params)
{
setenv("CMSelfFormats", "1", 1);
fp_read_data = malloc(sizeof(flexpath_read_data));
if(!fp_read_data) {
adios_error(err_no_memory, "Cannot allocate memory for flexpath.");
return -1;
}
memset(fp_read_data, 0, sizeof(flexpath_read_data));
fp_read_data->CM_TRANSPORT = attr_atom_from_string("CM_TRANSPORT");
attr_list listen_list = NULL;
char * transport = NULL;
transport = getenv("CMTransport");
// setup MPI stuffs
fp_read_data->fp_comm = comm;
MPI_Comm_size(fp_read_data->fp_comm, &(fp_read_data->fp_comm_size));
MPI_Comm_rank(fp_read_data->fp_comm, &(fp_read_data->fp_comm_rank));
fp_read_data->fp_cm = CManager_create();
if(transport == NULL){
if(CMlisten(fp_read_data->fp_cm) == 0) {
fprintf(stderr, "Flexpath ERROR: reader %d unable to initialize connection manager.\n",
fp_read_data->fp_comm_rank);
}
}else{
listen_list = create_attr_list();
add_attr(listen_list, fp_read_data->CM_TRANSPORT, Attr_String,
(attr_value)strdup(transport));
CMlisten_specific(fp_read_data->fp_cm, listen_list);
}
int forked = CMfork_comm_thread(fp_read_data->fp_cm);
if(!forked) {
fprintf(stderr, "reader %d failed to fork comm_thread.\n", fp_read_data->fp_comm_rank);
/*log_debug( "forked\n");*/
}
return 0;
}
/* This function is used by gtk_text_cell_accessible_get_offset_at_point()
* and gtk_text_cell_accessible_get_character_extents(). There is no
* cached PangoLayout so we must create a temporary one using this function.
*/
static PangoLayout *
create_pango_layout (GtkTextCellAccessible *text)
{
GdkRGBA *foreground_rgba;
PangoAttrList *attr_list, *attributes;
PangoLayout *layout;
PangoUnderline uline, underline;
PangoFontMask mask;
PangoFontDescription *font_desc;
gboolean foreground_set, strikethrough_set, strikethrough;
gboolean scale_set, underline_set, rise_set;
gchar *renderer_text;
gdouble scale;
gint rise;
GtkRendererCellAccessible *gail_renderer;
GtkCellRendererText *gtk_renderer;
gail_renderer = GTK_RENDERER_CELL_ACCESSIBLE (text);
gtk_renderer = GTK_CELL_RENDERER_TEXT (gail_renderer->renderer);
g_object_get (gtk_renderer,
"text", &renderer_text,
"attributes", &attributes,
"foreground-set", &foreground_set,
"foreground-rgba", &foreground_rgba,
"strikethrough-set", &strikethrough_set,
"strikethrough", &strikethrough,
"font-desc", &font_desc,
"scale-set", &scale_set,
"scale", &scale,
"underline-set", &underline_set,
"underline", &underline,
"rise-set", &rise_set,
"rise", &rise,
NULL);
layout = gtk_widget_create_pango_layout (get_widget (text), renderer_text);
if (attributes)
attr_list = pango_attr_list_copy (attributes);
else
attr_list = pango_attr_list_new ();
if (foreground_set)
{
add_attr (attr_list, pango_attr_foreground_new (foreground_rgba->red * 65535,
foreground_rgba->green * 65535,
foreground_rgba->blue * 65535));
}
if (strikethrough_set)
add_attr (attr_list,
pango_attr_strikethrough_new (strikethrough));
mask = pango_font_description_get_set_fields (font_desc);
if (mask & PANGO_FONT_MASK_FAMILY)
add_attr (attr_list,
pango_attr_family_new (pango_font_description_get_family (font_desc)));
if (mask & PANGO_FONT_MASK_STYLE)
add_attr (attr_list, pango_attr_style_new (pango_font_description_get_style (font_desc)));
if (mask & PANGO_FONT_MASK_VARIANT)
add_attr (attr_list, pango_attr_variant_new (pango_font_description_get_variant (font_desc)));
if (mask & PANGO_FONT_MASK_WEIGHT)
add_attr (attr_list, pango_attr_weight_new (pango_font_description_get_weight (font_desc)));
if (mask & PANGO_FONT_MASK_STRETCH)
add_attr (attr_list, pango_attr_stretch_new (pango_font_description_get_stretch (font_desc)));
if (mask & PANGO_FONT_MASK_SIZE)
add_attr (attr_list, pango_attr_size_new (pango_font_description_get_size (font_desc)));
if (scale_set && scale != 1.0)
add_attr (attr_list, pango_attr_scale_new (scale));
if (underline_set)
uline = underline;
else
uline = PANGO_UNDERLINE_NONE;
if (uline != PANGO_UNDERLINE_NONE)
add_attr (attr_list,
pango_attr_underline_new (underline));
if (rise_set)
add_attr (attr_list, pango_attr_rise_new (rise));
pango_layout_set_attributes (layout, attr_list);
pango_layout_set_width (layout, -1);
pango_attr_list_unref (attr_list);
pango_font_description_free (font_desc);
pango_attr_list_unref (attributes);
g_free (renderer_text);
gdk_rgba_free (foreground_rgba);
return layout;
}
/*
* make_trans -- Construct a single transform payload
*
* Inputs:
*
* length (output) length of entire transform payload.
* next Next Payload Type (3 = More transforms; 0=No more transforms)
* number Transform number
* cipher The encryption algorithm
* keylen Key length for variable length keys (0=fixed key length)
* hash Hash algorithm
* auth Authentication method
* group DH Group number
* lifetime Lifetime in seconds (0=no lifetime)
* lifesize Life in kilobytes (0=no life)
*
* Returns:
*
* Pointer to transform payload.
*
* This constructs a single transform payload.
* Most of the values are defined in RFC 2409 Appendix A.
*/
unsigned char*make_trans(size_t *length, unsigned next, unsigned number,
unsigned cipher,
unsigned keylen, unsigned hash, unsigned auth,
unsigned group,
unsigned lifetime, unsigned lifesize, int gss_id_flag,
unsigned char *gss_data, size_t gss_data_len)
{
struct isakmp_transform* hdr; /* Transform header */
unsigned char *payload;
unsigned char *attr;
unsigned char *cp;
size_t attr_len; /* Attribute Length */
size_t len; /* Payload Length */
/* Allocate and initialise the transform header */
hdr = Malloc(sizeof(struct isakmp_transform));
memset(hdr, '\0', sizeof(struct isakmp_transform));
hdr->isat_np = next; /* Next payload type */
hdr->isat_transnum = number; /* Transform Number */
hdr->isat_transid = KEY_IKE;
/* Allocate and initialise the mandatory attributes */
add_attr(0, NULL, 'B', OAKLEY_ENCRYPTION_ALGORITHM, 0, cipher, NULL);
add_attr(0, NULL, 'B', OAKLEY_HASH_ALGORITHM, 0, hash, NULL);
add_attr(0, NULL, 'B', OAKLEY_AUTHENTICATION_METHOD, 0, auth, NULL);
add_attr(0, NULL, 'B', OAKLEY_GROUP_DESCRIPTION, 0, group, NULL);
/* Allocate and initialise the optional attributes */
if (keylen)
add_attr(0, NULL, 'B', OAKLEY_KEY_LENGTH, 0, keylen, NULL);
if (lifetime) {
uint32_t lifetime_n = htonl(lifetime);
add_attr(0, NULL, 'B', OAKLEY_LIFE_TYPE, 0,
SA_LIFE_TYPE_SECONDS, NULL);
add_attr(0, NULL, 'V', OAKLEY_LIFE_DURATION, 4, 0,
&lifetime_n);
}
if (lifesize) {
uint32_t lifesize_n = htonl(lifesize);
add_attr(0, NULL, 'B', OAKLEY_LIFE_TYPE, 0,
SA_LIFE_TYPE_KBYTES, NULL);
add_attr(0, NULL, 'V', OAKLEY_LIFE_DURATION, 4, 0,
&lifesize_n);
}
if (gss_id_flag)
add_attr(0, NULL, 'V', OAKLEY_GSS_ID, gss_data_len, 0,
gss_data);
/* Finalise attributes and fill in length value */
attr = add_attr(1, &attr_len, '\0', 0, 0, 0, NULL);
len = attr_len + sizeof(struct isakmp_transform);
hdr->isat_length = htons(len); /* Transform length */
*length = len;
/* Allocate memory for payload and copy structures to payload */
payload = Malloc(len);
cp = payload;
memcpy(cp, hdr, sizeof(struct isakmp_transform));
free(hdr);
cp += sizeof(struct isakmp_transform);
memcpy(cp, attr, attr_len);
free(attr);
return payload;
}
/* Build link connections */
v_iterate(links, iter) {
link = vl_iter_pval(iter);
if (vh_iget(link, "NOLINK"))
continue;
if (vh_iget(link, "NOPATH"))
continue;
oneway = vh_iget(link, "ONEWAY");
len = vh_iget(link, "LEN");
if (len)
uselen++;
from = vh_pget(link, "FROM");
to = vh_pget(link, "TO");
/* From -> to */
reach = vh_create();
cmd = NULL;
goflag = vh_iget(link, "GO");
dir = vh_iget(link, "TO_DIR");
if ((cmdto = vh_pget(link, "TO_CMD")) != NULL) {
vh_pstore(reach, "CMD", cmdto);
} else {
if (goflag)
cmd = dirinfo[goflag].sname;
if (cmd == NULL)
cmd = dirinfo[dir].sname;
add_attr(reach, "CMD", cmd);
}
vh_pstore(reach, "FROM", from);
vh_pstore(reach, "TO", to);
vh_pstore(reach, "NEED", vh_pget(link, "NEED"));
vh_pstore(reach, "BEFORE", vh_pget(link, "BEFORE"));
vh_pstore(reach, "AFTER", vh_pget(link, "AFTER"));
vh_istore(reach, "LEN", V_MAX(len, 1));
vh_pstore(reach, "LEAVE", vh_pget(link, "LEAVE"));
vh_istore(reach, "LEAVEALL", vh_iget(link, "LEAVEALL"));
link_rooms(from, to, reach);
if (TASK_VERBOSE) {
indent(1);
list = vh_pget(reach, "CMD");
printf("link '%s' to '%s' (%s)",
vh_sgetref(from, "DESC"),
vh_sgetref(to, "DESC"),
vl_join(list, ". "));
if (len > 1)
printf(" (dist %d)", len);
printf("\n");
}
/* To -> from if not one-way */
if (!oneway) {
reach = vh_create();
cmd = NULL;
goflag = dirinfo[goflag].odir;
dir = vh_iget(link, "FROM_DIR");
if ((cmdfrom = vh_pget(link, "FROM_CMD")) != NULL) {
vh_pstore(reach, "CMD", cmdfrom);
} else if (cmdto != NULL) {
vh_pstore(reach, "CMD", cmdto);
} else {
if (goflag)
cmd = dirinfo[goflag].sname;
if (cmd == NULL)
cmd = dirinfo[dir].sname;
add_attr(reach, "CMD", cmd);
}
vh_pstore(reach, "FROM", to);
vh_pstore(reach, "TO", from);
vh_pstore(reach, "NEED", vh_pget(link, "NEED"));
vh_pstore(reach, "BEFORE", vh_pget(link, "BEFORE"));
vh_pstore(reach, "AFTER", vh_pget(link, "AFTER"));
vh_pstore(reach, "LEAVE", vh_pget(link, "LEAVE"));
vh_istore(reach, "LEAVEALL", vh_iget(link, "LEAVEALL"));
vh_istore(reach, "LEN", V_MAX(len, 1));
link_rooms(to, from, reach);
if (TASK_VERBOSE) {
indent(1);
list = vh_pget(reach, "CMD");
printf("link '%s' to '%s' (%s)",
vh_sgetref(to, "DESC"),
vh_sgetref(from, "DESC"),
vl_join(list, ". "));
if (len > 1)
printf(" (dist %d)", len);
printf("\n");
}
}
}
/*
adds different types of attributes to an object.
returns the number of attributes added to the objects.
*/
int add_attrs(hid_t oid, int idx)
{
char name[32];
int i0, i1, i2, j, nattrs=0;
hid_t aid, tid, tid1, sid;
hvl_t i_vlen[4];
hobj_ref_t ref;
zipcode_t cmp_data[4];
unsigned int i = 0xffffffff;
long long l = -2147483647;
float f = 123456789.987654321;
double d = 987654321.123456789;
char *s[7] = {"Parting", "is such", "sweeter", "sorrow."};
float f_array[4] = {1.0, 2.22, 3.333, 4.444};
char *s_vlen[4] = {"Parting", "is such", "sweet", "sorrow."};
hsize_t dims1[1]={1}, dims2[1]={4}, dims3[2]={3,5};
int int3d[4][3][5];
size_t offset = 0;
for (i0=0; i0<4; i0++) {
i_vlen[i0].len = (i0+1);
i_vlen[i0].p = (int *)calloc(i_vlen[i0].len, sizeof(int));
for (j=0; j<i_vlen[i0].len; j++)
((int *)i_vlen[i0].p)[j] = i0*100+j;
for (i1=0; i1<3; i1++) {
for (i2=0; i2<5; i2++)
int3d[i0][i1][i2] = i0*i1-i1*i2+i0*i2;
}
}
cmp_data[0].zipcode = 01001;
cmp_data[0].city = "Agawam, Massachusetts";
cmp_data[1].zipcode = 99950;
cmp_data[1].city = "Ketchikan, Alaska";
cmp_data[2].zipcode = 00501;
cmp_data[2].city = "Holtsville, New York";
cmp_data[3].zipcode = 61820;
cmp_data[3].city = "Champaign, Illinois";
/* 1 scalar point */
sid = H5Screate (H5S_SCALAR);
sprintf(name, "%05d scalar int", idx);
nattrs += add_attr(oid, name, H5T_NATIVE_UINT, sid, &i);
sprintf(name, "%05d scalar ulong", idx);
nattrs += add_attr(oid, name, H5T_NATIVE_INT64, sid, &l);
sprintf(name, "%05d scalar str", idx);
tid = H5Tcopy (H5T_C_S1);
H5Tset_size (tid, H5T_VARIABLE);
nattrs += add_attr(oid, name, tid, sid, &s[2]);
H5Tclose(tid);
H5Sclose(sid);
/* 4 single point */
sid = H5Screate_simple (1, dims1, NULL);
H5Rcreate(&ref, oid, ".", H5R_OBJECT, -1);
sprintf(name, "%05d single float", idx);
nattrs += add_attr(oid, name, H5T_NATIVE_FLOAT, sid, &f);
sprintf(name, "%05d single double", idx);
nattrs += add_attr(oid, name, H5T_NATIVE_DOUBLE, sid, &d);
sprintf(name, "%05d single obj_ref", idx);
nattrs += add_attr(oid, name, H5T_STD_REF_OBJ, sid, &ref);
H5Sclose(sid);
/* 7 fixed length 1D array */
sid = H5Screate_simple (1, dims1, NULL);
tid = H5Tarray_create (H5T_NATIVE_FLOAT, 1, dims2);
sprintf(name, "%05d array float", idx);
nattrs += add_attr(oid, name, tid, sid, &f_array[0]);
H5Tclose(tid);
tid = H5Tcopy (H5T_C_S1);
H5Tset_size (tid, strlen(s[0])+1);
tid1 = H5Tarray_create (tid, 1, dims2);
sprintf(name, "%05d array str", idx);
nattrs += add_attr(oid, name, tid1, sid, s);
H5Tclose(tid1);
H5Tclose(tid);
H5Sclose(sid);
/* 9 fixed length 2D int arrays */
sid = H5Screate_simple (1, dims2, NULL);
tid = H5Tarray_create (H5T_NATIVE_INT, 2, dims3);
sprintf(name, "%05d array int 2D", idx);
nattrs += add_attr(oid, name, tid, sid, int3d[0][0]);
H5Tclose(tid);
H5Sclose(sid);
/* 10 variable length arrays */
sid = H5Screate_simple (1, dims2, NULL);
tid = H5Tcopy (H5T_C_S1);
H5Tset_size (tid, H5T_VARIABLE);
sprintf(name, "%05d vlen strings", idx);
nattrs += add_attr(oid, name, tid, sid, s_vlen);
H5Tclose(tid);
tid = H5Tvlen_create (H5T_NATIVE_INT);;
sprintf(name, "%05d vlen int array", idx);
nattrs += add_attr(oid, name, tid, sid, i_vlen);
H5Tclose(tid);
H5Sclose(sid);
/* 12 compound data */
sid = H5Screate_simple (1, dims2, NULL);
tid = H5Tcreate (H5T_COMPOUND, sizeof (zipcode_t));
tid1 = H5Tcopy (H5T_C_S1);
H5Tset_size (tid1, H5T_VARIABLE);
H5Tinsert (tid, "zip code", 0, H5T_NATIVE_INT); offset += sizeof(H5T_NATIVE_INT);
H5Tinsert (tid, "City", offset, tid1); offset += sizeof(char *);
sprintf(name, "%05d compound data", idx);
nattrs += add_attr(oid, name, tid, sid, cmp_data);
H5Tclose(tid1);
H5Tclose(tid);
H5Sclose(sid);
for (i0=0; i0<4; i0++)
free(i_vlen[i0].p);
return nattrs;
}
static void do_args(int argc, char *argv[])
{
char *name = "", *value = "", *filter = "";
char *pool = NULL, *identity = NULL, *addresses = NULL;
value_type_t value_type = VALUE_NONE;
int timeout = 0;
bool utc = FALSE, hexout = FALSE;
enum {
OP_UNDEF,
OP_USAGE,
OP_STATUS,
OP_STATUS_ATTR,
OP_ADD,
OP_ADD_ATTR,
OP_DEL,
OP_DEL_ATTR,
OP_SHOW_ATTR,
OP_RESIZE,
OP_LEASES,
OP_PURGE,
OP_BATCH
} operation = OP_UNDEF;
/* reinit getopt state */
optind = 0;
while (TRUE)
{
int c;
struct option long_opts[] = {
{ "help", no_argument, NULL, 'h' },
{ "utc", no_argument, NULL, 'u' },
{ "status", no_argument, NULL, 'w' },
{ "add", required_argument, NULL, 'a' },
{ "replace", required_argument, NULL, 'c' },
{ "del", required_argument, NULL, 'd' },
{ "resize", required_argument, NULL, 'r' },
{ "leases", no_argument, NULL, 'l' },
{ "purge", required_argument, NULL, 'p' },
{ "statusattr", no_argument, NULL, '1' },
{ "addattr", required_argument, NULL, '2' },
{ "delattr", required_argument, NULL, '3' },
{ "showattr", no_argument, NULL, '4' },
{ "batch", required_argument, NULL, 'b' },
{ "start", required_argument, NULL, 's' },
{ "end", required_argument, NULL, 'e' },
{ "addresses", required_argument, NULL, 'y' },
{ "timeout", required_argument, NULL, 't' },
{ "filter", required_argument, NULL, 'f' },
{ "addr", required_argument, NULL, 'v' },
{ "mask", required_argument, NULL, 'v' },
{ "server", required_argument, NULL, 'v' },
{ "subnet", required_argument, NULL, 'n' },
{ "string", required_argument, NULL, 'g' },
{ "hex", required_argument, NULL, 'x' },
{ "hexout", no_argument, NULL, '5' },
{ "pool", required_argument, NULL, '6' },
{ "identity", required_argument, NULL, '7' },
{ 0,0,0,0 }
};
c = getopt_long(argc, argv, "", long_opts, NULL);
switch (c)
{
case EOF:
break;
case 'h':
operation = OP_USAGE;
break;
case 'w':
operation = OP_STATUS;
break;
case '1':
operation = OP_STATUS_ATTR;
break;
case 'u':
utc = TRUE;
continue;
case 'c':
replace_pool = TRUE;
/* fallthrough */
case 'a':
name = optarg;
operation = is_attribute(name) ? OP_ADD_ATTR : OP_ADD;
if (replace_pool && operation == OP_ADD_ATTR)
{
fprintf(stderr, "invalid pool name: "
"reserved for '%s' attribute.\n", optarg);
usage();
exit(EXIT_FAILURE);
}
continue;
case '2':
name = optarg;
operation = OP_ADD_ATTR;
continue;
case 'd':
name = optarg;
operation = is_attribute(name) ? OP_DEL_ATTR : OP_DEL;
continue;
case '3':
name = optarg;
operation = OP_DEL_ATTR;
continue;
case '4':
operation = OP_SHOW_ATTR;
continue;
case 'r':
name = optarg;
operation = OP_RESIZE;
continue;
case 'l':
operation = OP_LEASES;
continue;
case 'p':
name = optarg;
operation = OP_PURGE;
continue;
case 'b':
name = optarg;
if (operation == OP_BATCH)
{
fprintf(stderr, "--batch commands can not be nested\n");
exit(EXIT_FAILURE);
}
operation = OP_BATCH;
continue;
case 's':
DESTROY_IF(start);
start = host_create_from_string(optarg, 0);
if (start == NULL)
{
fprintf(stderr, "invalid start address: '%s'.\n", optarg);
usage();
exit(EXIT_FAILURE);
}
continue;
case 'e':
DESTROY_IF(end);
end = host_create_from_string(optarg, 0);
if (end == NULL)
{
fprintf(stderr, "invalid end address: '%s'.\n", optarg);
usage();
exit(EXIT_FAILURE);
}
continue;
case 't':
timeout = atoi(optarg);
if (timeout == 0 && strcmp(optarg, "0") != 0)
{
fprintf(stderr, "invalid timeout '%s'.\n", optarg);
usage();
exit(EXIT_FAILURE);
}
continue;
case 'f':
filter = optarg;
continue;
case 'y':
addresses = optarg;
continue;
case 'g':
value_type = VALUE_STRING;
value = optarg;
continue;
case 'n':
value_type = VALUE_SUBNET;
value = optarg;
continue;
case 'v':
value_type = VALUE_ADDR;
value = optarg;
continue;
case 'x':
value_type = VALUE_HEX;
value = optarg;
continue;
case '5':
hexout = TRUE;
continue;
case '6':
pool = optarg;
continue;
case '7':
identity = optarg;
continue;
default:
usage();
exit(EXIT_FAILURE);
break;
}
break;
}
switch (operation)
{
case OP_USAGE:
usage();
break;
case OP_STATUS:
status();
break;
case OP_STATUS_ATTR:
status_attr(hexout);
break;
case OP_ADD:
if (addresses != NULL)
{
add_addresses(name, addresses, timeout);
}
else if (start != NULL && end != NULL)
{
add(name, start, end, timeout);
}
else
{
fprintf(stderr, "missing arguments.\n");
usage();
exit(EXIT_FAILURE);
}
break;
case OP_ADD_ATTR:
if (value_type == VALUE_NONE)
{
fprintf(stderr, "missing arguments.\n");
usage();
exit(EXIT_FAILURE);
}
if (identity && !pool)
{
fprintf(stderr, "--identity option can't be used without --pool.\n");
usage();
exit(EXIT_FAILURE);
}
add_attr(name, pool, identity, value, value_type);
break;
case OP_DEL:
del(name);
break;
case OP_DEL_ATTR:
if (identity && !pool)
{
fprintf(stderr, "--identity option can't be used without --pool.\n");
usage();
exit(EXIT_FAILURE);
}
del_attr(name, pool, identity, value, value_type);
break;
case OP_SHOW_ATTR:
show_attr();
break;
case OP_RESIZE:
if (end == NULL)
{
fprintf(stderr, "missing arguments.\n");
usage();
exit(EXIT_FAILURE);
}
resize(name, end);
break;
case OP_LEASES:
leases(filter, utc);
break;
case OP_PURGE:
purge(name);
break;
case OP_BATCH:
if (name == NULL)
{
fprintf(stderr, "missing arguments.\n");
usage();
exit(EXIT_FAILURE);
}
batch(argv[0], name);
break;
default:
usage();
exit(EXIT_FAILURE);
}
}
/*
* This function is used by gail_text_cell_get_offset_at_point()
* and gail_text_cell_get_character_extents(). There is no
* cached PangoLayout for gailtextcell so we must create a temporary
* one using this function.
*/
static PangoLayout*
create_pango_layout(GtkCellRendererText *gtk_renderer,
GtkWidget *widget)
{
PangoAttrList *attr_list;
PangoLayout *layout;
PangoUnderline uline;
PangoFontMask mask;
layout = gtk_widget_create_pango_layout (widget, gtk_renderer->text);
if (gtk_renderer->extra_attrs)
attr_list = pango_attr_list_copy (gtk_renderer->extra_attrs);
else
attr_list = pango_attr_list_new ();
if (gtk_renderer->foreground_set)
{
PangoColor color;
color = gtk_renderer->foreground;
add_attr (attr_list, pango_attr_foreground_new (color.red,
color.green, color.blue));
}
if (gtk_renderer->strikethrough_set)
add_attr (attr_list,
pango_attr_strikethrough_new (gtk_renderer->strikethrough));
mask = pango_font_description_get_set_fields (gtk_renderer->font);
if (mask & PANGO_FONT_MASK_FAMILY)
add_attr (attr_list,
pango_attr_family_new (pango_font_description_get_family (gtk_renderer->font)));
if (mask & PANGO_FONT_MASK_STYLE)
add_attr (attr_list, pango_attr_style_new (pango_font_description_get_style (gtk_renderer->font)));
if (mask & PANGO_FONT_MASK_VARIANT)
add_attr (attr_list, pango_attr_variant_new (pango_font_description_get_variant (gtk_renderer->font)));
if (mask & PANGO_FONT_MASK_WEIGHT)
add_attr (attr_list, pango_attr_weight_new (pango_font_description_get_weight (gtk_renderer->font)));
if (mask & PANGO_FONT_MASK_STRETCH)
add_attr (attr_list, pango_attr_stretch_new (pango_font_description_get_stretch (gtk_renderer->font)));
if (mask & PANGO_FONT_MASK_SIZE)
add_attr (attr_list, pango_attr_size_new (pango_font_description_get_size (gtk_renderer->font)));
if (gtk_renderer->scale_set &&
gtk_renderer->font_scale != 1.0)
add_attr (attr_list, pango_attr_scale_new (gtk_renderer->font_scale));
if (gtk_renderer->underline_set)
uline = gtk_renderer->underline_style;
else
uline = PANGO_UNDERLINE_NONE;
if (uline != PANGO_UNDERLINE_NONE)
add_attr (attr_list,
pango_attr_underline_new (gtk_renderer->underline_style));
if (gtk_renderer->rise_set)
add_attr (attr_list, pango_attr_rise_new (gtk_renderer->rise));
pango_layout_set_attributes (layout, attr_list);
pango_layout_set_width (layout, -1);
pango_attr_list_unref (attr_list);
return layout;
}
