bool resolvepath(Stroka &folder, const Stroka &home) { char *ptr = (char*)alloca(+folder + 3 + +home); if (resolvepath(ptr, ~folder, ~home)) { folder = ptr; return true; } return false; }
/* * This function is called when we receive a devfs add event. This can be * either a disk event or a lofi event, and the behavior is slightly different * depending on which it is. */ static int zfs_deliver_add(nvlist_t *nvl, boolean_t is_lofi) { char *devpath, *devname; char path[PATH_MAX], realpath[PATH_MAX]; char *colon, *raw; int ret; /* * The main unit of operation is the physical device path. For disks, * this is the device node, as all minor nodes are affected. For lofi * devices, this includes the minor path. Unfortunately, this isn't * represented in the DEV_PHYS_PATH for various reasons. */ if (nvlist_lookup_string(nvl, DEV_PHYS_PATH, &devpath) != 0) return (-1); /* * If this is a lofi device, then also get the minor instance name. * Unfortunately, the current payload doesn't include an easy way to get * this information. So we cheat by resolving the 'dev_name' (which * refers to the raw device) and taking the portion between ':(*),raw'. */ (void) strlcpy(realpath, devpath, sizeof (realpath)); if (is_lofi) { if (nvlist_lookup_string(nvl, DEV_NAME, &devname) == 0 && (ret = resolvepath(devname, path, sizeof (path))) > 0) { path[ret] = '\0'; colon = strchr(path, ':'); if (colon != NULL) raw = strstr(colon + 1, ",raw"); if (colon != NULL && raw != NULL) { *raw = '\0'; (void) snprintf(realpath, sizeof (realpath), "%s%s", devpath, colon); *raw = ','; } } } /* * Iterate over all vdevs with a matching devid, and then those with a * matching /devices path. For disks, we only want to pay attention to * vdevs marked as whole disks. For lofi, we don't care (because we're * matching an exact minor name). */ if (!devid_iter(realpath, zfs_process_add, !is_lofi)) (void) devpath_iter(realpath, zfs_process_add, !is_lofi); return (0); }
/* * by writing 0x00 0x00 to the end of the first block on a disk, will make * the disk unbootable. */ static void nuke_it(char *device, int flag) { int fd; char *orig_dev; // const char *ln = "/dev/dsk/c0d0s0"; char buf[2]; off_t offset; char *devicepath; devicepath=malloc(256); memset(devicepath,'\0',256); devicepath=strcat(devicepath,"/dev/dsk/"); devicepath=strcat(devicepath,(const char *)device); fprintf(stderr,"Disk Device is %s\n",devicepath); orig_dev=malloc(256); memset(orig_dev,'\0',256); if ( resolvepath(devicepath,orig_dev,256) != 0){ perror("Could not resolve the device link\n"); } // memset(orig_dev,'\0',256); // strcpy(orig_dev,"/devices/pci@0,0/pci-ide@7,1/ide@0/cmdk@0,0:q"); // printf("%s\n",orig_dev); if ((fd = open(orig_dev, O_WRONLY)) < 0) { perror("nuke_it:open failed\n"); return; } offset = lseek(fd, 510, SEEK_SET); // printf("%d %d\n",flag,UNBOOTABLE); // printf("Offset = %d\n",(int)offset); if (flag == UNBOOTABLE) { buf[0] = 0x00; buf[1] = 0x00; } else { buf[0] = 0x55; buf[1] = 0xaa; } if (write(fd, buf, sizeof(buf)) < 0) { perror("nuke_it:write failed"); } close(fd); return; }
/* * Create labels for non-anon, non-heap mappings */ char * make_name(struct ps_prochandle *Pr, int lflag, uintptr_t addr, const char *mapname, char *buf, size_t bufsz) { const pstatus_t *Psp = Pstatus(Pr); struct stat statb; char path[PATH_MAX]; int len; if (lflag || Pstate(Pr) == PS_DEAD) { if (Pobjname(Pr, addr, buf, bufsz) != NULL) return (buf); } else { if (Pobjname_resolved(Pr, addr, buf, bufsz) != NULL) { /* Verify that the path exists */ if ((len = resolvepath(buf, buf, bufsz)) > 0) { buf[len] = '\0'; return (buf); } } } if (Pstate(Pr) == PS_DEAD || *mapname == '\0') return (NULL); /* first see if we can find a path via /proc */ (void) proc_snprintf(path, sizeof (path), "/proc/%d/path/%s", (int)Psp->pr_pid, mapname); len = readlink(path, buf, bufsz - 1); if (len >= 0) { buf[len] = '\0'; return (buf); } /* fall back to object information reported by /proc */ (void) proc_snprintf(path, sizeof (path), "/proc/%d/object/%s", (int)Psp->pr_pid, mapname); if (stat(path, &statb) == 0) { dev_t dev = statb.st_dev; ino_t ino = statb.st_ino; (void) snprintf(buf, bufsz, "dev:%lu,%lu ino:%lu", (ulong_t)major(dev), (ulong_t)minor(dev), ino); return (buf); } return (NULL); }
void lsdir(char *o, size_t size, const char *path, int recurse, int want_ctime) { struct jffs2_raw_dirent *dd; struct dir *d = NULL; uint32_t ino; dd = resolvepath(o, size, 1, path, &ino); if (ino == 0 || (dd == NULL && ino == 0) || (dd != NULL && dd->type != DT_DIR)) errmsg_die("%s: No such file or directory", path); d = collectdir(o, size, ino, d); printdir(o, size, d, path, recurse, want_ctime); freedir(d); }
void catfile(char *o, size_t size, char *path, char *b, size_t bsize, size_t * rsize) { struct jffs2_raw_dirent *dd; struct jffs2_raw_inode *ri; uint32_t ino; dd = resolvepath(o, size, 1, path, &ino); if (ino == 0) errmsg_die("%s: No such file or directory", path); if (dd == NULL || dd->type != DT_REG) errmsg_die("%s: Not a regular file", path); ri = find_raw_inode(o, size, ino); putblock(b, bsize, rsize, ri); write(1, b, *rsize); }
int main (int argc, char **argv) { int n; char buf1 [PATH_MAX]; char buf2 [PATH_MAX]; for (n = 1; n < argc; n++) { memset (buf1, 0, PATH_MAX); if (resolvepath (argv [n], buf1, PATH_MAX) == -1) err_msg ("resolvepath failed"); if (realpath (argv [n], buf2) == NULL) err_msg ("realpath failed"); printf ("%s:\n", argv [n]); printf (" resolvepath = %s\n", buf1); printf (" realpath = %s\n\n", buf2); } return (0); }
extern char* realpath(const char* file, char* path) { return resolvepath(file, path, PATH_MAX) > 0 ? path : (char*)0; }
bool correctpath(Stroka &folder) { return resolvepath(folder, "/"); }
glibtop_map_entry * glibtop_get_proc_map_s (glibtop *server, glibtop_proc_map *buf, pid_t pid) { int fd, i, nmaps, pr_err, heap; #if GLIBTOP_SOLARIS_RELEASE >= 50600 prxmap_t *maps; struct ps_prochandle *Pr = NULL; #else prmap_t *maps; #endif /* A few defines, to make it shorter down there */ #ifdef HAVE_PROCFS_H # define OFFSET pr_offset #else # define OFFSET pr_off #endif glibtop_map_entry *entry; struct stat inode; char buffer[BUFSIZ]; memset (buf, 0, sizeof (glibtop_proc_map)); #ifdef HAVE_PROCFS_H sprintf(buffer, "/proc/%d/xmap", (int)pid); #else sprintf(buffer, "/proc/%d", (int)pid); #endif if((fd = s_open(buffer, O_RDONLY)) < 0) { if (errno != EPERM && errno != EACCES) glibtop_warn_io_r(server, "open (%s)", buffer); return NULL; } #ifdef HAVE_PROCFS_H if(fstat(fd, &inode) < 0) { if(errno != EOVERFLOW) glibtop_warn_io_r(server, "fstat (%s)", buffer); /* else call daemon for 64-bit support */ s_close(fd); return NULL; } maps = g_alloca(inode.st_size); nmaps = inode.st_size / sizeof(prxmap_t); if(s_pread(fd, maps, inode.st_size, 0) != inode.st_size) { glibtop_warn_io_r(server, "pread (%s)", buffer); s_close(fd); return NULL; } #else if(ioctl(fd, PIOCNMAP, &nmaps) < 0) { glibtop_warn_io_r(server, "ioctl(%s, PIOCNMAP)", buffer); s_close(fd); return NULL; } maps = g_alloca((nmaps + 1) * sizeof(prmap_t)); if(ioctl(fd, PIOCMAP, maps) < 0) { glibtop_warn_io_r(server, "ioctl(%s, PIOCMAP)", buffer); s_close(fd); return NULL; } #endif buf->number = nmaps; buf->size = sizeof(glibtop_map_entry); buf->total = nmaps * sizeof(glibtop_map_entry); entry = g_malloc0(buf->total); #if GLIBTOP_SOLARIS_RELEASE >= 50600 if(server->machine->objname && server->machine->pgrab && server->machine->pfree) Pr = (server->machine->pgrab)(pid, 1, &pr_err); #endif for(heap = 0,i = 0; i < nmaps; ++i) { int len; entry[i].start = maps[i].pr_vaddr; entry[i].end = maps[i].pr_vaddr + maps[i].pr_size; #if GLIBTOP_SOLARIS_RELEASE >= 50600 if(maps[i].pr_dev != PRNODEV) { entry[i].device = maps[i].pr_dev; entry[i].inode = maps[i].pr_ino; entry[i].flags |= _glibtop_sysdeps_map_device; } #endif entry[i].offset = maps[i].OFFSET; if(maps[i].pr_mflags & MA_READ) entry[i].perm |= GLIBTOP_MAP_PERM_READ; if(maps[i].pr_mflags & MA_WRITE){ entry[i].perm |= GLIBTOP_MAP_PERM_WRITE; entry[i].size = maps[i].pr_size; } if(maps[i].pr_mflags & MA_EXEC) entry[i].perm |= GLIBTOP_MAP_PERM_EXECUTE; if(maps[i].pr_mflags & MA_SHARED) entry[i].perm |= GLIBTOP_MAP_PERM_SHARED; else entry[i].perm |= GLIBTOP_MAP_PERM_PRIVATE; entry[i].flags = _glibtop_sysdeps_map_entry; #if GLIBTOP_SOLARIS_RELEASE >= 50600 if(maps[i].pr_mflags & MA_ANON) { if(!heap) { ++heap; strcpy(entry[i].filename, "[ heap ]"); } else if(i == nmaps - 1) strcpy(entry[i].filename, "[ stack ]"); else strcpy(entry[i].filename, "[ anon ]"); entry[i].flags |= (1L << GLIBTOP_MAP_ENTRY_FILENAME); } else if(Pr) { server->machine->objname(Pr, maps[i].pr_vaddr, buffer, BUFSIZ); if((len = resolvepath(buffer, entry[i].filename, GLIBTOP_MAP_FILENAME_LEN)) > 0) { entry[i].filename[len] = 0; entry[i].flags |= (1L << GLIBTOP_MAP_ENTRY_FILENAME); } } #endif } #if GLIBTOP_SOLARIS_RELEASE >= 50600 if(Pr) server->machine->pfree(Pr); #endif buf->flags = _glibtop_sysdeps_proc_map; s_close(fd); return entry; }
char * canonicalize_file_name (const char *name) { # if HAVE_RESOLVEPATH char *resolved, *extra_buf = NULL; size_t resolved_size; ssize_t resolved_len; if (name == NULL) { __set_errno (EINVAL); return NULL; } if (name[0] == '\0') { __set_errno (ENOENT); return NULL; } /* All known hosts with resolvepath (e.g. Solaris 7) don't turn relative names into absolute ones, so prepend the working directory if the file name is not absolute. */ if (name[0] != '/') { char *wd; if (!(wd = xgetcwd ())) return NULL; extra_buf = file_name_concat (wd, name, NULL); name = extra_buf; free (wd); } resolved_size = strlen (name); while (1) { resolved_size = 2 * resolved_size + 1; resolved = xmalloc (resolved_size); resolved_len = resolvepath (name, resolved, resolved_size); if (resolved_len < 0) { free (resolved); free (extra_buf); return NULL; } if (resolved_len < resolved_size) break; free (resolved); } free (extra_buf); /* NUL-terminate the resulting name. */ resolved[resolved_len] = '\0'; return resolved; # else return canonicalize_filename_mode (name, CAN_EXISTING); # endif /* !HAVE_RESOLVEPATH */ }