static unsigned long get_bytes_read(void) { char fname[128]; char entry[] = "read_bytes: %lu"; sprintf(fname, "/proc/%u/io", getpid()); return parse_entry(fname, entry); }
/** * parse_ifd_entries() extracts entries from an offset given its type. * Throws exif_failure_exception if the exif data state is determined to be invalid * such that further entry parsing would be invalid. * @Throws exif_failure_exception_t */ void entry_reader::parse_ifd_entries(ifd_type_t ifd_type, tiff_handle_t &tiff_handle, size_t ifd_offset, entry_list_t &entries) { uint16_t num_entries = tiff_ifd_reader::get_num_entries(tiff_handle, ifd_offset); #ifdef DEBUG cout << "exif_entry.parse_ifd_entries ifd type " << (uint32_t)ifd_type << ", num entries: " << num_entries << " from offset " << ifd_offset << "\n"; #endif if (num_entries == 0) { return; } // abort the EXIF if its number of entries is considered excessive // truncate excessive entries if (num_entries > OPT_MAX_IFD_ENTRIES) throw exif_failure_exception_t(); // parse each entry for (uint16_t i=0; i<num_entries; i++) { // quick sanity check - have we parsed more than 64K? if (tiff_handle.bytes_read >= OPT_MAX_EXIF_BYTES) throw exif_failure_exception_t(); uint32_t ifd_entry_offset = tiff_ifd_reader::get_entry_offset(ifd_offset, i); if (ifd_entry_offset + 12 > tiff_handle.sbuf->bufsize) throw exif_failure_exception_t(); #ifdef DEBUG cout << "exif_entry.parse_ifd_entries ifd_entry_offset: " << ifd_entry_offset << "\n"; #endif // parse the entry parse_entry(ifd_type, tiff_handle, ifd_entry_offset, entries); } }
static int parse_line(Parser* self, const char* line, size_t len) { unsigned i = 0; // Skip whitespace while (i < len && isspace(line[i])) i++; if (i == len) { // Blank line return 0; } switch (line[i]) { case ';': case '#': // Comment return 0; case '[': i++; return parse_section(self, line+i, len-i); default: if (!self->section) { self->error = "entry before section header"; return -1; } return parse_entry(self, line, len); } }
/* Convert one or more acl entries in string form to an acl_t */ acl_t parse_acl_entries(const char *input) { acl_t acl_input; acl_entry_t newent; char *inbuf; char *oinbuf; char **bufp, *entryv[ACL_MAX_ENTRIES]; #if 0 /* XXX acl_from_text(), when implemented, will presumably use the canonical * text representation format, which is what chmod should be using * We may need to add an entry number to the input */ /* Translate the user supplied ACL entry */ /* acl_input = acl_from_text(input); */ #else inbuf = malloc(MAX_ACL_TEXT_SIZE); if (inbuf == NULL) { // err(1, "malloc() failed"); fprintf(stderr, "chmod: malloc() failed: %s\n", strerror(errno)); pthread_exit(NULL); } strncpy(inbuf, input, MAX_ACL_TEXT_SIZE); inbuf[MAX_ACL_TEXT_SIZE - 1] = '\0'; if ((acl_input = acl_init(1)) == NULL) { // err(1, "acl_init() failed"); fprintf(stderr, "chmod: acl_init() failed: %s\n", strerror(errno)); pthread_exit(NULL); } oinbuf = inbuf; for (bufp = entryv; (*bufp = strsep(&oinbuf, "\n")) != NULL;) if (**bufp != '\0') { if (0 != acl_create_entry(&acl_input, &newent)) { // err(1, "acl_create_entry() failed"); fprintf(stderr, "chmod: acl_create_entry() failed: %s\n", strerror(errno)); pthread_exit(NULL); } if (0 != parse_entry(*bufp, newent)) { // errx(1, "Failed parsing entry '%s'", *bufp); fprintf(stderr, "chmod: Failed parsing entry '%s'\n", *bufp); pthread_exit(NULL); } if (++bufp >= &entryv[ACL_MAX_ENTRIES - 1]) { // errx(1, "Too many entries"); fprintf(stderr, "chmod: Too many entries\n"); pthread_exit(NULL); } } free(inbuf); return acl_input; #endif /* #if 0 */ }
int parse_block(int fd1,int fd2) { char tag; read(fd1,&tag,1); switch(GET_TAG(tag)) { case 0x00: parse_titleblock(fd1); break; case 0x01: parse_sheet(fd1); break; case 0x02: parse_component(fd1,fd2); break; case 0x03: parse_wire(fd1); break; case 0x04: parse_bus(fd1); break; case 0x05: parse_junction(fd1); break; case 0x06: parse_port(fd1); break; case 0x07: parse_label(fd1); break; case 0x08: parse_entry(fd1); break; case 0x09: parse_dashed(fd1); break; case 0x0a: parse_power(fd1); break; case 0x0b: parse_text(fd1); break; case 0x0c: parse_marker(fd1); break; case 0x0f: return 0; break; default: fprintf(stderr,"\nUnknown Block Tag\n"); exit(-1); break; } return 1; }
static int read_kld(char *filename, char *kldname) { struct mod_metadata md; struct elf_file ef; void **p, **orgp; int error, eftype, nmlen; long start, finish, entries; char kldmodname[MAXMODNAME + 1], cval[MAXMODNAME + 1], *cp; if (verbose || dflag) printf("%s\n", filename); error = ef_open(filename, &ef, verbose); if (error) { error = ef_obj_open(filename, &ef, verbose); if (error) { if (verbose) warnc(error, "elf_open(%s)", filename); return error; } } eftype = EF_GET_TYPE(&ef); if (eftype != EFT_KLD && eftype != EFT_KERNEL) { EF_CLOSE(&ef); return 0; } if (!dflag) { cp = strrchr(kldname, '.'); nmlen = (cp != NULL) ? cp - kldname : (int)strlen(kldname); if (nmlen > MAXMODNAME) nmlen = MAXMODNAME; strlcpy(kldmodname, kldname, nmlen); /* fprintf(fxref, "%s:%s:%d\n", kldmodname, kldname, 0);*/ } do { check(EF_LOOKUP_SET(&ef, MDT_SETNAME, &start, &finish, &entries)); check(EF_SEG_READ_ENTRY_REL(&ef, start, sizeof(*p) * entries, (void *)&p)); orgp = p; while(entries--) { check(EF_SEG_READ_REL(&ef, (Elf_Off)*p, sizeof(md), &md)); p++; check(EF_SEG_READ(&ef, (Elf_Off)md.md_cval, sizeof(cval), cval)); cval[MAXMODNAME] = '\0'; parse_entry(&md, cval, &ef, kldname); } if (error) warnc(error, "error while reading %s", filename); free(orgp); } while(0); EF_CLOSE(&ef); return error; }
void parse(int fd, t_map *map) { char buffer[BUFFER_SIZE + 1]; int char_count; char_count = read_input(fd, buffer); check_input_length(char_count); prepare_entry_for_split(buffer); parse_entry(buffer, map); }
static GNode * xmms_magic_add_node (GNode *tree, const gchar *s, GNode *prev_node) { xmms_magic_entry_t *entry; gpointer *data = tree->data; guint indent = 0, prev_indent; g_assert (s); XMMS_DBG ("adding magic spec to tree '%s'", (gchar *) data[0]); /* indent level is number of leading '>' characters */ while (*s == '>') { indent++; s++; } entry = parse_entry (s); if (!entry) { XMMS_DBG ("cannot parse magic entry"); return NULL; } if (!indent) { return g_node_append_data (tree, entry); } if (!prev_node) { XMMS_DBG ("invalid indent level"); xmms_magic_entry_free (entry); return NULL; } prev_indent = g_node_depth (prev_node) - 2; if (indent > prev_indent) { /* larger jumps are invalid */ if (indent != prev_indent + 1) { XMMS_DBG ("invalid indent level"); xmms_magic_entry_free (entry); return NULL; } return g_node_append_data (prev_node, entry); } else { while (indent < prev_indent) { prev_indent--; prev_node = prev_node->parent; } return g_node_insert_after (prev_node->parent, prev_node, g_node_new (entry)); } }
/* * Parses a file (in the format used by TAGDB and NOTEDB). * * fn File to parse * * spec The specification of the format for the database. This * consists of a series of identifier,type,offset tuples, ending * with a NULL identifier. * * store The database store, with offsets specified in spec. * Specify as NULL for the first file, and the current database * pointer for subsequent files. * * nitems The number of items in the database so far. * * store_size The size of each structure in store. * * default A default structure for the store, or NULL if none. * * Returns a new copy of the database ('store'), or NULL for failure. */ void *parse_file(char *fn, pf_spec *spec, void *store, int *nitems, int store_size, void *default_store) { int eof = 0; int count = *nitems; char *storep; FILE *fp; infile = fn; lineno = 0; fp = fopen(fn, "rb"); if (!fp) { parse_error("Could not open"); return NULL; } while (!eof) { switch (next_word(fp)) { case TOK_END: eof = 1; break; case TOK_NL: break; case TOK_ID: if (!(storep = find_store(store, store_size, count, word))) { count++; store = xrealloc(store, count * store_size); storep = (char *)store + (count-1) * store_size; if (default_store) memcpy(storep, default_store, store_size); else memset(storep, 0, store_size); *((char **)storep) = strdup(word); } eof = parse_entry(fp, spec, storep); break; default: parse_error("Syntax error - stopped parsing"); fclose(fp); return NULL; } } fclose(fp); *nitems = count; return store; }
void process_desktop_file(const char * filename) { FILE * f = fopen(filename, "r"); if (!f) die("could not open file \"%s\"\n", filename); if (!parse_entry(f)) die("file %s was invalid\n", filename); fclose(f); if (shell) { char * args[] = { SHELL, "-c", progpath, NULL }; if (execvp(args[0], args) == -1) die("autorun: exec: %s (%d)\n", strerror(errno), errno); } char ** args = (char**)malloc(sizeof(char**)); int argc = 0; char * next = NULL; int i = 0, j; while(sscanf(progpath+i, "%ms%n", &next, &j)>0) { args = (char **)realloc((void*)args, sizeof(char**)*(argc+1)); args[argc] = next; args[argc+1] = NULL; argc++; i+=j; } if (argc==0) die("invalid Exec field value %s\n", progpath); if (execvp(args[0], args) == -1) die("could not exec program: %s (%d)\n", strerror(errno), errno); }
SdfNode* parse_document(ParserData* data) { SdfNode* root = new_valued_node(data->filename, strlen(data->filename)); // Parse children while (!data->eof) { SdfNode* child = parse_entry(data); if (child != NULL) { add_child(root, child); } else { // Syntax error in contents sdf_free_tree(root); return NULL; } } return root; }
/* Parse the contents of an ACL line. */ static struct acl_entry * parse_line(krb5_context context, const char *line, const char *fname) { struct acl_entry *entry = NULL; char *copy; char *client, *client_end, *ops, *ops_end, *target, *target_end, *rs, *end; const char *ws = "\t\n\f\v\r ,"; /* * Format: * entry ::= [<whitespace>] <principal> <whitespace> <opstring> * [<whitespace> <target> [<whitespace> <restrictions> * [<whitespace>]]] */ /* Make a copy and remove any trailing whitespace. */ copy = strdup(line); if (copy == NULL) return NULL; end = copy + strlen(copy); while (end > copy && isspace(end[-1])) *--end = '\0'; /* Find the beginning and end of each field. The end of restrictions is * the end of copy. */ client = copy + strspn(copy, ws); client_end = client + strcspn(client, ws); ops = client_end + strspn(client_end, ws); ops_end = ops + strcspn(ops, ws); target = ops_end + strspn(ops_end, ws); target_end = target + strcspn(target, ws); rs = target_end + strspn(target_end, ws); /* Terminate the first three fields. */ *client_end = *ops_end = *target_end = '\0'; /* The last two fields are optional; represent them as NULL if not present. * The first two fields are required. */ if (*target == '\0') target = NULL; if (*rs == '\0') rs = NULL; if (*client != '\0' && *ops != '\0') entry = parse_entry(context, client, ops, target, rs, line, fname); free(copy); return entry; }
void atom_parser::parse_feed(feed& f, xmlNode * rootNode) { if (!rootNode) throw exception(_("XML root node is NULL")); switch (f.rss_version) { case ATOM_0_3: ns = ATOM_0_3_URI; break; case ATOM_1_0: ns = ATOM_1_0_URI; break; case ATOM_0_3_NONS: ns = nullptr; break; default: ns = nullptr; break; } f.language = get_prop(rootNode, "lang"); globalbase = get_prop(rootNode, "base", XML_URI); for (xmlNode * node = rootNode->children; node != nullptr; node = node->next) { if (node_is(node, "title", ns)) { f.title = get_content(node); f.title_type = get_prop(node, "type"); if (f.title_type == "") f.title_type = "text"; } else if (node_is(node, "subtitle", ns)) { f.description = get_content(node); } else if (node_is(node, "link", ns)) { std::string rel = get_prop(node, "rel"); if (rel == "alternate") { f.link = newsbeuter::utils::absolute_url(globalbase, get_prop(node, "href")); } } else if (node_is(node, "updated", ns)) { f.pubDate = w3cdtf_to_rfc822(get_content(node)); } else if (node_is(node, "entry", ns)) { f.items.push_back(parse_entry(node)); } } }
int parse_map(char *filename) { FILE *fp; char *line; size_t len; size_t lineno = 0; char delim[] = { '\\', 0, 0 }; if (strcmp(filename, "-") == 0) fp = fdopen(0, "r"); else fp = fopen(filename, "r"); if (fp == NULL) { warn("%s", filename); return 0; } if (!isatty(fileno(fp)) && flock(fileno(fp), LOCK_SH|LOCK_NB) == -1) { if (errno == EWOULDBLOCK) warnx("%s is locked", filename); else warn("%s: flock", filename); fclose(fp); return 0; } while ((line = fparseln(fp, &len, &lineno, delim, 0)) != NULL) { if (! parse_entry(line, len, lineno)) { free(line); fclose(fp); return 0; } free(line); } fclose(fp); return 1; }
tsol_zcent_t * tsol_sgetzcent(const char *instr, int *errp, char **errstrp) { int err; m_label_t *slp; char *errstr; tsol_zcent_t *zc; const char *nextf; char *cp; char fieldbuf[1024]; /* * The user can specify NULL pointers for these. Make sure that we * don't have to deal with checking for NULL everywhere by just * pointing to our own variables if the user gives NULL. */ if (errp == NULL) errp = &err; if (errstrp == NULL) errstrp = &errstr; /* The default, unless we find a more specific error locus. */ *errstrp = (char *)instr; if ((zc = calloc(1, sizeof (*zc))) == NULL) { *errp = LTSNET_SYSERR; return (NULL); } /* First, parse off the zone name. */ instr = parse_entry(zc->zc_name, sizeof (zc->zc_name), instr, "#;:\n"); if (zc->zc_name[0] == '\0') { *errstrp = (char *)instr; if (*instr == '\0' || *instr == '#' || *instr == '\n') *errp = LTSNET_EMPTY; else if (*instr == ':') *errp = LTSNET_NO_NAME; else *errp = LTSNET_ILL_NAME; goto err_ret; } if (*instr != ':') { *errstrp = (char *)instr; if (*instr == '=' || *instr == ';') *errp = LTSNET_ILL_NAME; else *errp = LTSNET_ILL_ENTRY; goto err_ret; } instr++; /* Field two: parse off the label. */ nextf = parse_entry(fieldbuf, sizeof (fieldbuf), instr, "#;:\n"); if (*nextf != ':') { *errstrp = (char *)nextf; *errp = LTSNET_ILL_ENTRY; goto err_ret; } if (fieldbuf[0] == '\0') { *errstrp = (char *)instr; *errp = LTSNET_NO_LABEL; goto err_ret; } slp = &zc->zc_label; if (str_to_label(fieldbuf, &slp, MAC_LABEL, L_NO_CORRECTION, NULL) != 0) { *errstrp = (char *)instr; *errp = LTSNET_ILL_LABEL; goto err_ret; } instr = nextf + 1; /* The kernel will apply the system doi to the zone label later */ zc->zc_doi = 0; /* Field three: get match flag */ errno = 0; zc->zc_match = (uchar_t)strtol(instr, &cp, 0); if (errno != 0 || (*cp != ':' && *cp != '\0')) { *errp = LTSNET_ILL_FLAG; *errstrp = (char *)instr; goto err_ret; } if (*cp != ':') { *errp = LTSNET_ILL_VALDELIM; *errstrp = cp; goto err_ret; } instr = cp + 1; /* Field four: get zone-specific MLP list. */ nextf = parse_entry(fieldbuf, sizeof (fieldbuf), instr, "#:\n"); if (*nextf != ':') { *errstrp = (char *)nextf; *errp = LTSNET_ILL_ENTRY; goto err_ret; } if (!parse_mlp_list(&zc->zc_private_mlp, fieldbuf, errp, errstrp)) { *errstrp = (char *)instr + (*errstrp - fieldbuf); goto err_ret; } instr = nextf + 1; /* Field five: get global MLP list. */ nextf = parse_entry(fieldbuf, sizeof (fieldbuf), instr, "#:\n"); if (*nextf != '\0' && *nextf != '#' && !isspace(*nextf)) { *errstrp = (char *)nextf; *errp = LTSNET_ILL_ENTRY; goto err_ret; } if (!parse_mlp_list(&zc->zc_shared_mlp, fieldbuf, errp, errstrp)) { *errstrp = (char *)instr + (*errstrp - fieldbuf); goto err_ret; } return (zc); err_ret: err = errno; tsol_freezcent(zc); errno = err; return (NULL); }
SdfNode* parse_entry(ParserData* data) { // First try to parse a label. char* label; int length = consume_label(data, &label); if (length == 0) { // We did not find a label! return error(data, EXPECTED_LABEL); } // Create the node for this element SdfNode* element = new_valued_node(label, length); // Now try to get a { or : if (consume(data, '{')) { // This entry is a struct-valued entry // End the current line if (!next_line(data)) { sdf_free_tree(element); return error(data, EXPECTED_END_OF_LINE); } // Parse children until the closing bracket is found. while (!consume(data, '}')) { SdfNode* child = parse_entry(data); if (child != NULL) { add_child(element, child); } else { // Syntax error in contents sdf_free_tree(element); return NULL; } } } else if (consume(data, ':')) { // This entry is a single-valued entry // Consume leading white space consume_whitespace(data); // Try to get a simple or quoted string SdfNode* value; if (data->line[data->column] == '"') { // Quoted string value = consume_quoted_string(data); } else { // Simple string char* string; length = consume_label(data, &string); value = new_valued_node(string, length); } add_child(element, value); } else { // Failed to get a { or : sdf_free_tree(element); return error(data, EXPECTED_ENTRY); } // And we need a final newline, except when we are at the end of the file. if (!next_line(data) && !data->eof) { // Encountered something else than a newline or EOF sdf_free_tree(element); return error(data, EXPECTED_END_OF_LINE); } return element; }
/* * Get a service entry. Steps: * * 1. Parse entry attributes * 2. Determine service id * 3. Insert entry in table */ static void get_service_entry( int fd, pset_h sconfs, const char *name, struct service_config *defaults ) { struct service_config *scp ; const char *func = "get_service_entry" ; scp = sc_alloc( name ) ; if ( scp == NULL ) { skip_entry( fd ) ; return ; } /* Now fill in default attributes if given. */ if ( SC_SPECIFIED( defaults, A_LOG_ON_SUCCESS ) && ! SC_IS_PRESENT( scp, A_LOG_ON_SUCCESS) ) fill_attribute( A_LOG_ON_SUCCESS, scp, defaults ) ; if ( SC_SPECIFIED( defaults, A_LOG_ON_FAILURE ) && ! SC_IS_PRESENT( scp, A_LOG_ON_FAILURE ) ) fill_attribute( A_LOG_ON_FAILURE, scp, defaults ) ; if ( SC_SPECIFIED( defaults, A_ONLY_FROM ) && ! SC_IS_PRESENT( scp, A_ONLY_FROM ) ) fill_attribute( A_ONLY_FROM, scp, defaults ) ; if ( SC_SPECIFIED( defaults, A_NO_ACCESS ) && ! SC_IS_PRESENT( scp, A_NO_ACCESS ) ) fill_attribute( A_NO_ACCESS, scp, defaults ) ; if ( SC_SPECIFIED( defaults, A_PASSENV ) && ! SC_IS_PRESENT( scp, A_PASSENV ) ) fill_attribute( A_PASSENV, scp, defaults ) ; if ( SC_SPECIFIED( defaults, A_ACCESS_TIMES ) && ! SC_IS_PRESENT( scp, A_ACCESS_TIMES ) ) fill_attribute( A_ACCESS_TIMES, scp, defaults ) ; if ( SC_SPECIFIED( defaults, A_BANNER ) && ! SC_IS_PRESENT( scp, A_BANNER ) ) fill_attribute( A_BANNER, scp, defaults ) ; if ( SC_SPECIFIED( defaults, A_BANNER_SUCCESS ) && ! SC_IS_PRESENT( scp, A_BANNER_SUCCESS ) ) fill_attribute( A_BANNER_SUCCESS, scp, defaults ) ; if ( SC_SPECIFIED( defaults, A_BANNER_FAIL ) && ! SC_IS_PRESENT( scp, A_BANNER_FAIL ) ) fill_attribute( A_BANNER_FAIL, scp, defaults ) ; if ( parse_entry( SERVICE_ENTRY, fd, scp ) == FAILED ) { sc_free( scp ) ; skip_entry( fd ) ; return ; } /* * If no service id was specified, set it equal to the service name */ if ( ! SC_SPECIFIED( scp, A_ID ) ) { if ( (SC_ID(scp) = new_string( SC_NAME(scp) )) ) SC_PRESENT( scp, A_ID ) ; else { out_of_memory( func ) ; sc_free( scp ) ; return ; } } if ( ! (pset_add( sconfs, scp )) ) { out_of_memory( func ) ; sc_free( scp ) ; return ; } }
/* * Read the configuration file (descriptor fd) and place all * services found there in the configuration. */ void parse_conf_file( int fd, struct configuration *confp, const char *filename) { pset_h sconfs = CNF_SERVICE_CONFS( confp ) ; struct service_config *default_config = CNF_DEFAULTS( confp ) ; boolean_e found_defaults = NO ; struct service_config default_default_config ; const char *func = "parse_conf_file" ; int incfd; line_count = 0 ; current_file = filename; CLEAR( default_default_config ) ; for ( ;; ) { entry_e entry_type ; char *service_name = NULL; /* * if find_next_entry is successful, service_name * will point to malloc'ed memory */ entry_type = find_next_entry( fd, &service_name ) ; switch ( entry_type ) { case INCLUDE_ENTRY: { int saved_line_count = line_count; incfd = open(service_name, O_RDONLY); if( incfd < 0 ) { parsemsg( LOG_ERR, func, "Unable to open included configuration file: %s", service_name); break; } parsemsg( LOG_DEBUG,func, "Reading included configuration file: %s",service_name); parse_conf_file(incfd, confp, service_name); /* * parse_conf_file eventually calls Srdline, try Sclosing it * to unmmap memory. */ Sclose(incfd); /* Restore since we've returned from included file */ current_file = filename; line_count = saved_line_count; } break; case INCLUDEDIR_ENTRY: { int saved_line_count = line_count; handle_includedir(service_name, confp); current_file = filename; line_count = saved_line_count; } break; case SERVICE_ENTRY: get_service_entry( fd, sconfs, service_name, default_config ) ; break ; case DEFAULTS_ENTRY: if ( found_defaults == YES ) { parsemsg( LOG_ERR, func, "only 1 defaults entry is allowed. This entry will be ignored" ) ; skip_entry( fd ) ; } else if ( parse_entry( DEFAULTS_ENTRY, fd, default_config ) == OK ) { found_defaults = YES ; /* * We must check bind_address to see if it was deferred. */ if (SC_SPECIFIED( default_config, A_BIND) && SC_BIND_ADDR(default_config) == NULL) M_CLEAR( default_config->sc_specified_attributes, A_BIND ) ; } break ; case BAD_ENTRY: skip_entry( fd ) ; break ; case NO_ENTRY: return ; } if (service_name) free(service_name); } }
static void edit_index(int natoms, t_atoms *atoms, rvec *x, t_blocka *block, char ***gn, gmx_bool bVerbose) { static char **atnames, *ostring; static gmx_bool bFirst = TRUE; char inp_string[STRLEN], *string; char gname[STRLEN], gname1[STRLEN], gname2[STRLEN]; int i, i0, i1, sel_nr, sel_nr2, newgroup; atom_id nr, nr1, nr2, *index, *index1, *index2; gmx_bool bAnd, bOr, bPrintOnce; if (bFirst) { bFirst = FALSE; snew(atnames, MAXNAMES); for (i = 0; i < MAXNAMES; i++) { snew(atnames[i], NAME_LEN+1); } } string = NULL; snew(index, natoms); snew(index1, natoms); snew(index2, natoms); newgroup = NOTSET; bPrintOnce = TRUE; do { gname1[0] = '\0'; if (bVerbose || bPrintOnce || newgroup != NOTSET) { printf("\n"); if (bVerbose || bPrintOnce || newgroup == NOTSET) { i0 = 0; i1 = block->nr; } else { i0 = newgroup; i1 = newgroup+1; } for (i = i0; i < i1; i++) { printf("%3d %-20s: %5d atoms\n", i, (*gn)[i], block->index[i+1]-block->index[i]); } newgroup = NOTSET; } if (bVerbose || bPrintOnce) { printf("\n"); printf(" nr : group ! 'name' nr name 'splitch' nr Enter: list groups\n"); printf(" 'a': atom & 'del' nr 'splitres' nr 'l': list residues\n"); printf(" 't': atom type | 'keep' nr 'splitat' nr 'h': help\n"); printf(" 'r': residue 'res' nr 'chain' char\n"); printf(" \"name\": group 'case': case %s 'q': save and quit\n", bCase ? "insensitive" : "sensitive "); printf(" 'ri': residue index\n"); bPrintOnce = FALSE; } printf("\n"); printf("> "); if (NULL == fgets(inp_string, STRLEN, stdin)) { gmx_fatal(FARGS, "Error reading user input"); } inp_string[strlen(inp_string)-1] = 0; printf("\n"); string = inp_string; while (string[0] == ' ') { string++; } ostring = string; nr = 0; if (string[0] == 'h') { printf(" nr : selects an index group by number or quoted string.\n"); printf(" The string is first matched against the whole group name,\n"); printf(" then against the beginning and finally against an\n"); printf(" arbitrary substring. A multiple match is an error.\n"); printf(" 'a' nr1 [nr2 ...] : selects atoms, atom numbering starts at 1.\n"); printf(" 'a' nr1 - nr2 : selects atoms in the range from nr1 to nr2.\n"); printf(" 'a' name1[*] [name2[*] ...] : selects atoms by name(s), '?' matches any char,\n"); printf(" wildcard '*' allowed at the end of a name.\n"); printf(" 't' type1[*] [type2[*] ...] : as 'a', but for type, run input file required.\n"); printf(" 'r' nr1[ic1] [nr2[ic2] ...] : selects residues by number and insertion code.\n"); printf(" 'r' nr1 - nr2 : selects residues in the range from nr1 to nr2.\n"); printf(" 'r' name1[*] [name2[*] ...] : as 'a', but for residue names.\n"); printf(" 'ri' nr1 - nr2 : selects residue indices, 1-indexed, (as opposed to numbers) in the range from nr1 to nr2.\n"); printf(" 'chain' ch1 [ch2 ...] : selects atoms by chain identifier(s),\n"); printf(" not available with a .gro file as input.\n"); printf(" ! : takes the complement of a group with respect to all\n"); printf(" the atoms in the input file.\n"); printf(" & | : AND and OR, can be placed between any of the options\n"); printf(" above, the input is processed from left to right.\n"); printf(" 'name' nr name : rename group nr to name.\n"); printf(" 'del' nr1 [- nr2] : deletes one group or groups in the range from nr1 to nr2.\n"); printf(" 'keep' nr : deletes all groups except nr.\n"); printf(" 'case' : make all name compares case (in)sensitive.\n"); printf(" 'splitch' nr : split group into chains using CA distances.\n"); printf(" 'splitres' nr : split group into residues.\n"); printf(" 'splitat' nr : split group into atoms.\n"); printf(" 'res' nr : interpret numbers in group as residue numbers\n"); printf(" Enter : list the currently defined groups and commands\n"); printf(" 'l' : list the residues.\n"); printf(" 'h' : show this help.\n"); printf(" 'q' : save and quit.\n"); printf("\n"); printf(" Examples:\n"); printf(" > 2 | 4 & r 3-5\n"); printf(" selects all atoms from group 2 and 4 that have residue numbers 3, 4 or 5\n"); printf(" > a C* & !a C CA\n"); printf(" selects all atoms starting with 'C' but not the atoms 'C' and 'CA'\n"); printf(" > \"protein\" & ! \"backb\"\n"); printf(" selects all atoms that are in group 'protein' and not in group 'backbone'\n"); if (bVerbose) { printf("\npress Enter "); getchar(); } } else if (strncmp(string, "del", 3) == 0) { string += 3; if (parse_int(&string, &sel_nr)) { while (string[0] == ' ') { string++; } if (string[0] == '-') { string++; parse_int(&string, &sel_nr2); } else { sel_nr2 = NOTSET; } while (string[0] == ' ') { string++; } if (string[0] == '\0') { remove_group(sel_nr, sel_nr2, block, gn); } else { printf("\nSyntax error: \"%s\"\n", string); } } } else if (strncmp(string, "keep", 4) == 0) { string += 4; if (parse_int(&string, &sel_nr)) { remove_group(sel_nr+1, block->nr-1, block, gn); remove_group(0, sel_nr-1, block, gn); } } else if (strncmp(string, "name", 4) == 0) { string += 4; if (parse_int(&string, &sel_nr)) { if ((sel_nr >= 0) && (sel_nr < block->nr)) { sscanf(string, "%s", gname); sfree((*gn)[sel_nr]); (*gn)[sel_nr] = strdup(gname); } } } else if (strncmp(string, "case", 4) == 0) { bCase = !bCase; printf("Switched to case %s\n", bCase ? "sensitive" : "insensitive"); } else if (string[0] == 'v') { bVerbose = !bVerbose; printf("Turned verbose %s\n", bVerbose ? "on" : "off"); } else if (string[0] == 'l') { if (check_have_atoms(atoms, ostring) ) { list_residues(atoms); } } else if (strncmp(string, "splitch", 7) == 0) { string += 7; if (check_have_atoms(atoms, ostring) && parse_int(&string, &sel_nr) && (sel_nr >= 0) && (sel_nr < block->nr)) { split_chain(atoms, x, sel_nr, block, gn); } } else if (strncmp(string, "splitres", 8) == 0) { string += 8; if (check_have_atoms(atoms, ostring) && parse_int(&string, &sel_nr) && (sel_nr >= 0) && (sel_nr < block->nr)) { split_group(atoms, sel_nr, block, gn, FALSE); } } else if (strncmp(string, "splitat", 7) == 0) { string += 7; if (check_have_atoms(atoms, ostring) && parse_int(&string, &sel_nr) && (sel_nr >= 0) && (sel_nr < block->nr)) { split_group(atoms, sel_nr, block, gn, TRUE); } } else if (string[0] == '\0') { bPrintOnce = TRUE; } else if (string[0] != 'q') { nr1 = -1; nr2 = -1; if (parse_entry(&string, natoms, atoms, block, gn, &nr, index, gname)) { do { while (string[0] == ' ') { string++; } bAnd = FALSE; bOr = FALSE; if (string[0] == '&') { bAnd = TRUE; } else if (string[0] == '|') { bOr = TRUE; } if (bAnd || bOr) { string++; nr1 = nr; for (i = 0; i < nr; i++) { index1[i] = index[i]; } strcpy(gname1, gname); if (parse_entry(&string, natoms, atoms, block, gn, &nr2, index2, gname2)) { if (bOr) { or_groups(nr1, index1, nr2, index2, &nr, index); sprintf(gname, "%s_%s", gname1, gname2); } else { and_groups(nr1, index1, nr2, index2, &nr, index); sprintf(gname, "%s_&_%s", gname1, gname2); } } } } while (bAnd || bOr); } while (string[0] == ' ') { string++; } if (string[0]) { printf("\nSyntax error: \"%s\"\n", string); } else if (nr > 0) { copy2block(nr, index, block); srenew(*gn, block->nr); newgroup = block->nr-1; (*gn)[newgroup] = strdup(gname); } else { printf("Group is empty\n"); } } } while (string[0] != 'q'); sfree(index); sfree(index1); sfree(index2); }
int do_lookup1( char *mapname, char *key, char *subdir, char *mapopts, char *path, uint_t isdirect, uid_t uid, autofs_action_t *action, struct linka *linkp) { struct mapline ml; struct mapent *mapents = NULL; int err; struct autofs_rddir_cache *rdcp; int found = 0; bool_t iswildcard = FALSE; bool_t isrestricted = hasrestrictopt(mapopts); char *stack[STACKSIZ]; char **stkptr = stack; /* * Default action is for no work to be done by kernel AUTOFS. */ *action = AUTOFS_NONE; /* * Is there a cache for this map? */ rw_rdlock(&autofs_rddir_cache_lock); err = autofs_rddir_cache_lookup(mapname, &rdcp); if (!err && rdcp->full) { rw_unlock(&autofs_rddir_cache_lock); /* * Try to lock readdir cache entry for reading, if * the entry can not be locked, then avoid blocking * and go to the name service. I'm assuming it is * faster to go to the name service than to wait for * the cache to be populated. */ if (rw_tryrdlock(&rdcp->rwlock) == 0) { found = (rddir_entry_lookup(key, rdcp->entp) != NULL); rw_unlock(&rdcp->rwlock); } } else rw_unlock(&autofs_rddir_cache_lock); if (!err) { /* * release reference on cache entry */ mutex_lock(&rdcp->lock); rdcp->in_use--; assert(rdcp->in_use >= 0); mutex_unlock(&rdcp->lock); } if (found) return (0); /* * entry not found in cache, try the name service now */ err = 0; /* initialize the stack of open files for this thread */ stack_op(INIT, NULL, stack, &stkptr); err = getmapent(key, mapname, &ml, stack, &stkptr, &iswildcard, isrestricted); if (err == 0) /* call parser w default mount_access = TRUE */ mapents = parse_entry(key, mapname, mapopts, &ml, subdir, isdirect, TRUE); /* * Now we indulge in a bit of hanky-panky. * If the entry isn't found in the map and the * name begins with an "=" then we assume that * the name is an undocumented control message * for the daemon. This is accessible only * to superusers. */ if (mapents == NULL && *action == AUTOFS_NONE) { if (*key == '=' && uid == 0) { if (isdigit(*(key+1))) { /* * If next character is a digit * then set the trace level. */ trace = atoi(key+1); trace_prt(1, "Automountd: trace level = %d\n", trace); } else if (*(key+1) == 'v') { /* * If it's a "v" then * toggle verbose mode. */ verbose = !verbose; trace_prt(1, "Automountd: verbose %s\n", verbose ? "on" : "off"); } } err = ENOENT; goto done; } /* * Each mapent in the list describes a mount to be done. * Since I'm only doing a lookup, I only care whether a mapentry * was found or not. The mount will be done on a later RPC to * do_mount1. */ if (mapents == NULL && *action == AUTOFS_NONE) err = ENOENT; done: if (mapents) free_mapent(mapents); if (*action == AUTOFS_NONE && (iswildcard == TRUE)) { *action = AUTOFS_MOUNT_RQ; } if (trace > 1) { trace_prt(1, " do_lookup1: action=%d wildcard=%s error=%d\n", *action, iswildcard ? "TRUE" : "FALSE", err); } return (err); }
int save_old_pass (pam_handle_t *pamh, const char *user, uid_t uid, const char *oldpass, int howmany, int debug UNUSED) { char opasswd_tmp[] = TMP_PASSWORDS_FILE; struct stat opasswd_stat; FILE *oldpf, *newpf; int newpf_fd; int do_create = 0; int retval = PAM_SUCCESS; char *buf = NULL; size_t buflen = 0; int found = 0; if (howmany <= 0) return PAM_SUCCESS; if (oldpass == NULL || *oldpass == '\0') return PAM_SUCCESS; if ((oldpf = fopen (OLD_PASSWORDS_FILE, "r")) == NULL) { if (errno == ENOENT) { pam_syslog (pamh, LOG_NOTICE, "Creating %s", OLD_PASSWORDS_FILE); do_create = 1; } else { pam_syslog (pamh, LOG_ERR, "Cannot open %s: %m", OLD_PASSWORDS_FILE); return PAM_AUTHTOK_ERR; } } else if (fstat (fileno (oldpf), &opasswd_stat) < 0) { pam_syslog (pamh, LOG_ERR, "Cannot stat %s: %m", OLD_PASSWORDS_FILE); fclose (oldpf); return PAM_AUTHTOK_ERR; } /* Open a temp passwd file */ newpf_fd = mkstemp (opasswd_tmp); if (newpf_fd == -1) { pam_syslog (pamh, LOG_ERR, "Cannot create %s temp file: %m", OLD_PASSWORDS_FILE); if (oldpf) fclose (oldpf); return PAM_AUTHTOK_ERR; } if (do_create) { if (fchmod (newpf_fd, S_IRUSR|S_IWUSR) != 0) pam_syslog (pamh, LOG_ERR, "Cannot set permissions of %s temp file: %m", OLD_PASSWORDS_FILE); if (fchown (newpf_fd, 0, 0) != 0) pam_syslog (pamh, LOG_ERR, "Cannot set owner/group of %s temp file: %m", OLD_PASSWORDS_FILE); } else { if (fchmod (newpf_fd, opasswd_stat.st_mode) != 0) pam_syslog (pamh, LOG_ERR, "Cannot set permissions of %s temp file: %m", OLD_PASSWORDS_FILE); if (fchown (newpf_fd, opasswd_stat.st_uid, opasswd_stat.st_gid) != 0) pam_syslog (pamh, LOG_ERR, "Cannot set owner/group of %s temp file: %m", OLD_PASSWORDS_FILE); } newpf = fdopen (newpf_fd, "w+"); if (newpf == NULL) { pam_syslog (pamh, LOG_ERR, "Cannot fdopen %s: %m", opasswd_tmp); if (oldpf) fclose (oldpf); close (newpf_fd); retval = PAM_AUTHTOK_ERR; goto error_opasswd; } if (!do_create) while (!feof (oldpf)) { char *cp, *tmp, *save; #if defined(HAVE_GETLINE) ssize_t n = getline (&buf, &buflen, oldpf); #elif defined (HAVE_GETDELIM) ssize_t n = getdelim (&buf, &buflen, '\n', oldpf); #else ssize_t n; if (buf == NULL) { buflen = DEFAULT_BUFLEN; buf = malloc (buflen); if (buf == NULL) { fclose (oldpf); fclose (newpf); retval = PAM_BUF_ERR; goto error_opasswd; } } buf[0] = '\0'; fgets (buf, buflen - 1, oldpf); n = strlen (buf); #endif /* HAVE_GETLINE / HAVE_GETDELIM */ cp = buf; save = strdup (buf); /* Copy to write the original data back. */ if (save == NULL) { fclose (oldpf); fclose (newpf); retval = PAM_BUF_ERR; goto error_opasswd; } if (n < 1) break; tmp = strchr (cp, '#'); /* remove comments */ if (tmp) *tmp = '\0'; while (isspace ((int)*cp)) /* remove spaces and tabs */ ++cp; if (*cp == '\0') /* ignore empty lines */ goto write_old_data; if (cp[strlen (cp) - 1] == '\n') cp[strlen (cp) - 1] = '\0'; if (strncmp (cp, user, strlen (user)) == 0 && cp[strlen (user)] == ':') { /* We found the line we needed */ opwd entry; if (parse_entry (cp, &entry) == 0) { char *out = NULL; found = 1; /* Don't save the current password twice */ if (entry.old_passwords && entry.old_passwords[0] != '\0') { char *last = entry.old_passwords; cp = entry.old_passwords; entry.count = 1; /* Don't believe the count */ while ((cp = strchr (cp, ',')) != NULL) { entry.count++; last = ++cp; } /* compare the last password */ if (strcmp (last, oldpass) == 0) goto write_old_data; } else entry.count = 0; /* increase count. */ entry.count++; /* check that we don't remember to many passwords. */ while (entry.count > howmany && entry.count > 1) { char *p = strpbrk (entry.old_passwords, ","); if (p != NULL) entry.old_passwords = ++p; entry.count--; } if (entry.count == 1) { if (asprintf (&out, "%s:%s:%d:%s\n", entry.user, entry.uid, entry.count, oldpass) < 0) { free (save); retval = PAM_AUTHTOK_ERR; fclose (oldpf); fclose (newpf); goto error_opasswd; } } else { if (asprintf (&out, "%s:%s:%d:%s,%s\n", entry.user, entry.uid, entry.count, entry.old_passwords, oldpass) < 0) { free (save); retval = PAM_AUTHTOK_ERR; fclose (oldpf); fclose (newpf); goto error_opasswd; } } if (fputs (out, newpf) < 0) { free (out); free (save); retval = PAM_AUTHTOK_ERR; fclose (oldpf); fclose (newpf); goto error_opasswd; } free (out); } } else { write_old_data: if (fputs (save, newpf) < 0) { free (save); retval = PAM_AUTHTOK_ERR; fclose (oldpf); fclose (newpf); goto error_opasswd; } } free (save); } if (!found) { char *out; if (asprintf (&out, "%s:%d:1:%s\n", user, uid, oldpass) < 0) { retval = PAM_AUTHTOK_ERR; if (oldpf) fclose (oldpf); fclose (newpf); goto error_opasswd; } if (fputs (out, newpf) < 0) { free (out); retval = PAM_AUTHTOK_ERR; if (oldpf) fclose (oldpf); fclose (newpf); goto error_opasswd; } free (out); } if (oldpf) if (fclose (oldpf) != 0) { pam_syslog (pamh, LOG_ERR, "Error while closing old opasswd file: %m"); retval = PAM_AUTHTOK_ERR; fclose (newpf); goto error_opasswd; } if (fflush (newpf) != 0 || fsync (fileno (newpf)) != 0) { pam_syslog (pamh, LOG_ERR, "Error while syncing temporary opasswd file: %m"); retval = PAM_AUTHTOK_ERR; fclose (newpf); goto error_opasswd; } if (fclose (newpf) != 0) { pam_syslog (pamh, LOG_ERR, "Error while closing temporary opasswd file: %m"); retval = PAM_AUTHTOK_ERR; goto error_opasswd; } unlink (OLD_PASSWORDS_FILE".old"); if (link (OLD_PASSWORDS_FILE, OLD_PASSWORDS_FILE".old") != 0 && errno != ENOENT) pam_syslog (pamh, LOG_ERR, "Cannot create backup file of %s: %m", OLD_PASSWORDS_FILE); rename (opasswd_tmp, OLD_PASSWORDS_FILE); error_opasswd: unlink (opasswd_tmp); free (buf); return retval; }
/* Check, if the new password is already in the opasswd file. */ int check_old_pass (pam_handle_t *pamh, const char *user, const char *newpass, int debug) { int retval = PAM_SUCCESS; FILE *oldpf; char *buf = NULL; size_t buflen = 0; opwd entry; int found = 0; if ((oldpf = fopen (OLD_PASSWORDS_FILE, "r")) == NULL) { if (errno != ENOENT) pam_syslog (pamh, LOG_ERR, "Cannot open %s: %m", OLD_PASSWORDS_FILE); return PAM_SUCCESS; } while (!feof (oldpf)) { char *cp, *tmp; #if defined(HAVE_GETLINE) ssize_t n = getline (&buf, &buflen, oldpf); #elif defined (HAVE_GETDELIM) ssize_t n = getdelim (&buf, &buflen, '\n', oldpf); #else ssize_t n; if (buf == NULL) { buflen = DEFAULT_BUFLEN; buf = malloc (buflen); if (buf == NULL) return PAM_BUF_ERR; } buf[0] = '\0'; fgets (buf, buflen - 1, oldpf); n = strlen (buf); #endif /* HAVE_GETLINE / HAVE_GETDELIM */ cp = buf; if (n < 1) break; tmp = strchr (cp, '#'); /* remove comments */ if (tmp) *tmp = '\0'; while (isspace ((int)*cp)) /* remove spaces and tabs */ ++cp; if (*cp == '\0') /* ignore empty lines */ continue; if (cp[strlen (cp) - 1] == '\n') cp[strlen (cp) - 1] = '\0'; if (strncmp (cp, user, strlen (user)) == 0 && cp[strlen (user)] == ':') { /* We found the line we needed */ if (parse_entry (cp, &entry) == 0) { found = 1; break; } } } fclose (oldpf); if (found && entry.old_passwords) { const char delimiters[] = ","; char *running; char *oldpass; running = entry.old_passwords; do { oldpass = strsep (&running, delimiters); if (oldpass && strlen (oldpass) > 0 && compare_password(newpass, oldpass) ) { if (debug) pam_syslog (pamh, LOG_DEBUG, "New password already used"); retval = PAM_AUTHTOK_ERR; break; } } while (oldpass != NULL); } if (buf) free (buf); return retval; }
static unsigned long get_cached_size(void) { char entry[] = "Cached: %lu"; return parse_entry(meminfo_fname, entry); }
/* * Import authlist from the userspace */ static int write_authlist(struct authlist *authlist, void __user *buffer, size_t *lenp, loff_t *ppos) { struct authlist_entry *entries = NULL, *old_entries; char *memblk = NULL; int error = 0; int nentries; int ne; int terminal = -1; const char *p; /* ensure atomic transfer */ if (*ppos != 0) return -EINVAL; if (*lenp > AUTHLIST_LENGTH_LIMIT) return -EINVAL; memblk = kmalloc(*lenp + 1, GFP_KERNEL); if (memblk == NULL) return -ENOMEM; if (copy_from_user(memblk, buffer, *lenp)) error_out(-EFAULT); memblk[*lenp] = '\0'; nentries = count_entries(memblk); if (nentries == 0) error_out(-EINVAL); entries = kmalloc(sizeof(struct authlist_entry) * nentries, GFP_KERNEL); if (entries == NULL) error_out(-ENOMEM); for (p = memblk, ne = 0;; ne++) { /* skip leading whitespace */ while (is_ws(*p)) p++; /* reached the end of the string? */ if (*p == '\0') break; error = parse_entry(&p, entries + ne); if (error) goto out; switch (entries[ne].kind) { case AUTHLIST_KIND_EVERYBODY: case AUTHLIST_KIND_NOBODY: if (terminal != -1) error_out(-EINVAL); terminal = ne; break; default: break; } } /* * Last entry must be everybody/nobody. * Intermediate entry cannot be everybody/nobody. */ if (terminal != nentries - 1) error_out(-EINVAL); down_write(&authlist->rws); old_entries = authlist->entries; authlist->nentries = nentries; authlist->entries = entries; up_write(&authlist->rws); kfree(old_entries); entries = NULL; *ppos += *lenp; out: kfree(memblk); kfree(entries); return error; }
/* update the directory with the archive */ static gboolean update(char *path) { struct rdup *rdup_entry; size_t line, i, pathsize; size_t pathlen; char *buf, *pathbuf, *n, *p; char delim; gboolean ok; GHashTable *uidhash; /* holds username -> uid */ GHashTable *gidhash; /* holds groupname -> gid */ p = NULL; buf = g_malloc(BUFSIZE + 1); pathbuf = g_malloc(BUFSIZE + 1); i = BUFSIZE; delim = '\n'; line = 0; ok = TRUE; uidhash = g_hash_table_new(g_str_hash, g_str_equal); gidhash = g_hash_table_new(g_str_hash, g_str_equal); if (path) pathlen = strlen(path); else pathlen = 0; while ((rdup_getdelim(&buf, &i, delim, stdin)) != -1) { line++; n = strrchr(buf, '\n'); if (n) *n = '\0'; if (!(rdup_entry = parse_entry(buf, line))) { /* msgs from entry.c */ exit(EXIT_FAILURE); } /* we have a valid entry, read the filename */ pathsize = fread(pathbuf, sizeof(char), rdup_entry->f_name_size, stdin); if (pathsize != rdup_entry->f_name_size) { msg(_ ("Reported name size (%zd) does not match actual name size (%zd)"), rdup_entry->f_name_size, pathsize); exit(EXIT_FAILURE); } pathbuf[pathsize] = '\0'; if (pathbuf[0] != '/') { msg(_("Pathname does not start with /: `%s\'"), pathbuf); exit(EXIT_FAILURE); } rdup_entry->f_name = pathbuf; /* extract target from rdup_entry */ if (S_ISLNK(rdup_entry->f_mode) || rdup_entry->f_lnk) { // filesize is spot where to cut rdup_entry->f_name[rdup_entry->f_size] = '\0'; rdup_entry->f_target = rdup_entry->f_name + rdup_entry->f_size + 4; } else { rdup_entry->f_target = NULL; } /* strippath must be inserted here */ if (opt_strip) strippath(rdup_entry); if (opt_path_strip) strippathname(rdup_entry); if (!rdup_entry->f_name) p = NULL; else { /* avoid // at the beginning */ if ((pathlen == 1 && path[0] == '/') || pathlen == 0) { p = g_strdup(rdup_entry->f_name); } else { g_free(p); p = g_strdup_printf("%s%s", path, rdup_entry->f_name); rdup_entry->f_name_size += pathlen; if (S_ISLNK(rdup_entry->f_mode) || rdup_entry->f_lnk) rdup_entry->f_size += pathlen; } } rdup_entry->f_name = p; if (mk_obj(stdin, path, rdup_entry, uidhash, gidhash) == FALSE) ok = FALSE; g_free(rdup_entry->f_user); g_free(rdup_entry->f_group); g_free(rdup_entry); } /* post-process hardlinks */ if (mk_hlink(hlink_list) == FALSE) ok = FALSE; g_free(buf); g_free(pathbuf); return ok; }
void read_v23_status() { FILE *fp; char buffer[MAX_CHARS_PER_LINE]; struct status_dot_dat_entry ent; int i, host_stamp, service_stamp, eof; #ifdef _DEBUG_ debug("read_v23_status()..."); debug("status file is %s",STATUS_DAT_FILE); #endif /*--------------------------------------------------------*/ mvaddstr(LINES-1-pad,pad,"reading status.dat..."); refresh(); /*--------------------------------------------------------*/ if ((fp = fopen(STATUS_DAT_FILE, "r")) == NULL) { endwin(); fprintf(stderr,"fatal error: fopen %s ",STATUS_DAT_FILE); perror("failed"); exit(1); } line = 0; /*--------------------------------------------------------*/ /* read last update */ fgets(buffer,sizeof(buffer),fp); line++; while ( !feof(fp) && strcmp(buffer,"info {\n") != 0 ) { fgets(buffer,sizeof(buffer),fp); line++; } if ( strcmp(buffer,"info {\n") != 0 ) { endwin(); printf("fatal error: %s: could not find \"info\" stanza\n", STATUS_DAT_FILE); exit(1); } fgets(buffer,sizeof(buffer),fp); line++; parse_entry(&ent,buffer); while ( !feof(fp) && strcmp(ent.lhs,"created") != 0 ) { fgets(buffer,sizeof(buffer),fp); line++; parse_entry(&ent,buffer); } if ( !strcmp(ent.lhs,"created") ) { last_update_int = atoi(ent.rhs); strncpy(last_update,ctime((time_t *)&last_update_int),19); last_update[20] = '\0'; } else { endwin(); printf("fatal error: %s: could not find \"created\" entry\n", STATUS_DAT_FILE); exit(1); } #ifdef _DEBUG_ debug("last update is %s (%d)",last_update,last_update_int); #endif /*--------------------------------------------------------*/ num_okay = num_warn = num_crit = 0; host_list_size = service_list_size = 0; num_up = num_down = 0; while ( fgets(buffer,sizeof(buffer),fp) != NULL ) { line++; parse_entry(&ent,buffer); if ( !strcmp(ent.lhs,"fail") ) { continue; } /*--------------------------------------------------------*/ /* HOST object... */ if ( (!strcmp("host",ent.lhs)) || (!strcmp("hoststatus",ent.lhs)) ) { /*--------------------*/ /* HOST_NAME... */ fgets(buffer,sizeof(buffer),fp); line++; parse_entry(&ent,buffer); while ( !feof(fp) && strcmp(ent.lhs,"host_name") != 0 ) { fgets(buffer,sizeof(buffer),fp); line++; parse_entry(&ent,buffer); if ( !strcmp(ent.lhs,"fail") ) { endwin(); printf("fatal error: %s: could not find \"host_name\" for host stanza preceeding line %d\n", STATUS_DAT_FILE, line); exit(1); } } if ( strcmp(ent.lhs,"host_name") ) { endwin(); printf("fatal error: %s: could not find \"host_name\" for host stanza preceeding line %d\n", STATUS_DAT_FILE, line); exit(1); } host_list[host_list_size][HOST_NAME] = malloc(strlen(ent.rhs)+1); strncpy(host_list[host_list_size][HOST_NAME],ent.rhs,strlen(ent.rhs)+1); #ifdef _DEBUG_ debug("HOST NUMBER %d...", host_list_size); debug(" host_name is \"%s\"",host_list[host_list_size][HOST_NAME]); #endif /*--------------------*/ /* STATUS... */ fgets(buffer,sizeof(buffer),fp); line++; parse_entry(&ent,buffer); while ( !feof(fp) && strcmp(ent.lhs,"current_state") != 0 ) { fgets(buffer,sizeof(buffer),fp); line++; parse_entry(&ent,buffer); if ( !strcmp(ent.lhs,"fail") ) { endwin(); printf("fatal error: %s: could not find \"current_state\" for host stanza preceeding line %d\n", STATUS_DAT_FILE, line); exit(1); } } if ( strcmp(ent.lhs,"current_state") ) { endwin(); printf("fatal error: %s: could not find \"current_state\" for host stanza preceeding line %d\n", STATUS_DAT_FILE, line); exit(1); } switch(ent.rhs[0]) { case NAGIOS_HOST_UP: host_list[host_list_size][STATUS] = malloc(3); strncpy(host_list[host_list_size][STATUS],"UP",3); break; case NAGIOS_HOST_DOWN: host_list[host_list_size][STATUS] = malloc(5); strncpy(host_list[host_list_size][STATUS],"DOWN",5); break; } #ifdef _DEBUG_ debug(" current_state is %s", host_list[host_list_size][STATUS]); #endif /*--------------------*/ /* PLUGIN_OUTPUT... */ fgets(buffer,sizeof(buffer),fp); line++; parse_entry(&ent,buffer); while ( !feof(fp) && strcmp(ent.lhs,"plugin_output") != 0 ) { fgets(buffer,sizeof(buffer),fp); line++; parse_entry(&ent,buffer); if ( !strcmp(ent.lhs,"fail") ) { endwin(); printf("fatal error: %s: could not find \"plugin_output\" for host stanza preceeding line %d\n", STATUS_DAT_FILE, line); exit(1); } } if ( strcmp(ent.lhs,"plugin_output") ) { endwin(); printf("fatal error: %s: could not find \"plugin_output\" for host stanza preceeding line %d\n", STATUS_DAT_FILE, line); exit(1); } host_list[host_list_size][PLUGIN_OUTPUT] = malloc(strlen(ent.rhs)+1); strncpy(host_list[host_list_size][PLUGIN_OUTPUT],ent.rhs,strlen(ent.rhs)+1); perl_hook(HOST_PLUGIN_HOOK,host_list[host_list_size][PLUGIN_OUTPUT]); #ifdef _DEBUG_ debug(" raw plugin_output is \"%s\"",ent.rhs); debug(" munged plugin_output is \"%s\"",host_list[host_list_size][PLUGIN_OUTPUT]); #endif /*--------------------*/ /* LAST_STATE_CHANGE... */ fgets(buffer,sizeof(buffer),fp); line++; parse_entry(&ent,buffer); while ( !feof(fp) && strcmp(ent.lhs,"last_state_change") != 0 ) { fgets(buffer,sizeof(buffer),fp); line++; parse_entry(&ent,buffer); if ( !strcmp(ent.lhs,"fail") ) { endwin(); printf("fatal error: %s: could not find \"last_state_change\" for host stanza preceeding line %d\n", STATUS_DAT_FILE, line); exit(1); } } if ( strcmp(ent.lhs,"last_state_change") ) { endwin(); printf("fatal error: %s: could not find \"last_state_change\" for host stanza preceeding line %d\n", STATUS_DAT_FILE, line); exit(1); } sscanf(ent.rhs,"%d",&host_stamp); if ( (host_stamp == 0) && (host_list[host_list_size][PLUGIN_OUTPUT][0] == '\0') ) { #ifdef _DEBUG_ debug(" current_state is PENDING, inferred from empty plugin output on Jan 1 1970"); #endif /* PENDING... is really UP with NULL plugin output on Jan 1 1970... */ free(host_list[host_list_size][STATUS]); host_list[host_list_size][STATUS] = malloc(8); strncpy(host_list[host_list_size][STATUS],"PENDING",8); free(host_list[host_list_size][PLUGIN_OUTPUT]); host_list[host_list_size][PLUGIN_OUTPUT] = malloc(25); strncpy(host_list[host_list_size][PLUGIN_OUTPUT],"(Host assumed to be up)",25); perl_hook(HOST_PLUGIN_HOOK,host_list[host_list_size][PLUGIN_OUTPUT]); host_stamp = last_update_int; host_list[host_list_size][LAST_STATE_CHANGE_INT] = (char *)(last_update_int); host_list[host_list_size][LAST_STATE_CHANGE] = malloc(17); strncpy(host_list[host_list_size][LAST_STATE_CHANGE]," not applicable ",16); } else { host_list[host_list_size][LAST_STATE_CHANGE_INT] = (char *)host_stamp; host_list[host_list_size][LAST_STATE_CHANGE] = malloc(17); /* "DOW Mon DD HH:MM\0" */ strncpy(host_list[host_list_size][LAST_STATE_CHANGE],ctime((time_t *)&host_stamp),16); } host_list[host_list_size][LAST_STATE_CHANGE][16] = '\0'; #ifdef _DEBUG_ debug(" last_state_change is \"%s\" (%d)", host_list[host_list_size][LAST_STATE_CHANGE], (int)host_list[host_list_size][LAST_STATE_CHANGE_INT]); #endif /*--------------------*/ /* DURATION... */ host_list[host_list_size][DURATION] = (char *)calc_duration(host_stamp); #ifdef _DEBUG_ debug(" duration is \"%s\"",host_list[host_list_size][DURATION]); #endif /*--------------------*/ /* Other stuff... */ host_idx_to_level[host_list_size] = convert_level(host_list[host_list_size][STATUS]); switch(host_idx_to_level[host_list_size]) { case UP: num_up++; break; case DOWN: num_down++; break; } #if 0 debug("HOST idx=%d: NAME=%s STATUS=%s LAST_CHANGE=%s", host_list_size, host_list[host_list_size][HOST_NAME], host_list[host_list_size][STATUS], host_list[host_list_size][LAST_STATE_CHANGE] ); #endif host_list_size++; if ( host_list_size > MAX_ITEMS ) { endwin(); printf("fatal error: too many hosts!\n"); printf("increase MAX_ITEMS in cnagios.h\n"); exit(1); } continue; } /*--------------------------------------------------------*/ /* SERVICE object... */ if ( (!strcmp("service",ent.lhs)) || (!strcmp("servicestatus",ent.lhs)) ) { /*--------------------*/ /* HOST_NAME... */ fgets(buffer,sizeof(buffer),fp); line++; parse_entry(&ent,buffer); while ( !feof(fp) && strcmp(ent.lhs,"host_name") != 0 ) { fgets(buffer,sizeof(buffer),fp); line++; parse_entry(&ent,buffer); if ( !strcmp(ent.lhs,"fail") ) { endwin(); printf("fatal error: %s: could not find \"host_name\" for service stanza preceeding line %d\n", STATUS_DAT_FILE, line); exit(1); } } if ( strcmp(ent.lhs,"host_name") ) { endwin(); printf("fatal error: %s: could not find \"host_name\" for service stanza preceeding line %d\n", STATUS_DAT_FILE, line); exit(1); } service_list[service_list_size][HOST_NAME] = malloc(strlen(ent.rhs)+1); strncpy(service_list[service_list_size][HOST_NAME],ent.rhs,strlen(ent.rhs)+1); #ifdef _DEBUG_ debug("SERVICE NUMBER %d...",service_list_size); debug(" host_name is \"%s\"",service_list[service_list_size][HOST_NAME]); #endif /*--------------------*/ /* SERVICE_NAME... */ fgets(buffer,sizeof(buffer),fp); line++; parse_entry(&ent,buffer); while ( !feof(fp) && strcmp(ent.lhs,"service_description") != 0 ) { fgets(buffer,sizeof(buffer),fp); line++; parse_entry(&ent,buffer); if ( !strcmp(ent.lhs,"fail") ) { endwin(); printf("fatal error: %s: could not find \"service_description\" for service stanza preceeding line %d\n", STATUS_DAT_FILE, line); exit(1); } } if ( strcmp(ent.lhs,"service_description") ) { endwin(); printf("fatal error: %s: could not find \"service_description\" for service stanza preceeding line %d\n", STATUS_DAT_FILE, line); exit(1); } service_list[service_list_size][SERVICE_NAME] = malloc(strlen(ent.rhs)+1+strlen(service_list[service_list_size][HOST_NAME])+1); snprintf(service_list[service_list_size][SERVICE_NAME],(strlen(ent.rhs)+1+strlen(service_list[service_list_size][HOST_NAME])+1),"%s %s ", service_list[service_list_size][HOST_NAME],ent.rhs); perl_hook(SERVICE_PLUGIN_HOOK,service_list[service_list_size][SERVICE_NAME]); #ifdef _DEBUG_ debug(" raw service_description is \"%s\"",ent.rhs); debug(" munged service_description is \"%s\"",service_list[service_list_size][SERVICE_NAME]); #endif /*--------------------*/ /* STATUS... */ fgets(buffer,sizeof(buffer),fp); line++; parse_entry(&ent,buffer); while ( !feof(fp) && strcmp(ent.lhs,"current_state") != 0 ) { fgets(buffer,sizeof(buffer),fp); line++; parse_entry(&ent,buffer); if ( !strcmp(ent.lhs,"fail") ) { endwin(); printf("fatal error: %s: could not find \"current_state\" for service stanza preceeding line %d\n", STATUS_DAT_FILE, line); exit(1); } } if ( strcmp(ent.lhs,"current_state") ) { endwin(); printf("fatal error: %s: could not find \"current_state\" for service stanza preceeding line %d\n", STATUS_DAT_FILE, line); exit(1); } switch(ent.rhs[0]) { case NAGIOS_STATE_OK: service_list[service_list_size][STATUS] = malloc(5); strncpy(service_list[service_list_size][STATUS],"OKAY",5); break; case NAGIOS_STATE_WARNING: service_list[service_list_size][STATUS] = malloc(8); strncpy(service_list[service_list_size][STATUS],"WARNING",8); break; case NAGIOS_STATE_CRITICAL: service_list[service_list_size][STATUS] = malloc(9); strncpy(service_list[service_list_size][STATUS],"CRITICAL",9); break; case NAGIOS_STATE_UNKNOWN: service_list[service_list_size][STATUS] = malloc(8); strncpy(service_list[service_list_size][STATUS],"UNKNOWN",8); break; } #ifdef _DEBUG_ debug(" current_state is %s",service_list[service_list_size][STATUS]); #endif /*--------------------*/ /* LAST_STATE_CHANGE... */ fgets(buffer,sizeof(buffer),fp); line++; parse_entry(&ent,buffer); while ( !feof(fp) && strcmp(ent.lhs,"last_state_change") != 0 ) { fgets(buffer,sizeof(buffer),fp); line++; parse_entry(&ent,buffer); if ( !strcmp(ent.lhs,"fail") ) { endwin(); printf("fatal error: %s: could not find \"last_state_change\" for service stanza preceeding line %d\n", STATUS_DAT_FILE, line); exit(1); } } if ( strcmp(ent.lhs,"last_state_change") ) { endwin(); printf("fatal error: %s: could not find \"last_state_change\" for service stanza preceeding line %d\n", STATUS_DAT_FILE, line); exit(1); } sscanf(ent.rhs,"%d",&service_stamp); service_list[service_list_size][LAST_STATE_CHANGE_INT] = (char *)service_stamp; service_list[service_list_size][LAST_STATE_CHANGE] = malloc(17); /* "DOW Mon DD HH:MM\0" */ strncpy(service_list[service_list_size][LAST_STATE_CHANGE],ctime((time_t *)&service_stamp),16); service_list[service_list_size][LAST_STATE_CHANGE][16] = '\0'; #ifdef _DEBUG_ debug(" last_state_change is \"%s\" (%d)", service_list[service_list_size][LAST_STATE_CHANGE], (int)service_list[service_list_size][LAST_STATE_CHANGE_INT]); #endif /*--------------------*/ /* DURATION... */ service_list[service_list_size][DURATION] = (char *)calc_duration(service_stamp); #ifdef _DEBUG_ debug(" duration is \"%s\"",service_list[service_list_size][DURATION]); #endif /*--------------------*/ /* PLUGIN_OUTPUT... */ fgets(buffer,sizeof(buffer),fp); line++; parse_entry(&ent,buffer); while ( !feof(fp) && strcmp(ent.lhs,"plugin_output") != 0 ) { fgets(buffer,sizeof(buffer),fp); line++; parse_entry(&ent,buffer); if ( !strcmp(ent.lhs,"fail") ) { endwin(); printf("fatal error: %s: could not find \"plugin_output\" for service stanza preceeding line %d\n", STATUS_DAT_FILE, line); exit(1); } } if ( strcmp(ent.lhs,"plugin_output") ) { endwin(); printf("fatal error: %s: could not find \"plugin_output\" for service stanza preceeding line %d\n", STATUS_DAT_FILE, line); exit(1); } service_list[service_list_size][PLUGIN_OUTPUT] = malloc(strlen(ent.rhs)+1); strncpy(service_list[service_list_size][PLUGIN_OUTPUT],ent.rhs,strlen(ent.rhs)+1); perl_hook(SERVICE_PLUGIN_HOOK,service_list[service_list_size][PLUGIN_OUTPUT]); #ifdef _DEBUG_ debug(" raw plugin_output is \"%s\"",ent.rhs); debug(" munged plugin_output is \"%s\"",service_list[service_list_size][PLUGIN_OUTPUT]); #endif /* PENDING is really OKAY w/ "(Service assumed to be ok)" on Jan 1 1970... */ if ( (service_stamp == 0) && (!strcmp("(Service assumed to be ok)",ent.rhs)) ) { #ifdef _DEBUG_ debug(" current_state is PENDING, inferred from \"(Service assumed to be ok)\" on Jan 1 1970"); #endif free(service_list[service_list_size][STATUS]); service_list[service_list_size][STATUS] = malloc(8); strncpy(service_list[service_list_size][STATUS],"PENDING",8); service_stamp = last_update_int; service_list[service_list_size][LAST_STATE_CHANGE_INT] = (char *)service_stamp; service_list[service_list_size][LAST_STATE_CHANGE] = malloc(17); /* "DOW Mon DD HH:MM\0" */ strncpy(service_list[service_list_size][LAST_STATE_CHANGE]," not applicable ",17); service_list[service_list_size][DURATION] = (char *)calc_duration(service_stamp); } /*--------------------*/ /* Other stuff... */ service_idx_to_level[service_list_size] = convert_level(service_list[service_list_size][STATUS]); switch(service_idx_to_level[service_list_size]) { case 0: num_okay++; break; case 1: num_warn++; break; case 2: num_crit++; break; } #if 0 debug("SERVICE idx=%d: NAME=%s SERVICE=%s STATUS=%s LAST_CHANGE=%s", service_list_size, service_list[service_list_size][HOST_NAME], service_list[service_list_size][SERVICE_NAME], service_list[service_list_size][STATUS], service_list[service_list_size][LAST_STATE_CHANGE] ); #endif service_list_size++; if ( service_list_size > MAX_ITEMS ) { endwin(); printf("fatal error: too many services!\n"); printf("increase MAX_ITEMS in cnagios.h\n"); exit(1); } continue; } } /*--------------------------------------------------------*/ fclose(fp); #if _DEBUG_ debug("done with read_v23_status()"); #endif }
Dict* dict_text_new(const char* filename) { TextDict* text_dictionary; text_dictionary = (TextDict*)malloc(sizeof(TextDict)); text_dictionary->entry_count = INITIAL_DICTIONARY_SIZE; text_dictionary->max_length = 0; text_dictionary->lexicon = (TextEntry*)malloc( sizeof(TextEntry) * text_dictionary->entry_count); text_dictionary->word_buff = NULL; static char buff[ENTRY_BUFF_SIZE]; FILE* fp = fopen(filename, "r"); if (fp == NULL) { dict_text_delete((Dict*)text_dictionary); return (Dict*)-1; } skip_utf8_bom(fp); size_t i = 0; while (fgets(buff, ENTRY_BUFF_SIZE, fp)) { if (i >= text_dictionary->entry_count) { text_dictionary->entry_count += text_dictionary->entry_count; text_dictionary->lexicon = (TextEntry*)realloc( text_dictionary->lexicon, sizeof(TextEntry) * text_dictionary->entry_count ); } if (parse_entry(buff, text_dictionary->lexicon + i) == -1) { text_dictionary->entry_count = i; dict_text_delete((Dict*)text_dictionary); return (Dict*)-1; } size_t length = ucs4len(text_dictionary->lexicon[i].key); if (length > text_dictionary->max_length) { text_dictionary->max_length = length; } i++; } fclose(fp); text_dictionary->entry_count = i; text_dictionary->lexicon = (TextEntry*)realloc( text_dictionary->lexicon, sizeof(TextEntry) * text_dictionary->entry_count ); text_dictionary->word_buff = (ucs4_t*) malloc(sizeof(ucs4_t) * (text_dictionary->max_length + 1)); qsort(text_dictionary->lexicon, text_dictionary->entry_count, sizeof(text_dictionary->lexicon[0]), qsort_entry_cmp ); return (Dict*)text_dictionary; }