std::string BugzillaLink::get_bug_url() const { std::string url; AttributeMap::const_iterator iter = get_attributes().find(URI_ATTRIBUTE_NAME); if(iter != get_attributes().end()) { url = iter->second; } return url; }
ErrorCode ReadNC::read_header() { dbgOut.tprint(1, "Reading header...\n"); // Get the global attributes int numgatts; int success; success = NCFUNC(inq_natts )(fileId, &numgatts); if (success) MB_SET_ERR(MB_FAILURE, "Couldn't get number of global attributes"); // Read attributes into globalAtts ErrorCode result = get_attributes(NC_GLOBAL, numgatts, globalAtts);MB_CHK_SET_ERR(result, "Trouble getting global attributes"); dbgOut.tprintf(1, "Read %u attributes\n", (unsigned int) globalAtts.size()); // Read in dimensions into dimNames and dimLens result = get_dimensions(fileId, dimNames, dimLens);MB_CHK_SET_ERR(result, "Trouble getting dimensions"); dbgOut.tprintf(1, "Read %u dimensions\n", (unsigned int) dimNames.size()); // Read in variables into varInfo result = get_variables();MB_CHK_SET_ERR(result, "Trouble getting variables"); dbgOut.tprintf(1, "Read %u variables\n", (unsigned int) varInfo.size()); return MB_SUCCESS; }
// Default constructor GenericLevelObj::GenericLevelObj(std::string obj_name) : sprite(), surface(), desc(), pos(Vector3f(0,0,0)), orig_pos(), section_name(obj_name), object_type(), ground_type(), speed(0), parallax(0.0), repeat(0), owner_id(0), release_rate(0), direction(), scroll_x(0), scroll_y(0), stretch_x(false), stretch_y(false), keep_aspect(false), para_x(0), para_y(0), color(0,0,0,0), origin(), small_stars(), middle_stars(), large_stars(), id(), target_id(), height(15), attribs(get_attributes(obj_name)) { if (attribs & HAS_SPRITE_FAKE) load_generic_surface(); }
void CL_DomElement::remove_attribute(const CL_DomString &name) { if (impl) { CL_DomNamedNodeMap attributes = get_attributes(); attributes.remove_named_item(name); } }
void Shader::create(const std::string& name, Owner location){ init(); load_shaders(name,location); compile_shaders(); link_shaders(); get_attributes(); get_uniforms(); }
void CL_DomElement::remove_attribute_ns( const CL_DomString &namespace_uri, const CL_DomString &local_name) { if (impl) { CL_DomNamedNodeMap attributes = get_attributes(); attributes.remove_named_item_ns(namespace_uri, local_name); } }
CL_DomAttr CL_DomElement::get_attribute_node(const CL_DomString &name) const { if (impl) { CL_DomNamedNodeMap attributes = get_attributes(); CL_DomAttr attribute = attributes.get_named_item(name).to_attr(); return attribute; } return CL_DomAttr(); }
struct Node* readfile(char *filename,int *Sample_Num,int *Atttr_Num,char *Atttr_Seq){ FILE *fp; int finished = 0; int i = 0, j,k;//m,n; char string[2000]; char*ptr; struct Node *Sample; Sample=(struct Node *)malloc(sizeof(struct Node)*MAX_SAMPLE); get_attributes(filename,Atttr_Num,Atttr_Seq); fp=fopen(filename,"r"); if(fp==NULL) { printf("\nError in opening "); return NULL; } //n = 0; //m = 0; k = 0; while(finished != 1){ ptr= string; finished = get_line(ptr,fp); //printf("line read:%s\n",ptr); if(finished == 2){ //skip this line continue; } if(string[0] != '%' && string[0] != '@' && string[0] != '\0'){ k = 0; for(j = 0; j < *Atttr_Num; j++){ if(j == 0){ if(Atttr_Seq[k] == 'r'){ sscanf(ptr,"%f",&Sample[i].NumericAttributes[j]); } k++; }else{ if(Atttr_Seq[k] == 'r'){ sscanf(ptr,",%f",&Sample[i].NumericAttributes[j]); } k++; } do{ptr++;} while(*ptr != ','); } //printf("row%d\n",i); i++; (*Sample_Num)++; } } fclose(fp); return Sample; }
bool CL_DomElement::has_attribute_ns( const CL_DomString &namespace_uri, const CL_DomString &local_name) const { if (impl) { CL_DomNode attribute = get_attributes().get_named_item_ns(namespace_uri, local_name); return attribute.is_attr(); } return false; }
// print out the items stored in the two tables void table_dump () { printf("Identifiers:\n"); int ident_scp = 0; for (auto v: idents) { printf("%d\n", ident_scp); for (auto i = v->cbegin(); i != v->cend(); i++) { printf("\t %s %s\n", i->first->c_str(), get_attributes(i->second->attributes)); } ident_scp++; } printf("Types:\n"); for (auto i = types.cbegin(); i != types.cend(); i++) { printf("%s\n", i->first->c_str()); for (auto j = i->second->fields->cbegin(); j != i->second->fields->cend(); j++) { printf("\t%s %s\n", j->first->c_str(), get_attributes(j->second->attributes)); } } }
CL_DomAttr CL_DomElement::get_attribute_node_ns( const CL_DomString &namespace_uri, const CL_DomString &local_name) const { if (impl) { CL_DomNamedNodeMap attributes = get_attributes(); CL_DomAttr attribute = attributes.get_named_item_ns(namespace_uri, local_name).to_attr(); return attribute; } return CL_DomAttr(); }
void symbol_dump (symbol *sym, string *name) { if (sym == NULL || name == NULL) return; size_t depth = sym->block_num; for (size_t i = 0; i < depth; i++) fprintf(sym_file, "\t"); fprintf(sym_file, "%s (%zu.%zu.%zu) {%zu} %s\n", name->c_str(), sym->filenum, sym->linenum, sym->offset, sym->block_num, get_attributes(sym->attributes)); }
static bool first_open( rtems_termios_tty *tty, rtems_termios_device_context *base, struct termios *term, rtems_libio_open_close_args_t *args ) { struct apbuart_priv *uart = base_get_priv(base); uart->tty = tty; /* Inherit UART hardware parameters from bootloader on system console */ if (uart->condev.flags & CONSOLE_FLAG_SYSCON_GRANT) { get_attributes(base, term); term->c_oflag |= ONLCR; set_attributes(base, term); } /* Enable TX/RX */ uart->regs->ctrl |= APBUART_CTRL_RE | APBUART_CTRL_TE; if (uart->mode != TERMIOS_POLLED) { int ret; uint32_t ctrl; /* Register interrupt and enable it */ ret = drvmgr_interrupt_register( uart->dev, 0, uart->devName, apbuart_cons_isr, tty ); if (ret) { return false; } uart->sending = 0; /* Turn on RX interrupts */ ctrl = uart->regs->ctrl; ctrl |= APBUART_CTRL_RI; if (uart->cap & CAP_DI) { /* Use RX FIFO interrupt only if delayed interrupt available. */ ctrl |= (APBUART_CTRL_DI | APBUART_CTRL_RF); } uart->regs->ctrl = ctrl; } return true; }
Horizon::Implementation::Implementation (const BlockModel& al) : dry_bulk_density (al.number ("dry_bulk_density", -42.42e42)), SOM_C_per_N (al.number_sequence ("SOM_C_per_N")), C_per_N (al.number ("C_per_N", -42.42e42)), SOM_fractions (al.check ("SOM_fractions") ? al.number_sequence ("SOM_fractions") : std::vector<double> ()), turnover_factor (al.number ("turnover_factor")), anisotropy (al.number ("anisotropy")), attributes (get_attributes (al.submodel_sequence ("attributes"))), dimensions (get_dimensions (al.submodel_sequence ("attributes"))), nitrification (Librarian::build_item<Nitrification> (al, "Nitrification")), secondary (Librarian::build_item<Secondary> (al, "secondary_domain")), r_pore_min (al.number ("r_pore_min")), primary_sorption_fraction (NAN), hor_heat (al.submodel ("HorHeat")), CEC (al.number ("CEC", -42.42e42)) { }
void CL_DomElement::set_attribute(const CL_DomString &name, const CL_DomString &value) { if (impl) { CL_DomNamedNodeMap attributes = get_attributes(); CL_DomAttr attribute = attributes.get_named_item(name).to_attr(); if (attribute.is_attr()) { attribute.set_node_value(value); } else { attribute = get_owner_document().create_attribute(name); attribute.set_node_value(value); attributes.set_named_item(attribute); } } }
void Tilemap::add_layer(std::map<unsigned, Surface>& tiles, xml_node node, int tilewidth, int tileheight) { Layer layer; int width = node.attribute("width").as_int(); int height = node.attribute("height").as_int(); if (!width || !height) throw std::logic_error("Layer is empty."); #if 0 std::cerr << "Adding layer:" << " Name: " << node.attribute("name").value() << " Width: " << width << " Height: " << height << std::endl; #endif Utils::xml_node_walker walk{node.child("data"), "tile", "gid"}; int index = 0; for (auto& gid_str : walk) { Pos pos = Pos(index % width, index / width); unsigned gid = Utils::stoi(gid_str); if (gid) { Blit::Surface surf = tiles[gid]; surf.rect().pos = pos * Pos(tilewidth, tileheight); layer.cluster.vec().push_back({surf, Pos()}); if (Utils::find_or_default(surf.attr(), "collision", "") == "true") collisions.insert(pos); } index++; } layer.attr = get_attributes(node.child("properties"), "property"); layer.name = node.attribute("name").value(); m_layers.push_back(std::move(layer)); }
void DomElement::set_attribute_ns( const DomString &namespace_uri, const DomString &qualified_name, const DomString &value) { if (impl) { DomNamedNodeMap attributes = get_attributes(); DomAttr attribute = attributes.get_named_item_ns(namespace_uri, qualified_name).to_attr(); if (attribute.is_attr()) { attribute.set_node_value(value); } else { attribute = get_owner_document().create_attribute_ns(namespace_uri, qualified_name); attribute.set_node_value(value); attributes.set_named_item_ns(attribute); } } }
/* * DER encode a DistinguishedName */ void X509_DN::encode_into(DER_Encoder& der) const { std::multimap<OID, std::string> dn_info = get_attributes(); der.start_cons(SEQUENCE); if(!dn_bits.empty()) der.raw_bytes(dn_bits); else { do_ava(der, dn_info, PRINTABLE_STRING, "X520.Country"); do_ava(der, dn_info, DIRECTORY_STRING, "X520.State"); do_ava(der, dn_info, DIRECTORY_STRING, "X520.Locality"); do_ava(der, dn_info, DIRECTORY_STRING, "X520.Organization"); do_ava(der, dn_info, DIRECTORY_STRING, "X520.OrganizationalUnit"); do_ava(der, dn_info, DIRECTORY_STRING, "X520.CommonName"); do_ava(der, dn_info, PRINTABLE_STRING, "X520.SerialNumber"); } der.end_cons(); }
ErrorCode ReadNC::get_variables() { // First cache the number of time steps std::vector<std::string>::iterator vit = std::find(dimNames.begin(), dimNames.end(), "time"); if (vit == dimNames.end()) vit = std::find(dimNames.begin(), dimNames.end(), "t"); int ntimes = 0; if (vit != dimNames.end()) ntimes = dimLens[vit - dimNames.begin()]; if (!ntimes) ntimes = 1; // Get the number of variables int num_vars; int success = NCFUNC(inq_nvars)(fileId, &num_vars); if (success) MB_SET_ERR(MB_FAILURE, "Trouble getting number of variables"); if (num_vars > NC_MAX_VARS) { MB_SET_ERR(MB_FAILURE, "ReadNC: File contains " << num_vars << " vars but NetCDF library supports only " << NC_MAX_VARS); } char var_name[NC_MAX_NAME + 1]; int var_ndims; for (int i = 0; i < num_vars; i++) { // Get the name first, so we can allocate a map iterate for this var success = NCFUNC(inq_varname )(fileId, i, var_name); if (success) MB_SET_ERR(MB_FAILURE, "Trouble getting variable name"); VarData &data = varInfo[std::string(var_name)]; data.varName = std::string(var_name); data.varId = i; data.varTags.resize(ntimes, 0); // Get the data type success = NCFUNC(inq_vartype)(fileId, i, &data.varDataType); if (success) MB_SET_ERR(MB_FAILURE, "Trouble getting data type for variable " << data.varName); // Get the number of dimensions, then the dimensions success = NCFUNC(inq_varndims)(fileId, i, &var_ndims); if (success) MB_SET_ERR(MB_FAILURE, "Trouble getting number of dims for variable " << data.varName); data.varDims.resize(var_ndims); success = NCFUNC(inq_vardimid)(fileId, i, &data.varDims[0]); if (success) MB_SET_ERR(MB_FAILURE, "Trouble getting dimensions for variable " << data.varName); // Finally, get the number of attributes, then the attributes success = NCFUNC(inq_varnatts)(fileId, i, &data.numAtts); if (success) MB_SET_ERR(MB_FAILURE, "Trouble getting number of dims for variable " << data.varName); // Print debug info here so attribute info comes afterwards dbgOut.tprintf(2, "Variable %s: Id=%d, numAtts=%d, datatype=%d, num_dims=%u\n", data.varName.c_str(), data.varId, data.numAtts, data.varDataType, (unsigned int) data.varDims.size()); ErrorCode rval = get_attributes(i, data.numAtts, data.varAtts, " ");MB_CHK_SET_ERR(rval, "Trouble getting attributes for variable " << data.varName); } return MB_SUCCESS; }
int call_modify (int argc, char **argv) { struct ds_modifyentry_arg mod_arg; struct DSError error; struct entrymod *emnew, *ems_append(), *modify_avs(); Attr_Sequence as, #ifdef TURBO_DISK fget_attributes (), #else get_attributes (), #endif temp, trail = NULLATTR; AV_Sequence avst = NULLAV; extern AttributeType at_objectclass; extern int parse_status; Entry entry_ptr; FILE *fd; char draft_flag = FALSE; char noedit_flag = FALSE; int x; DN moddn; char *home; RDN new_rdn; struct list_element *start = 0 ; struct list_element *last ; struct list_element *l_temp ; /* char add = FALSE ; char rem = FALSE ; */ if ((argc = service_control (OPT, argc, argv, &mod_arg.mea_common)) == -1) return; mod_arg.mea_changes = NULLMOD; new_draft = FALSE; if (home = getenv ("DISHDRAFT")) strcpy (fname, home); else if (dad_flag) { strcpy (fname, "/tmp/dishXXXXXX"); unlink (mktemp (fname)); } else if (home = getenv ("HOME")) sprintf (fname, "%s/.dishdraft", home); else strcpy (fname, "./.dishdraft"); for (x=1; x<argc; x++) { if (test_arg (argv[x], "-draft",1)) { draft_flag = 1; shuffle_up (argc--,argv,x); if (x == argc) { ps_printf (OPT, "Draft file name missing\n"); Usage (argv[0]); return; } strcpy (fname, argv[x]); shuffle_up (argc--,argv,x--); } else if (test_arg (argv[x], "-newdraft",2)) { new_draft = TRUE; shuffle_up (argc--,argv,x--); } else if (test_arg (argv[x], "-noedit",3)) { noedit_flag = TRUE; shuffle_up (argc--,argv,x--); } else if (move (argv[x]) == OK) shuffle_up (argc--,argv,x--); else if (test_arg(argv[x], "-remove", 3)) { shuffle_up (argc--, argv, x); if (x == argc) { ps_printf(OPT, "Attribute to remove missing\n") ; Usage(argv[0]) ; return ; } l_temp = (struct list_element *) malloc (sizeof(struct list_element)) ; l_temp->mod = (char *) malloc ((unsigned)(strlen(argv[x]) + 1)); strcpy (l_temp->mod, argv[x]) ; l_temp->add = 0 ; l_temp->next = 0 ; if (start == 0) { start = last = l_temp ; } else { last->next = l_temp ; last = l_temp ; } shuffle_up (argc--,argv,x--); } else if (test_arg(argv[x], "-add", 2)) { shuffle_up (argc--, argv, x); if (x == argc) { ps_printf(OPT, "Attribute to insert missing\n") ; Usage(argv[0]) ; return ; } l_temp = (struct list_element *) malloc (sizeof(struct list_element)) ; l_temp->mod = (char *) malloc ((unsigned)(strlen(argv[x]) + 1)); strcpy (l_temp->mod, argv[x]) ; l_temp->add = 1 ; l_temp->next = 0 ; if (start == 0) { start = last = l_temp ; } else { last->next = l_temp ; last = l_temp ; } shuffle_up (argc--,argv,x--); } } if (dad_flag && (draft_flag || noedit_flag)) { ps_printf (OPT, "operation not allowed when using directory assistance server!\n"); return; } /* read attributes we want to modify */ if ((argc = read_cache_aux (argc, argv, FALSE, &mod_arg.mea_common)) <0 ) return; if (argc != 1) { ps_printf (OPT,"Unknown option %s\n",argv[1]); Usage (argv[0]); return; } if (start != 0) { if (build_modify(start, &mod_arg) == NOTOK) { return ; } while (ds_modifyentry (&mod_arg, &error) != DS_OK) { if (dish_error (OPT, &error) == 0) { return ; } mod_arg.mea_object = error.ERR_REFERRAL.DSE_ref_candidates->cr_name ; } ps_print (RPS, "Modified "); dn_print (RPS, dn, EDBOUT); ps_print (RPS, "\n"); delete_cache (dn); /* re-cache when next read */ return ; } if (!draft_flag) { if (mod_template (fname,noedit_flag) != OK) return; noedit_flag = FALSE; } else { new_draft = TRUE; /* Ugh ! */ mod_template ("/dev/null",TRUE); } if (! noedit_flag) if (editentry (1, argv) != OK) { make_old (fname,draft_flag); return; } /* now parse the files */ if ((fd = fopen (fname, "r")) == (FILE *) NULL) { ps_printf (OPT, "Can't open draft entry %s\n", fname); return; } entry_ptr = get_default_entry (NULLENTRY); #ifdef TURBO_DISK entry_ptr->e_attributes = fget_attributes (fd); #else entry_ptr->e_attributes = get_attributes (fd); #endif fclose (fd); if (parse_status != 0) return; mod_arg.mea_object = dn; for (moddn = dn ; moddn->dn_parent != NULLDN; moddn=moddn->dn_parent) ; entry_ptr->e_name = rdn_cpy (moddn->dn_rdn); /* add rdn as attribute */ for (new_rdn = entry_ptr->e_name; new_rdn != NULLRDN; new_rdn = new_rdn->rdn_next) { avst = avs_comp_new (AttrV_cpy (&new_rdn->rdn_av)); temp = as_comp_new (AttrT_cpy (new_rdn->rdn_at), avst, NULLACL_INFO); entry_ptr->e_attributes = as_merge (entry_ptr->e_attributes, temp); } for (as = entry_ptr->e_attributes; as != NULLATTR; as = as->attr_link) { emnew = NULLMOD; trail = as->attr_link; as->attr_link = NULLATTR; temp = current_entry->e_attributes; for (; temp != NULLATTR; temp = temp->attr_link) if (AttrT_cmp (as->attr_type, temp->attr_type) == 0) { /* found it - does it need changing ? */ if (avs_cmp (as->attr_value, temp->attr_value) != 0) emnew = modify_avs (as->attr_value, temp->attr_value,as->attr_type); break; } if (temp == NULLATTR) { emnew = em_alloc (); emnew->em_type = EM_ADDATTRIBUTE; emnew->em_what = as_cpy(as); emnew->em_next = NULLMOD; } if (emnew != NULLMOD) mod_arg.mea_changes = ems_append (mod_arg.mea_changes,emnew); as->attr_link = trail; } /* remove attribute missing in new entry */ for (as = current_entry->e_attributes; as != NULLATTR; as = as->attr_link) { emnew = NULLMOD; temp = entry_ptr->e_attributes; for (; temp != NULLATTR; temp = temp->attr_link) if (AttrT_cmp (as->attr_type, temp->attr_type) == 0) break; if (temp == NULLATTR) { emnew = em_alloc (); emnew->em_type = EM_REMOVEATTRIBUTE; emnew->em_what = as_comp_new(as->attr_type,NULLAV,NULLACL_INFO); emnew->em_next = NULLMOD; } if (emnew != NULLMOD) mod_arg.mea_changes = ems_append (mod_arg.mea_changes,emnew); } if (mod_arg.mea_changes == NULLMOD) { ps_print (RPS, "The draft entry and the entry for "); dn_print (RPS, dn, EDBOUT); ps_print (RPS, "\nare exactly the same - no change made!!!\n"); entry_free (entry_ptr); make_old (fname,draft_flag); return; } if (rebind () != OK) { entry_free (entry_ptr); return; } /* * If this operation is time-stamped, it may have expired while the user * was editing the entry. Re-calculate the time-stamp. Modify is the only * dish command where this needs to be done. */ if ((mod_arg.mea_common.ca_security != (struct security_parms *) 0) && (mod_arg.mea_common.ca_security->sp_time != NULLCP)) { char *new_version(); free(mod_arg.mea_common.ca_security->sp_time); mod_arg.mea_common.ca_security->sp_time = new_version(); } /* If security parameters are present, take this to mean that strong * authentication is required. This disallows 'parms + no signature' * (pointless) and 'signature + no parms' (security risk). */ if (mod_arg.mea_common.ca_security != (struct security_parms *) 0) { extern struct SecurityServices *dsap_security; mod_arg.mea_common.ca_sig = (dsap_security->serv_sign)((caddr_t)&mod_arg, _ZModifyEntryArgumentDataDAS, &_ZDAS_mod); } while (ds_modifyentry (&mod_arg, &error) != DS_OK) { if (dish_error (OPT, &error) == 0) { entry_free (entry_ptr); return; } mod_arg.mea_object = error.ERR_REFERRAL.DSE_ref_candidates->cr_name; } ps_print (RPS, "Modified "); dn_print (RPS, dn, EDBOUT); ps_print (RPS, "\n"); delete_cache (dn); /* re-cache when next read */ entry_free (entry_ptr); ems_part_free (mod_arg.mea_changes); make_old (fname,draft_flag); }
CL_DomAttr CL_DomElement::set_attribute_node_ns(const CL_DomAttr &attr) { if (impl) return get_attributes().set_named_item_ns(attr).to_attr(); return CL_DomAttr(); }
// Writes the attributes for the file void GenericLevelObj::write_properties(FileWriter &fw) { fw.begin_section(section_name.c_str()); const unsigned attribs_ = get_attributes(section_name); if (attribs_ & HAS_TYPE) fw.write_string("type", object_type); if (attribs_ & HAS_GPTYPE) fw.write_string("type", ground_type); if (attribs_ & HAS_SPRITE) { fw.begin_section("surface"); fw.write_string("image", desc.res_name); fw.write_string("modifier", ResourceModifier::to_string(desc.modifier)); fw.end_section(); // surface } fw.write_vector("position", pos); if (attribs_ & HAS_SPEED) fw.write_int("speed", speed); if (attribs_ & HAS_PARALLAX) fw.write_float("parallax", parallax); if (attribs_ & HAS_REPEAT) fw.write_int("repeat", repeat); if (attribs_ & HAS_OWNER) fw.write_int("owner-id", owner_id); if (attribs_ & HAS_DIRECTION) fw.write_string("direction", direction); if (attribs_ & HAS_RELEASE_RATE) fw.write_int("release-rate", release_rate); if (attribs_ & HAS_COLOR) fw.write_colori("colori", color); if (attribs_ & HAS_STRETCH) { fw.write_bool("stretch-x", stretch_x); fw.write_bool("stretch-y", stretch_y); fw.write_bool("keep-aspect", keep_aspect); } if (attribs_ & HAS_SCROLL) { fw.write_float("scroll-x", scroll_x); fw.write_float("scroll-y", scroll_y); } if (attribs_ & HAS_PARA) { fw.write_float("para-x", para_x); fw.write_float("para-y", para_y); } if (attribs_ & HAS_STARFIELD) { fw.write_int("small-stars", small_stars); fw.write_int("middle-stars", middle_stars); fw.write_int("large-stars", large_stars); } if (attribs_ & HAS_ID) { fw.write_string("id", id); } if (attribs_ & HAS_TARGET_ID) { fw.write_string("target-id", target_id); } if (attribs_ & HAS_HEIGHT) fw.write_int("height", height); // Writes any extra properties that may be necessary (virtual function) write_extra_properties(fw); fw.end_section(); // object's section_name }
Skybox::Skybox(size_t const size) : Object("skybox", get_attributes(size), std::set<Uniform>(), get_texture(size)) {}
main() { struct passwd *pw_entry ; struct passwd *getpwuid() ; struct stat buf ; int i = 1 ; int uid ; int um ; char pass1[LINESIZE] ; char pass2[LINESIZE] ; char Read_in_Stuff[LINESIZE] ; char **vecptr ; char *tmpdraft ; char home_dir[LINESIZE] ; char *p, *part1, *part2 ; char quipurc_file[100] ; char tailor_file[100] ; char user_name[9] ; char *localptr = Local ; char print_format = EDBOUT ; EntryInfo *ptr ; static CommonArgs ca = default_common_args; vecptr = (char **) malloc(100) ; vecptr[0] = malloc (LINESIZE) ; (void) strcpy(vecptr[0], "showentry") ; (void) strcpy(pass1, "x") ; (void) strcpy(pass2, "y") ; tmpdraft = malloc (LINESIZE) ; (void) strcpy(tmpdraft, "/tmp/dish-") ; if ((opt = ps_alloc (std_open)) == NULLPS) fatal (-62, "ps_alloc failed"); if (std_setup (opt, stderr) == NOTOK) fatal (-63, "std_setup failed"); if ((rps = ps_alloc (std_open)) == NULLPS) fatal (-64, "ps_alloc 2 failed"); if (std_setup (rps, stdout) == NOTOK) fatal (-65, "std_setup 2 failed"); (void) strcpy(filterstring, "userid=") ; /* Sort out files, userids etc. */ uid=getuid() ; if ((pw_entry=getpwuid(uid)) == 0) { ps_printf(rps, "Who are you? (no name for your uid number)\n") ; exit(1) ; } (void) strcpy(user_name, pw_entry->pw_name) ; (void) strcat(tmpdraft, user_name) ; if (getenv("HOME") == 0) { ps_printf(rps, "No home directory?!!") ; (void) strcpy(home_dir, pw_entry->pw_dir) ; } else { (void) strcpy(home_dir, getenv("HOME")) ; } (void) strcpy(quipurc_file, home_dir) ; (void) strcat(quipurc_file, "/.quipurc") ; (void) strcpy(tailor_file, isodefile ("dishinit", 1)); Manager[0] = 0; Password[0] = 0; Local[0] = 0; (void) stat(tailor_file, &buf) ; (void) seteuid(buf.st_uid) ; /* set effective to enable */ /* us to read protected file */ if ((fp_tailor = fopen(tailor_file, "r")) == 0) { ps_print(rps, "Can't open Tailor File. Abort.\n") ; exit(1) ; } while (fgets (Read_in_Stuff, LINESIZE, fp_tailor) != 0) { if (!strcmp(Read_in_Stuff, "##Anything after this line is copied into the users ~/.quipurc file\n")) { break ; } p = SkipSpace (Read_in_Stuff); if (( *p == '#') || (*p == '\0')) continue; /* ignore comments and blanks */ part1 = p; if ((part2 = index (p,':')) == NULLCP) { ps_printf (opt,"Seperator missing '%s'. Ignoring..\n",p); } *part2++ = '\0'; part2 = TidyString (part2); if (lexequ(part1, "manager") == 0) { (void) strcpy(Manager, part2) ; } else if (lexequ(part1, "password") == 0) { (void) strcpy(Password, part2) ; } else if (lexequ(part1, "local") == 0) { (void) strcpy(Local, part2) ; } else { ps_printf(rps, "Error in tailor. What's a %s?\n", part1) ; } } (void) setuid(uid) ; /* Restore Userid to original user. */ /* create ~/.quipurc file. NB this does eradicate anything in there. * (Theoretically nothing.) */ if (Manager[0] == 0) { ps_print(rps, "Can't find out the managers name\n") ; exit(1) ; } if (Password[0] == 0) { ps_print(rps, "Can't find out the managers password\n") ; exit(1) ; } if (Local[0] == 0) { ps_print(rps, "Can't find out where to search\n") ; exit(1) ; } um = umask(0177) ; if ((fp_quipurc = fopen(quipurc_file, "w")) == 0) { ps_printf(rps, "Can't open ~/.quipurc. Aborting..\n") ; exit(1) ; } (void) umask(um) ; if ((fileps = ps_alloc(std_open)) == NULLPS) { fatal (-66, "ps_alloc 2 failed"); } if (std_setup (fileps, fp_quipurc) == NOTOK) { fatal (-67, "std_setup 2 failed"); } /* Sorting out the bind section */ quipu_syntaxes() ; /* set up the needed function pointers */ dsap_init(&i, &vecptr) ; (void) strcpy(bindarg.dba_passwd, Password) ; bindarg.dba_version = DBA_VERSION_V1988; bindarg.dba_passwd_len = strlen(bindarg.dba_passwd) ; if ((bindarg.dba_dn = str2dn (Manager)) == NULLDN) { ps_printf (opt,"Invalid Manager name %s (???!)\n",Manager) ; exit(1) ; } if (ds_bind (&bindarg, &binderr, &bindresult) != OK) { ps_printf(rps, "Can't bind as the manager.\n") ; exit(1); } /* Hopefully, should be successfully bound */ /* * We now call the search stuff with the right bits, to see if we can get a * match of uid='user_name'. Once there, we echo lots of information from * their entry out to the .quipurc file. * Hopefully there should only be one match. This assumes that ALL dir info * up to date, and that SG do not allow multiple users with the same login. */ /* set up the appropriate structures and defaults. */ search_arg.sra_common = ca; /* struct copy */ search_arg.sra_common.ca_servicecontrol.svc_sizelimit = 2 ; search_arg.sra_eis.eis_allattributes = FALSE ; search_arg.sra_searchaliases = FALSE; search_arg.sra_subset = SRA_ONELEVEL; search_arg.sra_eis.eis_infotypes = EIS_ATTRIBUTESANDVALUES ; search_arg.sra_eis.eis_select = NULLATTR ; search_arg.sra_eis.eis_allattributes = TRUE ; search_arg.sra_filter = filter_alloc() ; /* Default filter. */ search_arg.sra_filter->flt_next = NULLFILTER; search_arg.sra_filter->flt_type = FILTER_ITEM; search_arg.sra_filter->FUFILT = NULLFILTER; if (*localptr == '@') { localptr++; } if ((search_arg.sra_baseobject = str2dn(localptr)) == NULLDN) { ps_printf (opt,"Invalid sequence in username %s.\n", localptr); exit(1) ; } (void) strcat(filterstring, user_name) ; search_arg.sra_filter->flt_un.flt_un_item.fi_type = FILTERITEM_EQUALITY ; if ((search_arg.sra_filter->flt_un.flt_un_item.fi_un.fi_un_ava.ava_type = AttrT_new ("userid")) == NULLAttrT) { ps_printf(rps, "Oops, userid is not a valid attr type. ABORT!!\n") ; exit(1) ; } if ((search_arg.sra_filter->flt_un.flt_un_item.fi_un.fi_un_ava.ava_value = str2AttrV (user_name, search_arg.sra_filter->flt_un.flt_un_item.fi_un.fi_un_ava.ava_type->oa_syntax)) == NULLAttrV) { ps_printf(rps, "%s is not a valid attribute value.\n", user_name) ; } /* call search */ /* We now ought to be in the right place, and with the search stuff set, * ready to call search, and receive one (or no) entry back, which then * gets processed accordingly. */ if (ds_search (&search_arg, &search_error, &search_result) != DS_OK) { ps_printf(rps, "Search failed...\n") ; exit (1) ; /* This is not the same as coming back with */ /* message "search failed to find anything. */ } /* If the user does not exist in the DIT, print out the limited .quipurc * and the warning message, and allow the user to play DISH. */ if (search_result.CSR_entries == NULLENTRYINFO) { ps_printf(opt, "Unfortunately, you seem to have no entry in\n") ; ps_printf(opt, "the directory. Contact '%s' who should be able to help.\n", Manager) ; ps_printf(opt, "In the mean time, you can read, but not write.\n") ; } else { ptr = search_result.CSR_entries ; dn = dn_cpy(ptr->ent_dn) ; /* Essence of move user_name. */ /* collect the info and put it into current_entry */ /* Set up the desired attribute type to be read*/ /* from read.c */ if ((at = AttrT_new ("userPassword")) != NULLAttrT) { as_flag = as_merge (as_flag, as_comp_new (AttrT_cpy (at), NULLAV, NULLACL_INFO)); } else { ps_printf(rps, "Oops, Serious error. unknown attribute type 'userPassword'.\n") ; exit(1) ; } if ((current_entry = local_find_entry (dn, FALSE)) == NULLENTRY) { read_arg.rda_common = ca; /* struct copy */ read_arg.rda_object = dn; read_arg.rda_eis.eis_infotypes = EIS_ATTRIBUTESANDVALUES; read_arg.rda_eis.eis_allattributes = TRUE ; read_arg.rda_eis.eis_select = NULLATTR ; if (ds_read (&read_arg, &read_error, &read_result) != DS_OK) { ps_printf(rps, "We even seem to be having problems reading\n" ) ; ps_printf(rps, "an entry we searched and found!! HELP!!\n") ; exit(1) ; } if (read_result.rdr_entry.ent_attr == NULLATTR) { ps_printf(rps, "No attributes present. Even though\n") ; ps_printf(rps, "we found you by userid attribute!!! HELP!!\n") ; exit (1) ; } cache_entry (&(read_result.rdr_entry), read_arg.rda_eis.eis_allattributes, TRUE) ; } if ((current_entry = local_find_entry (dn, FALSE)) == NULLENTRY) { ps_printf(rps, "We still have nothing.Even after reading? Abort.\n") ; exit(1) ; } ps_printf(fileps, "username: "******"\n") ; ps_printf(fileps, "me: ") ; dn_print(fileps, dn, EDBOUT) ; ps_printf(fileps, "\n") ; /* now showattribute -nokey to display it. */ ps_printf(fileps, "password: "******"You need a password...\n") ; (void) strcpy(pass1, getpassword("Enter Password: "******"Re-enter password: "******"\nMismatch - Try again.\n") ; } } ps_printf(fileps, "%s\n", pass1) ; um = umask(0177) ; if ((fp_draft = fopen(tmpdraft, "w")) == 0) { ps_print(rps, "Can't open draft file... Abort.\n") ; exit(1) ; } (void) umask(um) ; (void) fprintf(fp_draft, "UserPassword = %s\n", pass1) ; (void) fprintf(fp_draft, "acl = self # write # attributes # acl $ userPassword\n") ; (void) fprintf(fp_draft, "acl = others # compare # attributes # acl $ userPassword\n\n") ; (void) fclose(fp_draft) ; if ((fp_draft = fopen (tmpdraft, "r")) == NULL) { ps_printf (opt, "Can't open draft entry %s\n", tmpdraft); exit(1) ; } entry_ptr = get_default_entry (NULLENTRY); #ifdef TURBO_DISK entry_ptr->e_attributes = fget_attributes (fp_draft); #else entry_ptr->e_attributes = get_attributes (fp_draft); #endif (void) fclose (fp_draft); mod_arg.mea_common = ca; /* struct copy */ mod_arg.mea_object = dn; for (moddn = dn ; moddn->dn_parent != NULLDN; moddn=moddn->dn_parent) ; entry_ptr->e_name = rdn_cpy (moddn->dn_rdn); /* add rdn as attribute */ avst = avs_comp_new (AttrV_cpy (&entry_ptr->e_name->rdn_av)); temp = as_comp_new (AttrT_cpy (entry_ptr->e_name->rdn_at), avst, NULLACL_INFO); entry_ptr->e_attributes = as_merge (entry_ptr->e_attributes, temp); for (as = entry_ptr->e_attributes; as != NULLATTR; as = as->attr_link) { emnew = NULLMOD; trail = as->attr_link; as->attr_link = NULLATTR; temp = current_entry->e_attributes; for (; temp != NULLATTR; temp = temp->attr_link) if (AttrT_cmp (as->attr_type, temp->attr_type) == 0) { /* found it - does it need changing ? */ if (avs_cmp (as->attr_value, temp->attr_value) != 0) emnew = modify_avs (as->attr_value, temp->attr_value,as->attr_type); break; } if (temp == NULLATTR) { emnew = em_alloc (); emnew->em_type = EM_ADDATTRIBUTE; emnew->em_what = as_cpy(as); emnew->em_next = NULLMOD; } if (emnew != NULLMOD) { mod_arg.mea_changes = ems_append (mod_arg.mea_changes,emnew); } as->attr_link = trail; } while (ds_modifyentry (&mod_arg, &mod_error) != DS_OK) { if (dish_error (opt, &mod_error) == 0) { ps_printf(rps,"We have a dish error. Bye.\n") ; entry_free (entry_ptr); exit(1) ; } mod_arg.mea_object = mod_error.ERR_REFERRAL.DSE_ref_candidates->cr_name; } ps_print (rps, "Modified "); dn_print (rps, dn, EDBOUT); ps_print (rps, "\n"); delete_cache (dn); /* re-cache when next read */ entry_free (entry_ptr); ems_part_free (mod_arg.mea_changes); } } while(fgets(Read_in_Stuff, LINESIZE, fp_tailor) != 0) { fputs(Read_in_Stuff, fp_quipurc) ; } (void) fclose(fp_quipurc) ; (void) fclose(fp_tailor) ; /* (void) fprintf(fp_quipurc, "dsap: local_dit \"%s\"\n", Local) ; (void) fprintf(fp_quipurc, "notype: acl\n") ; (void) fprintf(fp_quipurc, "notype: treestructure\n") ; (void) fprintf(fp_quipurc, "notype: masterdsa\n") ; (void) fprintf(fp_quipurc, "notype: slavedsa\n") ; (void) fprintf(fp_quipurc, "notype: objectclass\n") ; (void) fprintf(fp_quipurc, "cache_time: 30\n") ; (void) fprintf(fp_quipurc, "connect_time: 2\n") ; */ (void) ds_unbind() ; (void) unlink(tmpdraft) ; }
void Tilemap::add_tileset(std::map<unsigned, Surface>& tiles, xml_node node) { int first_gid = node.attribute("firstgid").as_int(); int id_cnt = 0; int tilewidth = node.attribute("tilewidth").as_int(); int tileheight = node.attribute("tileheight").as_int(); pugi::xml_node image = node.child("image"); const char *source = image.attribute("source").value(); int width = image.attribute("width").as_int(); int height = image.attribute("height").as_int(); #if 0 std::cerr << "Adding tileset:" << " Name: " << node.attribute("name").value() << " Gid: " << first_gid << " Tilewidth: " << tilewidth << " Tileheight: " << tileheight << " Source: " << source << " Width: " << width << " Height: " << height << std::endl; #endif if (!width || !height || !tilewidth || !tileheight) throw std::logic_error("Tilemap is malformed."); SurfaceCache cache; Blit::Surface surf = cache.from_image(Utils::join(dir, "/", source)); if (surf.rect().w != width || surf.rect().h != height) throw std::logic_error("Tilemap geometry does not correspond with image values."); std::map<std::basic_string<char>, std::basic_string<char> > global_attr = get_attributes(node.child("properties"), "property"); #if 0 std::cerr << "Dumping attrs:" << std::endl; for (auto& attr : global_attr) std::cerr << "Found global attr (" << attr.first << " => " << attr.second << ")." << std::endl; std::cerr << "Dumped attrs." << std::endl; #endif for (int y = 0; y < height; y += tileheight) { for (int x = 0; x < width; x += tilewidth, id_cnt++) { int id = first_gid + id_cnt; tiles[id] = surf.sub({{x, y}, tilewidth, tileheight}); std::copy(global_attr.begin(), global_attr.end(), std::inserter(tiles[id].attr(), tiles[id].attr().begin())); } } // Load all attributes for a tile into the surface. for (auto tile = node.child("tile"); tile; tile = tile.next_sibling("tile")) { int id = first_gid + tile.attribute("id").as_int(); std::map<std::basic_string<char>, std::basic_string<char> > attrs = get_attributes(tile.child("properties"), "property"); std::copy(global_attr.begin(), global_attr.end(), std::inserter(attrs, attrs.begin())); auto itr = attrs.find("sprite"); if (itr != attrs.end()) tiles[id] = cache.from_sprite(Utils::join(dir, "/", itr->second)); tiles[id].attr() = std::move(attrs); } }
DomAttr DomElement::set_attribute_node(const DomAttr &attr) { if (impl) return get_attributes().set_named_item(attr).to_attr(); return DomAttr(); }
void BugzillaLink::set_bug_url(const std::string & value) { get_attributes()[URI_ATTRIBUTE_NAME] = value; make_image(); }
static void print_die_data(Dwarf_Debug dbg, Dwarf_Die print_me,int level, struct srcfilesdata *sf) { char *name = 0; Dwarf_Error error = 0; Dwarf_Half tag = 0; const char *tagname = 0; int localname = 0; struct attributes attr; int res = dwarf_diename(print_me,&name,&error); if(res == DW_DLV_ERROR) { printf("Error in dwarf_diename , level %d \n",level); exit(1); } if(res == DW_DLV_NO_ENTRY) { name = "<no DW_AT_name attr>"; localname = 1; } res = dwarf_tag(print_me,&tag,&error); if(res != DW_DLV_OK) { printf("Error in dwarf_tag , level %d \n",level); exit(1); } res = dwarf_get_TAG_name(tag,&tagname); if(res != DW_DLV_OK) { printf("Error in dwarf_get_TAG_name , level %d \n",level); exit(1); } if (level == 1) { if (tag == DW_TAG_structure_type || tag == DW_TAG_base_type ||(tag==DW_TAG_array_type)|| (tag == DW_TAG_pointer_type) || (tag == DW_TAG_typedef) || (tag==DW_TAG_variable)) { curr_top_tag = DW_TAG_structure_type; } else { curr_top_tag = 0; } } if (curr_top_tag != 0) { Dwarf_Off offset = 0; dwarf_dieoffset(print_me, &offset, &error); if (level > 1) { printf(" "); } count_data_types++; attr.size =0; attr.type_offset =0; attr.filename = 0; attr.member_location = 0; if (get_attributes(dbg, print_me, level, sf, &attr)==1){ printf("<%d> tag: %d %s name: \"%s\" offset:%x ", level, tag, tagname, name, offset); if (attr.type_offset != 0){ printf(" type offset: %x ",attr.type_offset); } if (attr.size != 0){ printf("size : %d ",attr.size); } if (attr.filename != 0){ printf(" filename: %s ",attr.filename); } printf("\n"); db_entries[db_count].offset = offset; db_entries[db_count].type_offset = attr.type_offset; db_entries[db_count].tag = tag; db_entries[db_count].level = level; db_entries[db_count].size = attr.size; db_entries[db_count].member_location = attr.member_location; strncpy(db_entries[db_count].name,name,MAX_NAME-1); db_count++; }else{ // printf("Decleartion <%d> tag: %d %s name: \"%s\" offset:%x \n", level, tag, tagname, // name, offset); } } if (!localname) { dwarf_dealloc(dbg, name, DW_DLA_STRING); } }
static int check_for_node_usability(const char *pathname) { struct stat st; if(!access(pathname, F_OK)) { ticables_info(_(" node %s: exists"), pathname); } else { ticables_info(_(" node %s: does not exist"), pathname); ticables_info(_(" => you will have to create the node.")); return -1; } if(!stat(pathname, &st)) { ticables_info(_(" permissions/user/group:%s%s %s"), get_attributes(st.st_mode), get_user_name(st.st_uid), get_group_name(st.st_gid)); } else { ticables_warning("can't stat '%s'.", pathname); return -1; } if(getuid() == st.st_uid) { ticables_info(_(" user can r/w on device: yes")); return 0; } else { ticables_info(_(" user can r/w on device: no")); } if((st.st_mode & S_IROTH) && (st.st_mode & S_IWOTH)) { ticables_info(_(" others can r/w on device: yes")); } else { char *user, *group; ticables_info(_(" others can r/w on device: no")); user = strdup(get_user_name(getuid())); group = strdup(get_group_name(st.st_gid)); if(!search_for_user_in_group(user, group)) { ticables_info(_(" is the user '%s' in the group '%s': yes"), user, group); } else { ticables_info(_(" is the user '%s' in the group '%s': no"), user, group); ticables_info(_(" => you should add your username at the group '%s' in '/etc/group'"), group); ticables_info(_(" => you will have to restart your session, too"), group); free(user); free(group); return -1; } free(user); free(group); } return 0; }
// Load a sequence of nodes until the specified terminator is found static ast_t* get_nodes(build_parser_t* builder, ast_token_id terminator) { assert(builder != NULL); ast_t* ast = NULL; ast_t* last_child = NULL; while(true) { ast_token_id id = get_token(builder); ast_t* child = NULL; bool is_type = false; if(id == terminator) { if(ast == NULL) build_error(builder, "Syntax error"); if(ast_id(ast) == TK_MINUS && ast_childcount(ast) == 1) ast_setid(ast, TK_UNARY_MINUS); return ast; } if(id == AT_ID) id = keyword_replace(builder); switch(id) { case AT_LPAREN: child = get_nodes(builder, AT_RPAREN); break; case AT_LSQUARE: child = get_type(builder, ast); is_type = true; break; case AT_ERROR: // Propogate break; case AT_STRING: case AT_TOKEN: child = ast_token(builder->token); save_token(builder); get_attributes(builder, child); break; case AT_ID: if(strcmp("id", token_string(builder->token)) == 0) return get_id(builder, ast); build_error(builder, "Unrecognised identifier \"%s\"", token_string(builder->token)); break; default: build_error(builder, "Syntax error"); break; } if(child == NULL) { // An error occurred and should already have been reported ast_free(ast); return NULL; } if(ast == NULL) { ast = child; last_child = NULL; } else if(is_type) { ast_settype(ast, child); } else { if(last_child == NULL) ast_add(ast, child); else ast_add_sibling(last_child, child); last_child = child; } } }