// Check whether the given entity has illegal parts static ast_result_t syntax_entity(ast_t* ast, int entity_def_index) { assert(ast != NULL); assert(entity_def_index >= 0 && entity_def_index < DEF_ENTITY_COUNT); ast_result_t r = AST_OK; const permission_def_t* def = &_entity_def[entity_def_index]; AST_GET_CHILDREN(ast, id, typeparams, defcap, provides, members, c_api); // Check if we're called Main if(def->permissions[ENTITY_MAIN] == 'N' && ast_name(id) == stringtab("Main")) { ast_error(ast, "Main must be an actor"); r = AST_ERROR; } if(!check_id_type(id, def->desc)) r = AST_ERROR; if(!check_permission(def, ENTITY_CAP, defcap, "default capability", defcap)) r = AST_ERROR; if(!check_permission(def, ENTITY_C_API, c_api, "C api", c_api)) r = AST_ERROR; if(ast_id(c_api) == TK_AT) { if(ast_id(typeparams) != TK_NONE) { ast_error(typeparams, "generic actor cannot specify C api"); r = AST_ERROR; } } if(entity_def_index != DEF_TYPEALIAS) { // Check referenced traits if(ast_id(provides) != TK_NONE && !check_provides_type(provides, "provides")) r = AST_ERROR; } else { // Check for a type alias if(ast_id(provides) == TK_NONE) { ast_error(provides, "a type alias must specify a type"); r = AST_ERROR; } } // Check for illegal members if(!check_members(members, entity_def_index)) r = AST_ERROR; return r; }
static ast_result_t syntax_object(pass_opt_t* opt, ast_t* ast) { assert(ast_id(ast) == TK_OBJECT); AST_GET_CHILDREN(ast, cap, provides, members); // Check for illegal members - even though object literals can be non-actors, // we use DEF_ACTOR because the permissions are close enough for our purposes. if(!check_members(opt, members, DEF_ACTOR)) return AST_ERROR; return AST_OK; }
/* * check_sgr_file - check the content of the shadowed group file (gshadow) */ static void check_sgr_file (int *errors, bool *changed) { struct group *grp; struct commonio_entry *sge, *tsge; struct sgrp *sgr; /* * Loop through the entire shadow group file. */ for (sge = __sgr_get_head (); NULL != sge; sge = sge->next) { /* * Start with the entries that are completely corrupt. They * have no (struct sgrp) entry because they couldn't be * parsed properly. */ if (NULL == sge->eptr) { /* * Tell the user this entire line is bogus and ask * them to delete it. */ (void) puts (_("invalid shadow group file entry")); printf (_("delete line '%s'? "), sge->line); *errors += 1; /* * prompt the user to delete the entry or not */ if (!yes_or_no (read_only)) { continue; } /* * All shadow group file deletions wind up here. * This code removes the current entry from the * linked list. When done, it skips back to the top * of the loop to try out the next list element. */ delete_sg: SYSLOG ((LOG_INFO, "delete shadow line '%s'", sge->line)); *changed = true; __sgr_del_entry (sge); continue; } /* * Shadow group structure is good, start using it. */ sgr = sge->eptr; /* * Make sure this entry has a unique name. */ for (tsge = __sgr_get_head (); NULL != tsge; tsge = tsge->next) { const struct sgrp *ent = tsge->eptr; /* * Don't check this entry */ if (tsge == sge) { continue; } /* * Don't check invalid entries. */ if (NULL == ent) { continue; } if (strcmp (sgr->sg_name, ent->sg_name) != 0) { continue; } /* * Tell the user this entry is a duplicate of * another and ask them to delete it. */ (void) puts (_("duplicate shadow group entry")); printf (_("delete line '%s'? "), sge->line); *errors += 1; /* * prompt the user to delete the entry or not */ if (yes_or_no (read_only)) { goto delete_sg; } } /* * Make sure this entry exists in the /etc/group file. */ grp = (struct group *) gr_locate (sgr->sg_name); if (grp == NULL) { printf (_("no matching group file entry in %s\n"), grp_file); printf (_("delete line '%s'? "), sge->line); *errors += 1; if (yes_or_no (read_only)) { goto delete_sg; } } else { /** * Verify that the all members defined in /etc/gshadow are also * present in /etc/group. */ compare_members_lists (sgr->sg_name, sgr->sg_mem, grp->gr_mem, sgr_file, grp_file); } /* * Make sure each administrator exists */ if (check_members (sgr->sg_name, sgr->sg_adm, _("shadow group %s: no administrative user %s\n"), _("delete administrative member '%s'? "), "delete admin '%s' from shadow group '%s'", errors) == 1) { *changed = true; sge->changed = true; __sgr_set_changed (); } /* * Make sure each member exists */ if (check_members (sgr->sg_name, sgr->sg_mem, _("shadow group %s: no user %s\n"), _("delete member '%s'? "), "delete member '%s' from shadow group '%s'", errors) == 1) { *changed = true; sge->changed = true; __sgr_set_changed (); } } }
/* * check_grp_file - check the content of the group file */ static void check_grp_file (int *errors, bool *changed) { struct commonio_entry *gre, *tgre; struct group *grp; #ifdef SHADOWGRP struct sgrp *sgr; #endif /* * Loop through the entire group file. */ for (gre = __gr_get_head (); NULL != gre; gre = gre->next) { /* * Skip all NIS entries. */ if ((gre->line[0] == '+') || (gre->line[0] == '-')) { continue; } /* * Start with the entries that are completely corrupt. They * have no (struct group) entry because they couldn't be * parsed properly. */ if (NULL == gre->eptr) { /* * Tell the user this entire line is bogus and ask * them to delete it. */ (void) puts (_("invalid group file entry")); printf (_("delete line '%s'? "), gre->line); *errors += 1; /* * prompt the user to delete the entry or not */ if (!yes_or_no (read_only)) { continue; } /* * All group file deletions wind up here. This code * removes the current entry from the linked list. * When done, it skips back to the top of the loop * to try out the next list element. */ delete_gr: SYSLOG ((LOG_INFO, "delete group line '%s'", gre->line)); *changed = true; __gr_del_entry (gre); continue; } /* * Group structure is good, start using it. */ grp = gre->eptr; /* * Make sure this entry has a unique name. */ for (tgre = __gr_get_head (); NULL != tgre; tgre = tgre->next) { const struct group *ent = tgre->eptr; /* * Don't check this entry */ if (tgre == gre) { continue; } /* * Don't check invalid entries. */ if (NULL == ent) { continue; } if (strcmp (grp->gr_name, ent->gr_name) != 0) { continue; } /* * Tell the user this entry is a duplicate of * another and ask them to delete it. */ (void) puts (_("duplicate group entry")); printf (_("delete line '%s'? "), gre->line); *errors += 1; /* * prompt the user to delete the entry or not */ if (yes_or_no (read_only)) { goto delete_gr; } } /* * Check for invalid group names. --marekm */ if (!is_valid_group_name (grp->gr_name)) { *errors += 1; printf (_("invalid group name '%s'\n"), grp->gr_name); } /* * Check for invalid group ID. */ if (grp->gr_gid == (gid_t)-1) { printf (_("invalid group ID '%lu'\n"), (long unsigned int)grp->gr_gid); *errors += 1; } /* * Workaround for a NYS libc 5.3.12 bug on RedHat 4.2 - * groups with no members are returned as groups with one * member "", causing grpck to fail. --marekm */ if ( (NULL != grp->gr_mem[0]) && (NULL == grp->gr_mem[1]) && ('\0' == grp->gr_mem[0][0])) { grp->gr_mem[0] = NULL; } if (check_members (grp->gr_name, grp->gr_mem, _("group %s: no user %s\n"), _("delete member '%s'? "), "delete member '%s' from group '%s'", errors) == 1) { *changed = true; gre->changed = true; __gr_set_changed (); } #ifdef SHADOWGRP /* * Make sure this entry exists in the /etc/gshadow file. */ if (is_shadow) { sgr = (struct sgrp *) sgr_locate (grp->gr_name); if (sgr == NULL) { printf (_("no matching group file entry in %s\n"), sgr_file); printf (_("add group '%s' in %s? "), grp->gr_name, sgr_file); *errors += 1; if (yes_or_no (read_only)) { struct sgrp sg; struct group gr; static char *empty = NULL; sg.sg_name = grp->gr_name; sg.sg_passwd = grp->gr_passwd; sg.sg_adm = ∅ sg.sg_mem = grp->gr_mem; SYSLOG ((LOG_INFO, "add group '%s' to '%s'", grp->gr_name, sgr_file)); *changed = true; if (sgr_update (&sg) == 0) { fprintf (stderr, _("%s: failed to prepare the new %s entry '%s'\n"), Prog, sgr_dbname (), sg.sg_name); fail_exit (E_CANT_UPDATE); } /* remove password from /etc/group */ gr = *grp; gr.gr_passwd = SHADOW_PASSWD_STRING; /* XXX warning: const */ if (gr_update (&gr) == 0) { fprintf (stderr, _("%s: failed to prepare the new %s entry '%s'\n"), Prog, gr_dbname (), gr.gr_name); fail_exit (E_CANT_UPDATE); } } } else { /** * Verify that all the members defined in /etc/group are also * present in /etc/gshadow. */ compare_members_lists (grp->gr_name, grp->gr_mem, sgr->sg_mem, grp_file, sgr_file); /* The group entry has a gshadow counterpart. * Make sure no passwords are in group. */ if (strcmp (grp->gr_passwd, SHADOW_PASSWD_STRING) != 0) { printf (_("group %s has an entry in %s, but its password field in %s is not set to 'x'\n"), grp->gr_name, sgr_file, grp_file); *errors += 1; } } } #endif } }