/* This function sets up the standard parts of the fs_tab. */ static struct fstable * fs_tab_init(char *mountp, char *fstype) { struct fstable *nfte; /* Create the array if necessary. */ if (fs_list == -1) { fs_list = ar_create(ALLOC_CHUNK, (unsigned)sizeof (struct fstable), "filesystem mount data"); if (fs_list == -1) { progerr(ERR_MALLOC, "fs_list", errno, strerror(errno)); return (NULL); } } /* * Allocate an fstable entry for this mnttab entry. */ if ((nfte = *(struct fstable **)ar_next_avail(fs_list)) == NULL) { progerr(ERR_MALLOC, "nfte", errno, strerror(errno)); return (NULL); } /* * Point fs_tab at the head of the array again, since it may have * moved due to realloc in ar_next_avail(). If ar_next_avail() realizes * that there is no more room to grow the array, it reallocates the * array. Because we stored pointer to that array in fs_tab, we need * to make sure that it is updated as well. */ if ((fs_tab = (struct fstable **)ar_get_head(fs_list)) == NULL) { progerr(ERR_NOTABLE, "mount", MOUNT_TABLE, strerror(errno)); return (NULL); } /* * Get the length of the 'mount point' name. */ nfte->namlen = strlen(mountp); /* * Allocate space for the 'mount point' name. */ if ((nfte->name = malloc(nfte->namlen+1)) == NULL) { progerr(ERR_MALLOC, "name", errno, strerror(errno)); return (NULL); } (void) strcpy(nfte->name, mountp); if ((nfte->fstype = malloc(strlen(fstype)+1)) == NULL) { progerr(ERR_MALLOC, "fstype", errno, strerror(errno)); return (NULL); } (void) strcpy(nfte->fstype, fstype); fs_tab_used++; return (nfte); }
/* * Free up the entry in the array indicated by index, but hold onto it for * future use. */ int ar_delete(int list_handle, int index) { char **array; char *deleted_rec; int i; struct blk_list_cs *list_ptr, *data_ptr; if ((array = ar_get_head(list_handle)) == NULL) return (0); if (invalid_record(list_handle, index)) return (0); /* Get the pointer to the array control structure. */ list_ptr = bl_cs_array[list_handle]; if (!(list_ptr->contiguous)) return (0); /* This isn't an array. */ data_ptr = bl_cs_array[list_ptr->data_handle]; /* * Since this looks just like an array. Record the pointer being * deleted for insertion into the avail list at the end and move all * elements below it up one. */ deleted_rec = array[index]; for (i = index; array[i] != NULL; i++) array[i] = array[i+1]; /* * Now insert the deleted entry into the avails list after the NULL * and adjust the avail_ptr to point to the NULL again. */ array[i] = deleted_rec; list_ptr->alloc_segs->avail_ptr -= list_ptr->struct_size; /* Adjust other entries in the control structure. */ list_ptr->alloc_segs->full = 0; list_ptr->total_elem -= 1; /* Clear the deleted data area. */ (void) memset(deleted_rec, '\000', data_ptr->struct_size); return (1); }
/* Insert a single class into the list. */ void addlist(struct cl_attr ***listp, char *item) { int i; /* If the list is already there, scan for this item */ if (*listp) { for (i = 0; (*listp)[i]; i++) if (strcmp(item, (*listp)[i]->name) == 0) return; } else { i = 0; } /* Insert the new entry */ if (new_cl_attr(item) == NULL) quit(99); /* Point the passed pointer to the head of the list. */ (*listp) = (struct cl_attr **)ar_get_head(cl_handle); }
/* * Create a list of all classes involved in this installation as well as * their attributes. */ int setlist(struct cl_attr ***plist, char *slist) { struct cl_attr **list, *struct_ptr; char *pt; int n; int i; int sn = -1; /* Initialize the environment scanners. */ (void) s_verify(NULL); (void) d_verify(NULL); (void) s_pathtype(NULL); n = 0; /* * This looks like a serious memory leak, however pkgmk depends on * this creating a second list and forgetting any prior ones. The * pkgmk utility does a reasonable job of keeping track of a prior * list constructed from the prototype file using addlist() above. * Perhaps this should be reviewed later, but I do not believe this * to be a problem from what I've seen. - JST */ cl_handle = -1; /* forget other lists */ /* Isolate the first token. */ pt = strtok(slist, " \t\n"); while (pt) { if (sn == -1 && strcmp(pt, "none") == 0) sn = n; /* Add new class to list. */ if ((struct_ptr = new_cl_attr(pt)) == NULL) quit(99); /* Next token. */ n++; pt = strtok(NULL, " \t\n"); if (pt && sn != -1) if (strcmp(pt, "none") == 0) pt = strtok(NULL, " \t\n"); } /* * According to the ABI, if there is a class "none", it will be * the first class to be installed. This insures that iff there * is a class "none", it will be the first to be installed. * If there is no class "none", nothing happens! */ new_order = 0; /* Get the head of the array. */ list = (struct cl_attr **)ar_get_head(cl_handle); if (sn > 0) { struct_ptr = list[sn]; for (i = sn; i > 0; i--) list[i] = list[i - 1]; list[0] = struct_ptr; new_order++; /* the order is different now */ } /* Point the passed pointer to the head of the list. */ *plist = list; return (n); }